diff --git a/README.md b/README.md index 3e2ff417e..a7a88254f 100755 --- a/README.md +++ b/README.md @@ -203,7 +203,7 @@ List of Definitions * [Riot.js](https://github.com/moot/riotjs) (by [vvakame](https://github.com/vvakame)) * [Restify](https://github.com/mcavage/node-restify) (by [Bret Little](https://github.com/blittle)) * [Royalslider](http://dimsemenov.com/plugins/royal-slider/) (by [Christiaan Rakowski](https://github.com/csrakowski)) -* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino)) +* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino), [Igor Oleinikov](https://github.com/Igorbek), [Carl de Billy](http://carl.debilly.net/), [zoetrope](https://github.com/zoetrope)) * [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall)) * [Restangular](https://github.com/mgonto/restangular/) (by [Boris Yankov](https://github.com/borisyankov)) * [require.js](http://requirejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/)) diff --git a/_infrastructure/tests/typescript/0.9.5/lib.d.ts b/_infrastructure/tests/typescript/0.9.5/lib.d.ts new file mode 100644 index 000000000..b0b5c96dd --- /dev/null +++ b/_infrastructure/tests/typescript/0.9.5/lib.d.ts @@ -0,0 +1,14202 @@ +/* ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +/// + +///////////////////////////// +/// ECMAScript APIs +///////////////////////////// + +declare var NaN: number; +declare var Infinity: number; + +/** + * Evaluates JavaScript code and executes it. + * @param x A String value that contains valid JavaScript code. + */ +declare function eval(x: string): any; + +/** + * Converts A string to an integer. + * @param s A string to convert into a number. + * @param radix A value between 2 and 36 that specifies the base of the number in numString. + * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal. + * All other strings are considered decimal. + */ +declare function parseInt(s: string, radix?: number): number; + +/** + * Converts a string to a floating-point number. + * @param string A string that contains a floating-point number. + */ +declare function parseFloat(string: string): number; + +/** + * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a number). + * @param number A numeric value. + */ +declare function isNaN(number: number): boolean; + +/** + * Determines whether a supplied number is finite. + * @param number Any numeric value. + */ +declare function isFinite(number: number): boolean; + +/** + * Gets the unencoded version of an encoded Uniform Resource Identifier (URI). + * @param encodedURI A value representing an encoded URI. + */ +declare function decodeURI(encodedURI: string): string; + +/** + * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI). + * @param encodedURIComponent A value representing an encoded URI component. + */ +declare function decodeURIComponent(encodedURIComponent: string): string; + +/** + * Encodes a text string as a valid Uniform Resource Identifier (URI) + * @param uri A value representing an encoded URI. + */ +declare function encodeURI(uri: string): string; + +/** + * Encodes a text string as a valid component of a Uniform Resource Identifier (URI). + * @param uriComponent A value representing an encoded URI component. + */ +declare function encodeURIComponent(uriComponent: string): string; + +interface PropertyDescriptor { + configurable?: boolean; + enumerable?: boolean; + value?: any; + writable?: boolean; + get? (): any; + set? (v: any): void; +} + +interface PropertyDescriptorMap { + [s: string]: PropertyDescriptor; +} + +interface Object { + /** Returns a string representation of an object. */ + toString(): string; + + /** Returns a date converted to a string using the current locale. */ + toLocaleString(): string; + + /** Returns the primitive value of the specified object. */ + valueOf(): Object; + + /** + * Determines whether an object has a property with the specified name. + * @param v A property name. + */ + hasOwnProperty(v: string): boolean; + + /** + * Determines whether an object exists in another object's prototype chain. + * @param v Another object whose prototype chain is to be checked. + */ + isPrototypeOf(v: Object): boolean; + + /** + * Determines whether a specified property is enumerable. + * @param v A property name. + */ + propertyIsEnumerable(v: string): boolean; +} + +/** + * Provides functionality common to all JavaScript objects. + */ +declare var Object: { + new (value?: any): Object; + (): any; + (value: any): any; + + /** A reference to the prototype for a class of objects. */ + prototype: Object; + + /** + * Returns the prototype of an object. + * @param o The object that references the prototype. + */ + getPrototypeOf(o: any): any; + + /** + * Gets the own property descriptor of the specified object. + * An own property descriptor is one that is defined directly on the object and is not inherited from the object's prototype. + * @param o Object that contains the property. + * @param p Name of the property. + */ + getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; + + /** + * Returns the names of the own properties of an object. The own properties of an object are those that are defined directly + * on that object, and are not inherited from the object's prototype. The properties of an object include both fields (objects) and functions. + * @param o Object that contains the own properties. + */ + getOwnPropertyNames(o: any): string[]; + + /** + * Creates an object that has the specified prototype, and that optionally contains specified properties. + * @param o Object to use as a prototype. May be null + * @param properties JavaScript object that contains one or more property descriptors. + */ + create(o: any, properties?: PropertyDescriptorMap): any; + + /** + * Adds a property to an object, or modifies attributes of an existing property. + * @param o Object on which to add or modify the property. This can be a native JavaScript object (that is, a user-defined object or a built in object) or a DOM object. + * @param p The property name. + * @param attributes Descriptor for the property. It can be for a data property or an accessor property. + */ + defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; + + /** + * Adds one or more properties to an object, and/or modifies attributes of existing properties. + * @param o Object on which to add or modify the properties. This can be a native JavaScript object or a DOM object. + * @param properties JavaScript object that contains one or more descriptor objects. Each descriptor object describes a data property or an accessor property. + */ + defineProperties(o: any, properties: PropertyDescriptorMap): any; + + /** + * Prevents the modification of attributes of existing properties, and prevents the addition of new properties. + * @param o Object on which to lock the attributes. + */ + seal(o: any): any; + + /** + * Prevents the modification of existing property attributes and values, and prevents the addition of new properties. + * @param o Object on which to lock the attributes. + */ + freeze(o: any): any; + + /** + * Prevents the addition of new properties to an object. + * @param o Object to make non-extensible. + */ + preventExtensions(o: any): any; + + /** + * Returns true if existing property attributes cannot be modified in an object and new properties cannot be added to the object. + * @param o Object to test. + */ + isSealed(o: any): boolean; + + /** + * Returns true if existing property attributes and values cannot be modified in an object, and new properties cannot be added to the object. + * @param o Object to test. + */ + isFrozen(o: any): boolean; + + /** + * Returns a value that indicates whether new properties can be added to an object. + * @param o Object to test. + */ + isExtensible(o: any): boolean; + + /** + * Returns the names of the enumerable properties and methods of an object. + * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object. + */ + keys(o: any): string[]; +} + +/** + * Creates a new function. + */ +interface Function { + /** + * Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function. + * @param thisArg The object to be used as the this object. + * @param argArray A set of arguments to be passed to the function. + */ + apply(thisArg: any, argArray?: any): any; + + /** + * Calls a method of an object, substituting another object for the current object. + * @param thisArg The object to be used as the current object. + * @param argArray A list of arguments to be passed to the method. + */ + call(thisArg: any, ...argArray: any[]): any; + + /** + * For a given function, creates a bound function that has the same body as the original function. + * The this object of the bound function is associated with the specified object, and has the specified initial parameters. + * @param thisArg An object to which the this keyword can refer inside the new function. + * @param argArray A list of arguments to be passed to the new function. + */ + bind(thisArg: any, ...argArray: any[]): any; + + prototype: any; + length: number; + + // Non-standard extensions + arguments: any; + caller: Function; +} + +declare var Function: { + /** + * Creates a new function. + * @param args A list of arguments the function accepts. + */ + new (...args: string[]): Function; + (...args: string[]): Function; + prototype: Function; +} + +interface IArguments { + [index: number]: any; + length: number; + callee: Function; +} + +interface String { + /** Returns a string representation of a string. */ + toString(): string; + + /** + * Returns the character at the specified index. + * @param pos The zero-based index of the desired character. + */ + charAt(pos: number): string; + + /** + * Returns the Unicode value of the character at the specified location. + * @param index The zero-based index of the desired character. If there is no character at the specified index, NaN is returned. + */ + charCodeAt(index: number): number; + + /** + * Returns a string that contains the concatenation of two or more strings. + * @param strings The strings to append to the end of the string. + */ + concat(...strings: string[]): string; + + /** + * Returns the position of the first occurrence of a substring. + * @param searchString The substring to search for in the string + * @param position The index at which to begin searching the String object. If omitted, search starts at the beginning of the string. + */ + indexOf(searchString: string, position?: number): number; + + /** + * Returns the last occurrence of a substring in the string. + * @param searchString The substring to search for. + * @param position The index at which to begin searching. If omitted, the search begins at the end of the string. + */ + lastIndexOf(searchString: string, position?: number): number; + + /** + * Determines whether two strings are equivalent in the current locale. + * @param that String to compare to target string + */ + localeCompare(that: string): number; + + /** + * Matches a string with a regular expression, and returns an array containing the results of that search. + * @param regexp A variable name or string literal containing the regular expression pattern and flags. + */ + match(regexp: string): string[]; + + /** + * Matches a string with a regular expression, and returns an array containing the results of that search. + * @param regexp A regular expression object that contains the regular expression pattern and applicable flags. + */ + match(regexp: RegExp): string[]; + + /** + * Replaces text in a string, using a regular expression or search string. + * @param searchValue A String object or string literal that represents the regular expression + * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj. + */ + replace(searchValue: string, replaceValue: string): string; + + /** + * Replaces text in a string, using a regular expression or search string. + * @param searchValue A String object or string literal that represents the regular expression + * @param replaceValue A function that returns the replacement text. + */ + replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; + + /** + * Replaces text in a string, using a regular expression or search string. + * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags + * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj. + */ + replace(searchValue: RegExp, replaceValue: string): string; + + /** + * Replaces text in a string, using a regular expression or search string. + * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags + * @param replaceValue A function that returns the replacement text. + */ + replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; + + /** + * Finds the first substring match in a regular expression search. + * @param regexp The regular expression pattern and applicable flags. + */ + search(regexp: string): number; + + /** + * Finds the first substring match in a regular expression search. + * @param regexp The regular expression pattern and applicable flags. + */ + search(regexp: RegExp): number; + + /** + * Returns a section of a string. + * @param start The index to the beginning of the specified portion of stringObj. + * @param end The index to the end of the specified portion of stringObj. The substring includes the characters up to, but not including, the character indicated by end. + * If this value is not specified, the substring continues to the end of stringObj. + */ + slice(start: number, end?: number): string; + + /** + * Split a string into substrings using the specified separator and return them as an array. + * @param separator A string that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned. + * @param limit A value used to limit the number of elements returned in the array. + */ + split(separator: string, limit?: number): string[]; + + /** + * Split a string into substrings using the specified separator and return them as an array. + * @param separator A Regular Express that identifies character or characters to use in separating the string. If omitted, a single-element array containing the entire string is returned. + * @param limit A value used to limit the number of elements returned in the array. + */ + split(separator: RegExp, limit?: number): string[]; + + /** + * Returns the substring at the specified location within a String object. + * @param start The zero-based index number indicating the beginning of the substring. + * @param end Zero-based index number indicating the end of the substring. The substring includes the characters up to, but not including, the character indicated by end. + * If end is omitted, the characters from start through the end of the original string are returned. + */ + substring(start: number, end?: number): string; + + /** Converts all the alphabetic characters in a string to lowercase. */ + toLowerCase(): string; + + /** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */ + toLocaleLowerCase(): string; + + /** Converts all the alphabetic characters in a string to uppercase. */ + toUpperCase(): string; + + /** Returns a string where all alphabetic characters have been converted to uppercase, taking into account the host environment's current locale. */ + toLocaleUpperCase(): string; + + /** Removes the leading and trailing white space and line terminator characters from a string. */ + trim(): string; + + /** Returns the length of a String object. */ + length: number; + + // IE extensions + /** + * Gets a substring beginning at the specified location and having the specified length. + * @param from The starting position of the desired substring. The index of the first character in the string is zero. + * @param length The number of characters to include in the returned substring. + */ + substr(from: number, length?: number): string; + + [index: number]: string; +} + +/** + * Allows manipulation and formatting of text strings and determination and location of substrings within strings. + */ +declare var String: { + new (value?: any): String; + (value?: any): string; + prototype: String; + fromCharCode(...codes: number[]): string; +} + +interface Boolean { +} +declare var Boolean: { + new (value?: any): Boolean; + (value?: any): boolean; + prototype: Boolean; +} + +interface Number { + /** + * Returns a string representation of an object. + * @param radix Specifies a radix for converting numeric values to strings. This value is only used for numbers. + */ + toString(radix?: number): string; + + /** + * Returns a string representing a number in fixed-point notation. + * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive. + */ + toFixed(fractionDigits?: number): string; + + /** + * Returns a string containing a number represented in exponential notation. + * @param fractionDigits Number of digits after the decimal point. Must be in the range 0 - 20, inclusive. + */ + toExponential(fractionDigits?: number): string; + + /** + * Returns a string containing a number represented either in exponential or fixed-point notation with a specified number of digits. + * @param precision Number of significant digits. Must be in the range 1 - 21, inclusive. + */ + toPrecision(precision?: number): string; +} + +/** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */ +declare var Number: { + new (value?: any): Number; + (value?: any): number; + prototype: Number; + + /** The largest number that can be represented in JavaScript. Equal to approximately 1.79E+308. */ + MAX_VALUE: number; + + /** The closest number to zero that can be represented in JavaScript. Equal to approximately 5.00E-324. */ + MIN_VALUE: number; + + /** + * A value that is not a number. + * In equality comparisons, NaN does not equal any value, including itself. To test whether a value is equivalent to NaN, use the isNaN function. + */ + NaN: number; + + /** + * A value that is less than the largest negative number that can be represented in JavaScript. + * JavaScript displays NEGATIVE_INFINITY values as -infinity. + */ + NEGATIVE_INFINITY: number; + + /** + * A value greater than the largest number that can be represented in JavaScript. + * JavaScript displays POSITIVE_INFINITY values as infinity. + */ + POSITIVE_INFINITY: number; +} + +interface Math { + /** The mathematical constant e. This is Euler's number, the base of natural logarithms. */ + E: number; + /** The natural logarithm of 10. */ + LN10: number; + /** The natural logarithm of 2. */ + LN2: number; + /** The base-2 logarithm of e. */ + LOG2E: number; + /** The base-10 logarithm of e. */ + LOG10E: number; + /** Pi. This is the ratio of the circumference of a circle to its diameter. */ + PI: number; + /** The square root of 0.5, or, equivalently, one divided by the square root of 2. */ + SQRT1_2: number; + /** The square root of 2. */ + SQRT2: number; + /** + * Returns the absolute value of a number (the value without regard to whether it is positive or negative). + * For example, the absolute value of -5 is the same as the absolute value of 5. + * @param x A numeric expression for which the absolute value is needed. + */ + abs(x: number): number; + /** + * Returns the arc cosine (or inverse cosine) of a number. + * @param x A numeric expression. + */ + acos(x: number): number; + /** + * Returns the arcsine of a number. + * @param x A numeric expression. + */ + asin(x: number): number; + /** + * Returns the arctangent of a number. + * @param x A numeric expression for which the arctangent is needed. + */ + atan(x: number): number; + /** + * Returns the angle (in radians) from the X axis to a point (y,x). + * @param y A numeric expression representing the cartesian y-coordinate. + * @param x A numeric expression representing the cartesian x-coordinate. + */ + atan2(y: number, x: number): number; + /** + * Returns the smallest number greater than or equal to its numeric argument. + * @param x A numeric expression. + */ + ceil(x: number): number; + /** + * Returns the cosine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ + cos(x: number): number; + /** + * Returns e (the base of natural logarithms) raised to a power. + * @param x A numeric expression representing the power of e. + */ + exp(x: number): number; + /** + * Returns the greatest number less than or equal to its numeric argument. + * @param x A numeric expression. + */ + floor(x: number): number; + /** + * Returns the natural logarithm (base e) of a number. + * @param x A numeric expression. + */ + log(x: number): number; + /** + * Returns the larger of a set of supplied numeric expressions. + * @param values Numeric expressions to be evaluated. + */ + max(...values: number[]): number; + /** + * Returns the smaller of a set of supplied numeric expressions. + * @param values Numeric expressions to be evaluated. + */ + min(...values: number[]): number; + /** + * Returns the value of a base expression taken to a specified power. + * @param x The base value of the expression. + * @param y The exponent value of the expression. + */ + pow(x: number, y: number): number; + /** Returns a pseudorandom number between 0 and 1. */ + random(): number; + /** + * Returns a supplied numeric expression rounded to the nearest number. + * @param x The value to be rounded to the nearest number. + */ + round(x: number): number; + /** + * Returns the sine of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ + sin(x: number): number; + /** + * Returns the square root of a number. + * @param x A numeric expression. + */ + sqrt(x: number): number; + /** + * Returns the tangent of a number. + * @param x A numeric expression that contains an angle measured in radians. + */ + tan(x: number): number; +} +/** An intrinsic object that provides basic mathematics functionality and constants. */ +declare var Math: Math; + +/** Enables basic storage and retrieval of dates and times. */ +interface Date { + /** Returns a string representation of a date. The format of the string depends on the locale. */ + toString(): string; + /** Returns a date as a string value. */ + toDateString(): string; + /** Returns a time as a string value. */ + toTimeString(): string; + /** Returns a value as a string value appropriate to the host environment's current locale. */ + toLocaleString(): string; + /** Returns a date as a string value appropriate to the host environment's current locale. */ + toLocaleDateString(): string; + /** Returns a time as a string value appropriate to the host environment's current locale. */ + toLocaleTimeString(): string; + /** Returns the stored time value in milliseconds since midnight, January 1, 1970 UTC. */ + valueOf(): number; + /** Gets the time value in milliseconds. */ + getTime(): number; + /** Gets the year, using local time. */ + getFullYear(): number; + /** Gets the year using Universal Coordinated Time (UTC). */ + getUTCFullYear(): number; + /** Gets the month, using local time. */ + getMonth(): number; + /** Gets the month of a Date object using Universal Coordinated Time (UTC). */ + getUTCMonth(): number; + /** Gets the day-of-the-month, using local time. */ + getDate(): number; + /** Gets the day-of-the-month, using Universal Coordinated Time (UTC). */ + getUTCDate(): number; + /** Gets the day of the week, using local time. */ + getDay(): number; + /** Gets the day of the week using Universal Coordinated Time (UTC). */ + getUTCDay(): number; + /** Gets the hours in a date, using local time. */ + getHours(): number; + /** Gets the hours value in a Date object using Universal Coordinated Time (UTC). */ + getUTCHours(): number; + /** Gets the minutes of a Date object, using local time. */ + getMinutes(): number; + /** Gets the minutes of a Date object using Universal Coordinated Time (UTC). */ + getUTCMinutes(): number; + /** Gets the seconds of a Date object, using local time. */ + getSeconds(): number; + /** Gets the seconds of a Date object using Universal Coordinated Time (UTC). */ + getUTCSeconds(): number; + /** Gets the milliseconds of a Date, using local time. */ + getMilliseconds(): number; + /** Gets the milliseconds of a Date object using Universal Coordinated Time (UTC). */ + getUTCMilliseconds(): number; + /** Gets the difference in minutes between the time on the local computer and Universal Coordinated Time (UTC). */ + getTimezoneOffset(): number; + /** + * Sets the date and time value in the Date object. + * @param time A numeric value representing the number of elapsed milliseconds since midnight, January 1, 1970 GMT. + */ + setTime(time: number): void; + /** + * Sets the milliseconds value in the Date object using local time. + * @param ms A numeric value equal to the millisecond value. + */ + setMilliseconds(ms: number): void; + /** + * Sets the milliseconds value in the Date object using Universal Coordinated Time (UTC). + * @param ms A numeric value equal to the millisecond value. + */ + setUTCMilliseconds(ms: number): void; + + /** + * Sets the seconds value in the Date object using local time. + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setSeconds(sec: number, ms?: number): void; + /** + * Sets the seconds value in the Date object using Universal Coordinated Time (UTC). + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setUTCSeconds(sec: number, ms?: number): void; + /** + * Sets the minutes value in the Date object using local time. + * @param min A numeric value equal to the minutes value. + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setMinutes(min: number, sec?: number, ms?: number): void; + /** + * Sets the minutes value in the Date object using Universal Coordinated Time (UTC). + * @param min A numeric value equal to the minutes value. + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setUTCMinutes(min: number, sec?: number, ms?: number): void; + /** + * Sets the hour value in the Date object using local time. + * @param hours A numeric value equal to the hours value. + * @param min A numeric value equal to the minutes value. + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setHours(hours: number, min?: number, sec?: number, ms?: number): void; + /** + * Sets the hours value in the Date object using Universal Coordinated Time (UTC). + * @param hours A numeric value equal to the hours value. + * @param min A numeric value equal to the minutes value. + * @param sec A numeric value equal to the seconds value. + * @param ms A numeric value equal to the milliseconds value. + */ + setUTCHours(hours: number, min?: number, sec?: number, ms?: number): void; + /** + * Sets the numeric day-of-the-month value of the Date object using local time. + * @param date A numeric value equal to the day of the month. + */ + setDate(date: number): void; + /** + * Sets the numeric day of the month in the Date object using Universal Coordinated Time (UTC). + * @param date A numeric value equal to the day of the month. + */ + setUTCDate(date: number): void; + /** + * Sets the month value in the Date object using local time. + * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. + * @param date A numeric value representing the day of the month. If this value is not supplied, the value from a call to the getDate method is used. + */ + setMonth(month: number, date?: number): void; + /** + * Sets the month value in the Date object using Universal Coordinated Time (UTC). + * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. + * @param date A numeric value representing the day of the month. If it is not supplied, the value from a call to the getUTCDate method is used. + */ + setUTCMonth(month: number, date?: number): void; + /** + * Sets the year of the Date object using local time. + * @param year A numeric value for the year. + * @param month A zero-based numeric value for the month (0 for January, 11 for December). Must be specified if numDate is specified. + * @param date A numeric value equal for the day of the month. + */ + setFullYear(year: number, month?: number, date?: number): void; + /** + * Sets the year value in the Date object using Universal Coordinated Time (UTC). + * @param year A numeric value equal to the year. + * @param month A numeric value equal to the month. The value for January is 0, and other month values follow consecutively. Must be supplied if numDate is supplied. + * @param date A numeric value equal to the day of the month. + */ + setUTCFullYear(year: number, month?: number, date?: number): void; + /** Returns a date converted to a string using Universal Coordinated Time (UTC). */ + toUTCString(): string; + /** Returns a date as a string value in ISO format. */ + toISOString(): string; + /** Used by the JSON.stringify method to enable the transformation of an object's data for JavaScript Object Notation (JSON) serialization. */ + toJSON(key?: any): string; +} + +declare var Date: { + new (): Date; + new (value: number): Date; + new (value: string): Date; + new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date; + (): string; + prototype: Date; + /** + * Parses a string containing a date, and returns the number of milliseconds between that date and midnight, January 1, 1970. + * @param s A date string + */ + parse(s: string): number; + /** + * Returns the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the specified date. + * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year. + * @param month The month as an number between 0 and 11 (January to December). + * @param date The date as an number between 1 and 31. + * @param hours Must be supplied if minutes is supplied. An number from 0 to 23 (midnight to 11pm) that specifies the hour. + * @param minutes Must be supplied if seconds is supplied. An number from 0 to 59 that specifies the minutes. + * @param seconds Must be supplied if milliseconds is supplied. An number from 0 to 59 that specifies the seconds. + * @param ms An number from 0 to 999 that specifies the milliseconds. + */ + UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number; + now(): number; +} + +interface RegExpExecArray { + [index: number]: string; + length: number; + + index: number; + input: string; + + toString(): string; + toLocaleString(): string; + concat(...items: string[][]): string[]; + join(separator?: string): string; + pop(): string; + push(...items: string[]): number; + reverse(): string[]; + shift(): string; + slice(start: number, end?: number): string[]; + sort(compareFn?: (a: string, b: string) => number): string[]; + splice(start: number): string[]; + splice(start: number, deleteCount: number, ...items: string[]): string[]; + unshift(...items: string[]): number; + + indexOf(searchElement: string, fromIndex?: number): number; + lastIndexOf(searchElement: string, fromIndex?: number): number; + every(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean; + some(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): boolean; + forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void; + map(callbackfn: (value: string, index: number, array: string[]) => any, thisArg?: any): any[]; + filter(callbackfn: (value: string, index: number, array: string[]) => boolean, thisArg?: any): string[]; + reduce(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any; + reduceRight(callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: string[]) => any, initialValue?: any): any; +} + + +interface RegExp { + /** + * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search. + * @param string The String object or string literal on which to perform the search. + */ + exec(string: string): RegExpExecArray; + + /** + * Returns a Boolean value that indicates whether or not a pattern exists in a searched string. + * @param string String on which to perform the search. + */ + test(string: string): boolean; + + /** Returns a copy of the text of the regular expression pattern. Read-only. The rgExp argument is a Regular expression object. It can be a variable name or a literal. */ + source: string; + + /** Returns a Boolean value indicating the state of the global flag (g) used with a regular expression. Default is false. Read-only. */ + global: boolean; + + /** Returns a Boolean value indicating the state of the ignoreCase flag (i) used with a regular expression. Default is false. Read-only. */ + ignoreCase: boolean; + + /** Returns a Boolean value indicating the state of the multiline flag (m) used with a regular expression. Default is false. Read-only. */ + multiline: boolean; + + lastIndex: number; + + // Non-standard extensions + compile(): RegExp; +} +declare var RegExp: { + new (pattern: string, flags?: string): RegExp; + (pattern: string, flags?: string): RegExp; + + // Non-standard extensions + $1: string; + $2: string; + $3: string; + $4: string; + $5: string; + $6: string; + $7: string; + $8: string; + $9: string; + lastMatch: string; +} + +interface Error { + name: string; + message: string; +} +declare var Error: { + new (message?: string): Error; + (message?: string): Error; + prototype: Error; +} + +interface EvalError extends Error { +} +declare var EvalError: { + new (message?: string): EvalError; + (message?: string): EvalError; + prototype: EvalError; +} + +interface RangeError extends Error { +} +declare var RangeError: { + new (message?: string): RangeError; + (message?: string): RangeError; + prototype: RangeError; +} + +interface ReferenceError extends Error { +} +declare var ReferenceError: { + new (message?: string): ReferenceError; + (message?: string): ReferenceError; + prototype: ReferenceError; +} + +interface SyntaxError extends Error { +} +declare var SyntaxError: { + new (message?: string): SyntaxError; + (message?: string): SyntaxError; + prototype: SyntaxError; +} + +interface TypeError extends Error { +} +declare var TypeError: { + new (message?: string): TypeError; + (message?: string): TypeError; + prototype: TypeError; +} + +interface URIError extends Error { +} +declare var URIError: { + new (message?: string): URIError; + (message?: string): URIError; + prototype: URIError; +} + +interface JSON { + /** + * Converts a JavaScript Object Notation (JSON) string into an object. + * @param text A valid JSON string. + * @param reviver A function that transforms the results. This function is called for each member of the object. + * If a member contains nested objects, the nested objects are transformed before the parent object is. + */ + parse(text: string, reviver?: (key: any, value: any) => any): any; + /** + * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. + * @param value A JavaScript value, usually an object or array, to be converted. + */ + stringify(value: any): string; + /** + * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. + * @param value A JavaScript value, usually an object or array, to be converted. + * @param replacer A function that transforms the results. + */ + stringify(value: any, replacer: (key: string, value: any) => any): string; + /** + * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. + * @param value A JavaScript value, usually an object or array, to be converted. + * @param replacer Array that transforms the results. + */ + stringify(value: any, replacer: any[]): string; + /** + * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. + * @param value A JavaScript value, usually an object or array, to be converted. + * @param replacer A function that transforms the results. + * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read. + */ + stringify(value: any, replacer: (key: string, value: any) => any, space: any): string; + /** + * Converts a JavaScript value to a JavaScript Object Notation (JSON) string. + * @param value A JavaScript value, usually an object or array, to be converted. + * @param replacer Array that transforms the results. + * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read. + */ + stringify(value: any, replacer: any[], space: any): string; +} +/** + * An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format. + */ +declare var JSON: JSON; + + +///////////////////////////// +/// ECMAScript Array API (specially handled by compiler) +///////////////////////////// + +interface Array { + /** + * Returns a string representation of an array. + */ + toString(): string; + toLocaleString(): string; + /** + * Combines two or more arrays. + * @param items Additional items to add to the end of array1. + */ + concat(...items: U[]): T[]; + /** + * Combines two or more arrays. + * @param items Additional items to add to the end of array1. + */ + concat(...items: T[]): T[]; + /** + * Adds all the elements of an array separated by the specified separator string. + * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma. + */ + join(separator?: string): string; + /** + * Removes the last element from an array and returns it. + */ + pop(): T; + /** + * Appends new elements to an array, and returns the new length of the array. + * @param items New elements of the Array. + */ + push(...items: T[]): number; + /** + * Reverses the elements in an Array. + */ + reverse(): T[]; + /** + * Removes the first element from an array and returns it. + */ + shift(): T; + /** + * Returns a section of an array. + * @param start The beginning of the specified portion of the array. + * @param end The end of the specified portion of the array. + */ + slice(start: number, end?: number): T[]; + + /** + * Sorts an array. + * @param compareFn The name of the function used to determine the order of the elements. If omitted, the elements are sorted in ascending, ASCII character order. + */ + sort(compareFn?: (a: T, b: T) => number): T[]; + + /** + * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements. + * @param start The zero-based location in the array from which to start removing elements. + */ + splice(start: number): T[]; + + /** + * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements. + * @param start The zero-based location in the array from which to start removing elements. + * @param deleteCount The number of elements to remove. + * @param items Elements to insert into the array in place of the deleted elements. + */ + splice(start: number, deleteCount: number, ...items: T[]): T[]; + + /** + * Inserts new elements at the start of an array. + * @param items Elements to insert at the start of the Array. + */ + unshift(...items: T[]): number; + + /** + * Returns the index of the first occurrence of a value in an array. + * @param searchElement The value to locate in the array. + * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0. + */ + indexOf(searchElement: T, fromIndex?: number): number; + + /** + * Returns the index of the last occurrence of a specified value in an array. + * @param searchElement The value to locate in the array. + * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at the last index in the array. + */ + lastIndexOf(searchElement: T, fromIndex?: number): number; + + /** + * Determines whether all the members of an array satisfy the specified test. + * @param callbackfn A function that accepts up to three arguments. The every method calls the callbackfn function for each element in array1 until the callbackfn returns false, or until the end of the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; + + /** + * Determines whether the specified callback function returns true for any element of an array. + * @param callbackfn A function that accepts up to three arguments. The some method calls the callbackfn function for each element in array1 until the callbackfn returns true, or until the end of the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean; + + /** + * Performs the specified action for each element in an array. + * @param callbackfn A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void; + + /** + * Calls a defined callback function on each element of an array, and returns an array that contains the results. + * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + map(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]; + + /** + * Returns the elements of an array that meet the condition specified in a callback function. + * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array. + * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value. + */ + filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[]; + + /** + * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. + */ + reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; + /** + * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. + */ + reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + + /** + * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. + */ + reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; + /** + * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function. + * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array. + * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value. + */ + reduceRight(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; + + /** + * Gets or sets the length of the array. This is a number one higher than the highest element defined in an array. + */ + length: number; + + [n: number]: T; +} +declare var Array: { + new(arrayLength?: number): any[]; + new (arrayLength: number): T[]; + new (...items: T[]): T[]; + (arrayLength?: number): any[]; + (arrayLength: number): T[]; + (...items: T[]): T[]; + isArray(arg: any): boolean; + prototype: Array; +} + + +///////////////////////////// +/// IE10 ECMAScript Extensions +///////////////////////////// + +/** + * Represents a raw buffer of binary data, which is used to store data for the + * different typed arrays. ArrayBuffers cannot be read from or written to directly, + * but can be passed to a typed array or DataView Object to interpret the raw + * buffer as needed. + */ +interface ArrayBuffer { + /** + * Read-only. The length of the ArrayBuffer (in bytes). + */ + byteLength: number; +} + +declare var ArrayBuffer: { + prototype: ArrayBuffer; + new (byteLength: number): ArrayBuffer; +} + +interface ArrayBufferView { + buffer: ArrayBuffer; + byteOffset: number; + byteLength: number; +} + +/** + * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Int8Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Int8Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Int8Array view of the ArrayBuffer store for this array, referencing the elements at begin, inclusive, up to end, exclusive. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Int8Array; +} +declare var Int8Array: { + prototype: Int8Array; + new (length: number): Int8Array; + new (array: Int8Array): Int8Array; + new (array: number[]): Int8Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Uint8Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Uint8Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Uint8Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Uint8Array; +} +declare var Uint8Array: { + prototype: Uint8Array; + new (length: number): Uint8Array; + new (array: Uint8Array): Uint8Array; + new (array: number[]): Uint8Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint8Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 16-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Int16Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Int16Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Int16Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Int16Array; +} +declare var Int16Array: { + prototype: Int16Array; + new (length: number): Int16Array; + new (array: Int16Array): Int16Array; + new (array: number[]): Int16Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int16Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Uint16Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Uint16Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Uint16Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Uint16Array; +} +declare var Uint16Array: { + prototype: Uint16Array; + new (length: number): Uint16Array; + new (array: Uint16Array): Uint16Array; + new (array: number[]): Uint16Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint16Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 32-bit integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Int32Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Int32Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Int32Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Int32Array; +} +declare var Int32Array: { + prototype: Int32Array; + new (length: number): Int32Array; + new (array: Int32Array): Int32Array; + new (array: number[]): Int32Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Int32Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Uint32Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Uint32Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Int8Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Uint32Array; +} +declare var Uint32Array: { + prototype: Uint32Array; + new (length: number): Uint32Array; + new (array: Uint32Array): Uint32Array; + new (array: number[]): Uint32Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Uint32Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 32-bit float values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Float32Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Float32Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Float32Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Float32Array; +} +declare var Float32Array: { + prototype: Float32Array; + new (length: number): Float32Array; + new (array: Float32Array): Float32Array; + new (array: number[]): Float32Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float32Array; + BYTES_PER_ELEMENT: number; +} + +/** + * A typed array of 64-bit float values. The contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised. + */ +interface Float64Array extends ArrayBufferView { + /** + * The size in bytes of each element in the array. + */ + BYTES_PER_ELEMENT: number; + + /** + * The length of the array. + */ + length: number; + [index: number]: number; + + /** + * Gets the element at the specified index. + * @param index The index at which to get the element of the array. + */ + get(index: number): number; + + /** + * Sets a value or an array of values. + * @param index The index of the location to set. + * @param value The value to set. + */ + set(index: number, value: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: Float64Array, offset?: number): void; + + /** + * Sets a value or an array of values. + * @param A typed or untyped array of values to set. + * @param offset The index in the current array at which the values are to be written. + */ + set(array: number[], offset?: number): void; + + /** + * Gets a new Float64Array view of the ArrayBuffer Object store for this array, specifying the first and last members of the subarray. + * @param begin The index of the beginning of the array. + * @param end The index of the end of the array. + */ + subarray(begin: number, end?: number): Float64Array; +} +declare var Float64Array: { + prototype: Float64Array; + new (length: number): Float64Array; + new (array: Float64Array): Float64Array; + new (array: number[]): Float64Array; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): Float64Array; + BYTES_PER_ELEMENT: number; +} + +/** + * You can use a DataView object to read and write the different kinds of binary data to any location in the ArrayBuffer. + */ +interface DataView extends ArrayBufferView { + /** + * Gets the Int8 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getInt8(byteOffset: number): number; + + /** + * Gets the Uint8 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getUint8(byteOffset: number): number; + + /** + * Gets the Int16 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getInt16(byteOffset: number, littleEndian?: boolean): number; + + /** + * Gets the Uint16 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getUint16(byteOffset: number, littleEndian?: boolean): number; + + /** + * Gets the Int32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getInt32(byteOffset: number, littleEndian?: boolean): number; + + /** + * Gets the Uint32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getUint32(byteOffset: number, littleEndian?: boolean): number; + + /** + * Gets the Float32 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getFloat32(byteOffset: number, littleEndian?: boolean): number; + + /** + * Gets the Float64 value at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset. + * @param byteOffset The place in the buffer at which the value should be retrieved. + */ + getFloat64(byteOffset: number, littleEndian?: boolean): number; + + /** + * Stores an Int8 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + */ + setInt8(byteOffset: number, value: number): void; + + /** + * Stores an Uint8 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + */ + setUint8(byteOffset: number, value: number): void; + + /** + * Stores an Int16 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setInt16(byteOffset: number, value: number, littleEndian?: boolean): void; + + /** + * Stores an Uint16 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setUint16(byteOffset: number, value: number, littleEndian?: boolean): void; + + /** + * Stores an Int32 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setInt32(byteOffset: number, value: number, littleEndian?: boolean): void; + + /** + * Stores an Uint32 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setUint32(byteOffset: number, value: number, littleEndian?: boolean): void; + + /** + * Stores an Float32 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setFloat32(byteOffset: number, value: number, littleEndian?: boolean): void; + + /** + * Stores an Float64 value at the specified byte offset from the start of the view. + * @param byteOffset The place in the buffer at which the value should be set. + * @param value The value to set. + * @param littleEndian If false or undefined, a big-endian value should be written, otherwise a little-endian value should be written. + */ + setFloat64(byteOffset: number, value: number, littleEndian?: boolean): void; +} +declare var DataView: { + prototype: DataView; + new (buffer: ArrayBuffer, byteOffset?: number, length?: number): DataView; +} + +///////////////////////////// +/// IE11 ECMAScript Extensions +///////////////////////////// + +interface Map { + clear(): void; + delete(key: K): boolean; + forEach(callbackfn: (value: V, index: K, map: Map) => void, thisArg?: any): void; + get(key: K): V; + has(key: K): boolean; + set(key: K, value: V): Map; + size: number; +} +declare var Map: { + new (): Map; +} + +interface WeakMap { + clear(): void; + delete(key: K): boolean; + get(key: K): V; + has(key: K): boolean; + set(key: K, value: V): WeakMap; +} +declare var WeakMap: { + new (): WeakMap; +} + +interface Set { + add(value: T): Set; + clear(): void; + delete(value: T): boolean; + forEach(callbackfn: (value: T, index: T, set: Set) => void, thisArg?: any): void; + has(value: T): boolean; + size: number; +} +declare var Set: { + new (): Set; +} + +declare module Intl { + + interface CollatorOptions { + usage?: string; + localeMatcher?: string; + numeric?: boolean; + caseFirst?: string; + sensitivity?: string; + ignorePunctuation?: boolean; + } + + interface ResolvedCollatorOptions { + locale: string; + usage: string; + sensitivity: string; + ignorePunctuation: boolean; + collation: string; + caseFirst: string; + numeric: boolean; + } + + interface Collator { + compare(x: string, y: string): number; + resolvedOptions(): ResolvedCollatorOptions; + } + var Collator: { + new (locales?: string[], options?: CollatorOptions): Collator; + new (locale?: string, options?: CollatorOptions): Collator; + (locales?: string[], options?: CollatorOptions): Collator; + (locale?: string, options?: CollatorOptions): Collator; + supportedLocalesOf(locales: string[], options?: CollatorOptions): string[]; + supportedLocalesOf(locale: string, options?: CollatorOptions): string[]; + } + + interface NumberFormatOptions { + localeMatcher?: string; + style?: string; + currency?: string; + currencyDisplay?: string; + useGrouping?: boolean; + } + + interface ResolvedNumberFormatOptions { + locale: string; + numberingSystem: string; + style: string; + currency?: string; + currencyDisplay?: string; + minimumintegerDigits: number; + minimumFractionDigits: number; + maximumFractionDigits: number; + minimumSignificantDigits?: number; + maximumSignificantDigits?: number; + useGrouping: boolean; + } + + interface NumberFormat { + format(value: number): string; + resolvedOptions(): ResolvedNumberFormatOptions; + } + var NumberFormat: { + new (locales?: string[], options?: NumberFormatOptions): Collator; + new (locale?: string, options?: NumberFormatOptions): Collator; + (locales?: string[], options?: NumberFormatOptions): Collator; + (locale?: string, options?: NumberFormatOptions): Collator; + supportedLocalesOf(locales: string[], options?: NumberFormatOptions): string[]; + supportedLocalesOf(locale: string, options?: NumberFormatOptions): string[]; + } + + interface DateTimeFormatOptions { + localeMatcher?: string; + weekday?: string; + era?: string; + year?: string; + month?: string; + day?: string; + hour?: string; + minute?: string; + second?: string; + timeZoneName?: string; + formatMatcher?: string; + hour12: boolean; + } + + interface ResolvedDateTimeFormatOptions { + locale: string; + calendar: string; + numberingSystem: string; + timeZone: string; + hour12?: boolean; + weekday?: string; + era?: string; + year?: string; + month?: string; + day?: string; + hour?: string; + minute?: string; + second?: string; + timeZoneName?: string; + } + + interface DateTimeFormat { + format(date: number): string; + resolvedOptions(): ResolvedDateTimeFormatOptions; + } + var DateTimeFormat: { + new (locales?: string[], options?: DateTimeFormatOptions): Collator; + new (locale?: string, options?: DateTimeFormatOptions): Collator; + (locales?: string[], options?: DateTimeFormatOptions): Collator; + (locale?: string, options?: DateTimeFormatOptions): Collator; + supportedLocalesOf(locales: string[], options?: DateTimeFormatOptions): string[]; + supportedLocalesOf(locale: string, options?: DateTimeFormatOptions): string[]; + } +} + +interface String { + localeCompare(that: string, locales: string[], options?: Intl.CollatorOptions): number; + localeCompare(that: string, locale: string, options?: Intl.CollatorOptions): number; +} + +interface Number { + toLocaleString(locales: string[], options?: Intl.NumberFormatOptions): string; + toLocaleString(locale: string, options?: Intl.NumberFormatOptions): string; +} + +interface Date { + toLocaleString(locales: string[], options?: Intl.DateTimeFormatOptions): string; + toLocaleString(locale: string, options?: Intl.DateTimeFormatOptions): string; +} + + +///////////////////////////// +/// IE9 DOM APIs +///////////////////////////// + +interface PositionOptions { + enableHighAccuracy?: boolean; + timeout?: number; + maximumAge?: number; +} + +interface NavigatorID { + appVersion: string; + appName: string; + userAgent: string; + platform: string; +} + +interface HTMLTableElement extends HTMLElement, MSDataBindingTableExtensions, MSDataBindingExtensions, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle { + /** + * Sets or retrieves the width of the object. + */ + width: string; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorLight: any; + /** + * Sets or retrieves the amount of space between cells in a table. + */ + cellSpacing: string; + /** + * Retrieves the tFoot object of the table. + */ + tFoot: HTMLTableSectionElement; + /** + * Sets or retrieves the way the border frame around the table is displayed. + */ + frame: string; + /** + * Sets or retrieves the border color of the object. + */ + borderColor: any; + /** + * Sets or retrieves the number of horizontal rows contained in the object. + */ + rows: HTMLCollection; + /** + * Sets or retrieves which dividing lines (inner borders) are displayed. + */ + rules: string; + /** + * Sets or retrieves the number of columns in the table. + */ + cols: number; + /** + * Sets or retrieves a description and/or structure of the object. + */ + summary: string; + /** + * Retrieves the caption object of a table. + */ + caption: HTMLTableCaptionElement; + /** + * Retrieves a collection of all tBody objects in the table. Objects in this collection are in source order. + */ + tBodies: HTMLCollection; + /** + * Retrieves the tHead object of the table. + */ + tHead: HTMLTableSectionElement; + /** + * Sets or retrieves a value that indicates the table alignment. + */ + align: string; + /** + * Retrieves a collection of all cells in the table row or in the entire table. + */ + cells: HTMLCollection; + /** + * Sets or retrieves the height of the object. + */ + height: any; + /** + * Sets or retrieves the amount of space between the border of the cell and the content of the cell. + */ + cellPadding: string; + /** + * Sets or retrieves the width of the border to draw around the object. + */ + border: string; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorDark: any; + /** + * Removes the specified row (tr) from the element and from the rows collection. + * @param index Number that specifies the zero-based position in the rows collection of the row to remove. + */ + deleteRow(index?: number): void; + /** + * Creates an empty tBody element in the table. + */ + createTBody(): HTMLElement; + /** + * Deletes the caption element and its contents from the table. + */ + deleteCaption(): void; + /** + * Creates a new row (tr) in the table, and adds the row to the rows collection. + * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection. + */ + insertRow(index?: number): HTMLElement; + /** + * Deletes the tFoot element and its contents from the table. + */ + deleteTFoot(): void; + /** + * Returns the tHead element object if successful, or null otherwise. + */ + createTHead(): HTMLElement; + /** + * Deletes the tHead element and its contents from the table. + */ + deleteTHead(): void; + /** + * Creates an empty caption element in the table. + */ + createCaption(): HTMLElement; + /** + * Moves a table row to a new position. + * @param indexFrom Number that specifies the index in the rows collection of the table row that is moved. + * @param indexTo Number that specifies where the row is moved within the rows collection. + */ + moveRow(indexFrom?: number, indexTo?: number): Object; + /** + * Creates an empty tFoot element in the table. + */ + createTFoot(): HTMLElement; +} +declare var HTMLTableElement: { + prototype: HTMLTableElement; + new (): HTMLTableElement; +} + +interface TreeWalker { + whatToShow: number; + filter: NodeFilter; + root: Node; + currentNode: Node; + expandEntityReferences: boolean; + previousSibling(): Node; + lastChild(): Node; + nextSibling(): Node; + nextNode(): Node; + parentNode(): Node; + firstChild(): Node; + previousNode(): Node; +} +declare var TreeWalker: { + prototype: TreeWalker; + new (): TreeWalker; +} + +interface GetSVGDocument { + getSVGDocument(): Document; +} + +interface SVGPathSegCurvetoQuadraticRel extends SVGPathSeg { + y: number; + y1: number; + x: number; + x1: number; +} +declare var SVGPathSegCurvetoQuadraticRel: { + prototype: SVGPathSegCurvetoQuadraticRel; + new (): SVGPathSegCurvetoQuadraticRel; +} + +interface Performance { + navigation: PerformanceNavigation; + timing: PerformanceTiming; + getEntriesByType(entryType: string): any; + toJSON(): any; + getMeasures(measureName?: string): any; + clearMarks(markName?: string): void; + getMarks(markName?: string): any; + clearResourceTimings(): void; + mark(markName: string): void; + measure(measureName: string, startMarkName?: string, endMarkName?: string): void; + getEntriesByName(name: string, entryType?: string): any; + getEntries(): any; + clearMeasures(measureName?: string): void; + setResourceTimingBufferSize(maxSize: number): void; +} +declare var Performance: { + prototype: Performance; + new (): Performance; +} + +interface MSDataBindingTableExtensions { + dataPageSize: number; + nextPage(): void; + firstPage(): void; + refresh(): void; + previousPage(): void; + lastPage(): void; +} + +interface CompositionEvent extends UIEvent { + data: string; + locale: string; + initCompositionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, locale: string): void; +} +declare var CompositionEvent: { + prototype: CompositionEvent; + new (): CompositionEvent; +} + +interface WindowTimers { + clearTimeout(handle: number): void; + setTimeout(handler: any, timeout?: any, ...args: any[]): number; + clearInterval(handle: number): void; + setInterval(handler: any, timeout?: any, ...args: any[]): number; +} + +interface SVGMarkerElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox, SVGExternalResourcesRequired { + orientType: SVGAnimatedEnumeration; + markerUnits: SVGAnimatedEnumeration; + markerWidth: SVGAnimatedLength; + markerHeight: SVGAnimatedLength; + orientAngle: SVGAnimatedAngle; + refY: SVGAnimatedLength; + refX: SVGAnimatedLength; + setOrientToAngle(angle: SVGAngle): void; + setOrientToAuto(): void; + SVG_MARKER_ORIENT_UNKNOWN: number; + SVG_MARKER_ORIENT_ANGLE: number; + SVG_MARKERUNITS_UNKNOWN: number; + SVG_MARKERUNITS_STROKEWIDTH: number; + SVG_MARKER_ORIENT_AUTO: number; + SVG_MARKERUNITS_USERSPACEONUSE: number; +} +declare var SVGMarkerElement: { + prototype: SVGMarkerElement; + new (): SVGMarkerElement; + SVG_MARKER_ORIENT_UNKNOWN: number; + SVG_MARKER_ORIENT_ANGLE: number; + SVG_MARKERUNITS_UNKNOWN: number; + SVG_MARKERUNITS_STROKEWIDTH: number; + SVG_MARKER_ORIENT_AUTO: number; + SVG_MARKERUNITS_USERSPACEONUSE: number; +} + +interface CSSStyleDeclaration { + backgroundAttachment: string; + visibility: string; + textAlignLast: string; + borderRightStyle: string; + counterIncrement: string; + orphans: string; + cssText: string; + borderStyle: string; + pointerEvents: string; + borderTopColor: string; + markerEnd: string; + textIndent: string; + listStyleImage: string; + cursor: string; + listStylePosition: string; + wordWrap: string; + borderTopStyle: string; + alignmentBaseline: string; + opacity: string; + direction: string; + strokeMiterlimit: string; + maxWidth: string; + color: string; + clip: string; + borderRightWidth: string; + verticalAlign: string; + overflow: string; + mask: string; + borderLeftStyle: string; + emptyCells: string; + stopOpacity: string; + paddingRight: string; + parentRule: CSSRule; + background: string; + boxSizing: string; + textJustify: string; + height: string; + paddingTop: string; + length: number; + right: string; + baselineShift: string; + borderLeft: string; + widows: string; + lineHeight: string; + left: string; + textUnderlinePosition: string; + glyphOrientationHorizontal: string; + display: string; + textAnchor: string; + cssFloat: string; + strokeDasharray: string; + rubyAlign: string; + fontSizeAdjust: string; + borderLeftColor: string; + backgroundImage: string; + listStyleType: string; + strokeWidth: string; + textOverflow: string; + fillRule: string; + borderBottomColor: string; + zIndex: string; + position: string; + listStyle: string; + msTransformOrigin: string; + dominantBaseline: string; + overflowY: string; + fill: string; + captionSide: string; + borderCollapse: string; + boxShadow: string; + quotes: string; + tableLayout: string; + unicodeBidi: string; + borderBottomWidth: string; + backgroundSize: string; + textDecoration: string; + strokeDashoffset: string; + fontSize: string; + border: string; + pageBreakBefore: string; + borderTopRightRadius: string; + msTransform: string; + borderBottomLeftRadius: string; + textTransform: string; + rubyPosition: string; + strokeLinejoin: string; + clipPath: string; + borderRightColor: string; + fontFamily: string; + clear: string; + content: string; + backgroundClip: string; + marginBottom: string; + counterReset: string; + outlineWidth: string; + marginRight: string; + paddingLeft: string; + borderBottom: string; + wordBreak: string; + marginTop: string; + top: string; + fontWeight: string; + borderRight: string; + width: string; + kerning: string; + pageBreakAfter: string; + borderBottomStyle: string; + fontStretch: string; + padding: string; + strokeOpacity: string; + markerStart: string; + bottom: string; + borderLeftWidth: string; + clipRule: string; + backgroundPosition: string; + backgroundColor: string; + pageBreakInside: string; + backgroundOrigin: string; + strokeLinecap: string; + borderTopWidth: string; + outlineStyle: string; + borderTop: string; + outlineColor: string; + paddingBottom: string; + marginLeft: string; + font: string; + outline: string; + wordSpacing: string; + maxHeight: string; + fillOpacity: string; + letterSpacing: string; + borderSpacing: string; + backgroundRepeat: string; + borderRadius: string; + borderWidth: string; + borderBottomRightRadius: string; + whiteSpace: string; + fontStyle: string; + minWidth: string; + stopColor: string; + borderTopLeftRadius: string; + borderColor: string; + marker: string; + glyphOrientationVertical: string; + markerMid: string; + fontVariant: string; + minHeight: string; + stroke: string; + rubyOverhang: string; + overflowX: string; + textAlign: string; + margin: string; + getPropertyPriority(propertyName: string): string; + getPropertyValue(propertyName: string): string; + removeProperty(propertyName: string): string; + item(index: number): string; + [index: number]: string; + setProperty(propertyName: string, value: string, priority?: string): void; +} +declare var CSSStyleDeclaration: { + prototype: CSSStyleDeclaration; + new (): CSSStyleDeclaration; +} + +interface SVGGElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { +} +declare var SVGGElement: { + prototype: SVGGElement; + new (): SVGGElement; +} + +interface MSStyleCSSProperties extends MSCSSProperties { + pixelWidth: number; + posHeight: number; + posLeft: number; + pixelTop: number; + pixelBottom: number; + textDecorationNone: boolean; + pixelLeft: number; + posTop: number; + posBottom: number; + textDecorationOverline: boolean; + posWidth: number; + textDecorationLineThrough: boolean; + pixelHeight: number; + textDecorationBlink: boolean; + posRight: number; + pixelRight: number; + textDecorationUnderline: boolean; +} +declare var MSStyleCSSProperties: { + prototype: MSStyleCSSProperties; + new (): MSStyleCSSProperties; +} + +interface Navigator extends NavigatorID, NavigatorOnLine, NavigatorContentUtils, MSNavigatorExtensions, NavigatorGeolocation, MSNavigatorDoNotTrack, NavigatorStorageUtils { +} +declare var Navigator: { + prototype: Navigator; + new (): Navigator; +} + +interface SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg { + y: number; + x2: number; + x: number; + y2: number; +} +declare var SVGPathSegCurvetoCubicSmoothAbs: { + prototype: SVGPathSegCurvetoCubicSmoothAbs; + new (): SVGPathSegCurvetoCubicSmoothAbs; +} + +interface SVGZoomEvent extends UIEvent { + zoomRectScreen: SVGRect; + previousScale: number; + newScale: number; + previousTranslate: SVGPoint; + newTranslate: SVGPoint; +} +declare var SVGZoomEvent: { + prototype: SVGZoomEvent; + new (): SVGZoomEvent; +} + +interface NodeSelector { + querySelectorAll(selectors: string): NodeList; + querySelector(selectors: string): Element; +} + +interface HTMLTableDataCellElement extends HTMLTableCellElement { +} +declare var HTMLTableDataCellElement: { + prototype: HTMLTableDataCellElement; + new (): HTMLTableDataCellElement; +} + +interface HTMLBaseElement extends HTMLElement { + /** + * Sets or retrieves the window or frame at which to target content. + */ + target: string; + /** + * Gets or sets the baseline URL on which relative links are based. + */ + href: string; +} +declare var HTMLBaseElement: { + prototype: HTMLBaseElement; + new (): HTMLBaseElement; +} + +interface ClientRect { + left: number; + width: number; + right: number; + top: number; + bottom: number; + height: number; +} +declare var ClientRect: { + prototype: ClientRect; + new (): ClientRect; +} + +interface PositionErrorCallback { + (error: PositionError): void; +} + +interface DOMImplementation { + createDocumentType(qualifiedName: string, publicId: string, systemId: string): DocumentType; + createDocument(namespaceURI: string, qualifiedName: string, doctype: DocumentType): Document; + hasFeature(feature: string, version?: string): boolean; + createHTMLDocument(title: string): Document; +} +declare var DOMImplementation: { + prototype: DOMImplementation; + new (): DOMImplementation; +} + +interface SVGUnitTypes { + SVG_UNIT_TYPE_UNKNOWN: number; + SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number; + SVG_UNIT_TYPE_USERSPACEONUSE: number; +} +declare var SVGUnitTypes: { + prototype: SVGUnitTypes; + new (): SVGUnitTypes; + SVG_UNIT_TYPE_UNKNOWN: number; + SVG_UNIT_TYPE_OBJECTBOUNDINGBOX: number; + SVG_UNIT_TYPE_USERSPACEONUSE: number; +} + +interface Element extends Node, NodeSelector, ElementTraversal { + scrollTop: number; + clientLeft: number; + scrollLeft: number; + tagName: string; + clientWidth: number; + scrollWidth: number; + clientHeight: number; + clientTop: number; + scrollHeight: number; + getAttribute(name?: string): string; + getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList; + hasAttributeNS(namespaceURI: string, localName: string): boolean; + getBoundingClientRect(): ClientRect; + getAttributeNS(namespaceURI: string, localName: string): string; + getAttributeNodeNS(namespaceURI: string, localName: string): Attr; + setAttributeNodeNS(newAttr: Attr): Attr; + msMatchesSelector(selectors: string): boolean; + hasAttribute(name: string): boolean; + removeAttribute(name?: string): void; + setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void; + getAttributeNode(name: string): Attr; + fireEvent(eventName: string, eventObj?: any): boolean; + getElementsByTagName(name: "a"): NodeListOf; + getElementsByTagName(name: "abbr"): NodeListOf; + getElementsByTagName(name: "address"): NodeListOf; + getElementsByTagName(name: "area"): NodeListOf; + getElementsByTagName(name: "article"): NodeListOf; + getElementsByTagName(name: "aside"): NodeListOf; + getElementsByTagName(name: "audio"): NodeListOf; + getElementsByTagName(name: "b"): NodeListOf; + getElementsByTagName(name: "base"): NodeListOf; + getElementsByTagName(name: "bdi"): NodeListOf; + getElementsByTagName(name: "bdo"): NodeListOf; + getElementsByTagName(name: "blockquote"): NodeListOf; + getElementsByTagName(name: "body"): NodeListOf; + getElementsByTagName(name: "br"): NodeListOf; + getElementsByTagName(name: "button"): NodeListOf; + getElementsByTagName(name: "canvas"): NodeListOf; + getElementsByTagName(name: "caption"): NodeListOf; + getElementsByTagName(name: "cite"): NodeListOf; + getElementsByTagName(name: "code"): NodeListOf; + getElementsByTagName(name: "col"): NodeListOf; + getElementsByTagName(name: "colgroup"): NodeListOf; + getElementsByTagName(name: "datalist"): NodeListOf; + getElementsByTagName(name: "dd"): NodeListOf; + getElementsByTagName(name: "del"): NodeListOf; + getElementsByTagName(name: "dfn"): NodeListOf; + getElementsByTagName(name: "div"): NodeListOf; + getElementsByTagName(name: "dl"): NodeListOf; + getElementsByTagName(name: "dt"): NodeListOf; + getElementsByTagName(name: "em"): NodeListOf; + getElementsByTagName(name: "embed"): NodeListOf; + getElementsByTagName(name: "fieldset"): NodeListOf; + getElementsByTagName(name: "figcaption"): NodeListOf; + getElementsByTagName(name: "figure"): NodeListOf; + getElementsByTagName(name: "footer"): NodeListOf; + getElementsByTagName(name: "form"): NodeListOf; + getElementsByTagName(name: "h1"): NodeListOf; + getElementsByTagName(name: "h2"): NodeListOf; + getElementsByTagName(name: "h3"): NodeListOf; + getElementsByTagName(name: "h4"): NodeListOf; + getElementsByTagName(name: "h5"): NodeListOf; + getElementsByTagName(name: "h6"): NodeListOf; + getElementsByTagName(name: "head"): NodeListOf; + getElementsByTagName(name: "header"): NodeListOf; + getElementsByTagName(name: "hgroup"): NodeListOf; + getElementsByTagName(name: "hr"): NodeListOf; + getElementsByTagName(name: "html"): NodeListOf; + getElementsByTagName(name: "i"): NodeListOf; + getElementsByTagName(name: "iframe"): NodeListOf; + getElementsByTagName(name: "img"): NodeListOf; + getElementsByTagName(name: "input"): NodeListOf; + getElementsByTagName(name: "ins"): NodeListOf; + getElementsByTagName(name: "kbd"): NodeListOf; + getElementsByTagName(name: "label"): NodeListOf; + getElementsByTagName(name: "legend"): NodeListOf; + getElementsByTagName(name: "li"): NodeListOf; + getElementsByTagName(name: "link"): NodeListOf; + getElementsByTagName(name: "main"): NodeListOf; + getElementsByTagName(name: "map"): NodeListOf; + getElementsByTagName(name: "mark"): NodeListOf; + getElementsByTagName(name: "menu"): NodeListOf; + getElementsByTagName(name: "meta"): NodeListOf; + getElementsByTagName(name: "nav"): NodeListOf; + getElementsByTagName(name: "noscript"): NodeListOf; + getElementsByTagName(name: "object"): NodeListOf; + getElementsByTagName(name: "ol"): NodeListOf; + getElementsByTagName(name: "optgroup"): NodeListOf; + getElementsByTagName(name: "option"): NodeListOf; + getElementsByTagName(name: "p"): NodeListOf; + getElementsByTagName(name: "param"): NodeListOf; + getElementsByTagName(name: "pre"): NodeListOf; + getElementsByTagName(name: "progress"): NodeListOf; + getElementsByTagName(name: "q"): NodeListOf; + getElementsByTagName(name: "rp"): NodeListOf; + getElementsByTagName(name: "rt"): NodeListOf; + getElementsByTagName(name: "ruby"): NodeListOf; + getElementsByTagName(name: "s"): NodeListOf; + getElementsByTagName(name: "samp"): NodeListOf; + getElementsByTagName(name: "script"): NodeListOf; + getElementsByTagName(name: "section"): NodeListOf; + getElementsByTagName(name: "select"): NodeListOf; + getElementsByTagName(name: "small"): NodeListOf; + getElementsByTagName(name: "source"): NodeListOf; + getElementsByTagName(name: "span"): NodeListOf; + getElementsByTagName(name: "strong"): NodeListOf; + getElementsByTagName(name: "style"): NodeListOf; + getElementsByTagName(name: "sub"): NodeListOf; + getElementsByTagName(name: "summary"): NodeListOf; + getElementsByTagName(name: "sup"): NodeListOf; + getElementsByTagName(name: "table"): NodeListOf; + getElementsByTagName(name: "tbody"): NodeListOf; + getElementsByTagName(name: "td"): NodeListOf; + getElementsByTagName(name: "textarea"): NodeListOf; + getElementsByTagName(name: "tfoot"): NodeListOf; + getElementsByTagName(name: "th"): NodeListOf; + getElementsByTagName(name: "thead"): NodeListOf; + getElementsByTagName(name: "title"): NodeListOf; + getElementsByTagName(name: "tr"): NodeListOf; + getElementsByTagName(name: "track"): NodeListOf; + getElementsByTagName(name: "u"): NodeListOf; + getElementsByTagName(name: "ul"): NodeListOf; + getElementsByTagName(name: "var"): NodeListOf; + getElementsByTagName(name: "video"): NodeListOf; + getElementsByTagName(name: "wbr"): NodeListOf; + getElementsByTagName(name: string): NodeList; + getClientRects(): ClientRectList; + setAttributeNode(newAttr: Attr): Attr; + removeAttributeNode(oldAttr: Attr): Attr; + setAttribute(name?: string, value?: string): void; + removeAttributeNS(namespaceURI: string, localName: string): void; +} +declare var Element: { + prototype: Element; + new (): Element; +} + +interface HTMLNextIdElement extends HTMLElement { + n: string; +} +declare var HTMLNextIdElement: { + prototype: HTMLNextIdElement; + new (): HTMLNextIdElement; +} + +interface SVGPathSegMovetoRel extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegMovetoRel: { + prototype: SVGPathSegMovetoRel; + new (): SVGPathSegMovetoRel; +} + +interface SVGLineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + y1: SVGAnimatedLength; + x2: SVGAnimatedLength; + x1: SVGAnimatedLength; + y2: SVGAnimatedLength; +} +declare var SVGLineElement: { + prototype: SVGLineElement; + new (): SVGLineElement; +} + +interface HTMLParagraphElement extends HTMLElement, DOML2DeprecatedTextFlowControl { + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; +} +declare var HTMLParagraphElement: { + prototype: HTMLParagraphElement; + new (): HTMLParagraphElement; +} + +interface HTMLAreasCollection extends HTMLCollection { + /** + * Removes an element from the collection. + */ + remove(index?: number): void; + /** + * Adds an element to the areas, controlRange, or options collection. + */ + add(element: HTMLElement, before?: any): void; +} +declare var HTMLAreasCollection: { + prototype: HTMLAreasCollection; + new (): HTMLAreasCollection; +} + +interface SVGDescElement extends SVGElement, SVGStylable, SVGLangSpace { +} +declare var SVGDescElement: { + prototype: SVGDescElement; + new (): SVGDescElement; +} + +interface Node extends EventTarget { + nodeType: number; + previousSibling: Node; + localName: string; + namespaceURI: string; + textContent: string; + parentNode: Node; + nextSibling: Node; + nodeValue: string; + lastChild: Node; + childNodes: NodeList; + nodeName: string; + ownerDocument: Document; + attributes: NamedNodeMap; + firstChild: Node; + prefix: string; + removeChild(oldChild: Node): Node; + appendChild(newChild: Node): Node; + isSupported(feature: string, version: string): boolean; + isEqualNode(arg: Node): boolean; + lookupPrefix(namespaceURI: string): string; + isDefaultNamespace(namespaceURI: string): boolean; + compareDocumentPosition(other: Node): number; + normalize(): void; + isSameNode(other: Node): boolean; + hasAttributes(): boolean; + lookupNamespaceURI(prefix: string): string; + cloneNode(deep?: boolean): Node; + hasChildNodes(): boolean; + replaceChild(newChild: Node, oldChild: Node): Node; + insertBefore(newChild: Node, refChild?: Node): Node; + ENTITY_REFERENCE_NODE: number; + ATTRIBUTE_NODE: number; + DOCUMENT_FRAGMENT_NODE: number; + TEXT_NODE: number; + ELEMENT_NODE: number; + COMMENT_NODE: number; + DOCUMENT_POSITION_DISCONNECTED: number; + DOCUMENT_POSITION_CONTAINED_BY: number; + DOCUMENT_POSITION_CONTAINS: number; + DOCUMENT_TYPE_NODE: number; + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number; + DOCUMENT_NODE: number; + ENTITY_NODE: number; + PROCESSING_INSTRUCTION_NODE: number; + CDATA_SECTION_NODE: number; + NOTATION_NODE: number; + DOCUMENT_POSITION_FOLLOWING: number; + DOCUMENT_POSITION_PRECEDING: number; +} +declare var Node: { + prototype: Node; + new (): Node; + ENTITY_REFERENCE_NODE: number; + ATTRIBUTE_NODE: number; + DOCUMENT_FRAGMENT_NODE: number; + TEXT_NODE: number; + ELEMENT_NODE: number; + COMMENT_NODE: number; + DOCUMENT_POSITION_DISCONNECTED: number; + DOCUMENT_POSITION_CONTAINED_BY: number; + DOCUMENT_POSITION_CONTAINS: number; + DOCUMENT_TYPE_NODE: number; + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number; + DOCUMENT_NODE: number; + ENTITY_NODE: number; + PROCESSING_INSTRUCTION_NODE: number; + CDATA_SECTION_NODE: number; + NOTATION_NODE: number; + DOCUMENT_POSITION_FOLLOWING: number; + DOCUMENT_POSITION_PRECEDING: number; +} + +interface SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegCurvetoQuadraticSmoothRel: { + prototype: SVGPathSegCurvetoQuadraticSmoothRel; + new (): SVGPathSegCurvetoQuadraticSmoothRel; +} + +interface DOML2DeprecatedListSpaceReduction { + compact: boolean; +} + +interface MSScriptHost { +} +declare var MSScriptHost: { + prototype: MSScriptHost; + new (): MSScriptHost; +} + +interface SVGClipPathElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + clipPathUnits: SVGAnimatedEnumeration; +} +declare var SVGClipPathElement: { + prototype: SVGClipPathElement; + new (): SVGClipPathElement; +} + +interface MouseEvent extends UIEvent { + toElement: Element; + layerY: number; + fromElement: Element; + which: number; + pageX: number; + offsetY: number; + x: number; + y: number; + metaKey: boolean; + altKey: boolean; + ctrlKey: boolean; + offsetX: number; + screenX: number; + clientY: number; + shiftKey: boolean; + layerX: number; + screenY: number; + relatedTarget: EventTarget; + button: number; + pageY: number; + buttons: number; + clientX: number; + initMouseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget): void; + getModifierState(keyArg: string): boolean; +} +declare var MouseEvent: { + prototype: MouseEvent; + new (): MouseEvent; +} + +interface RangeException { + code: number; + message: string; + toString(): string; + INVALID_NODE_TYPE_ERR: number; + BAD_BOUNDARYPOINTS_ERR: number; +} +declare var RangeException: { + prototype: RangeException; + new (): RangeException; + INVALID_NODE_TYPE_ERR: number; + BAD_BOUNDARYPOINTS_ERR: number; +} + +interface SVGTextPositioningElement extends SVGTextContentElement { + y: SVGAnimatedLengthList; + rotate: SVGAnimatedNumberList; + dy: SVGAnimatedLengthList; + x: SVGAnimatedLengthList; + dx: SVGAnimatedLengthList; +} +declare var SVGTextPositioningElement: { + prototype: SVGTextPositioningElement; + new (): SVGTextPositioningElement; +} + +interface HTMLAppletElement extends HTMLElement, DOML2DeprecatedMarginStyle, DOML2DeprecatedBorderStyle, DOML2DeprecatedAlignmentStyle, MSDataBindingExtensions, MSDataBindingRecordSetExtensions { + width: number; + /** + * Sets or retrieves the Internet media type for the code associated with the object. + */ + codeType: string; + object: string; + form: HTMLFormElement; + code: string; + /** + * Sets or retrieves a character string that can be used to implement your own archive functionality for the object. + */ + archive: string; + /** + * Sets or retrieves a text alternative to the graphic. + */ + alt: string; + /** + * Sets or retrieves a message to be displayed while an object is loading. + */ + standby: string; + /** + * Sets or retrieves the class identifier for the object. + */ + classid: string; + /** + * Sets or retrieves the shape of the object. + */ + name: string; + /** + * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. + */ + useMap: string; + /** + * Sets or retrieves the URL that references the data of the object. + */ + data: string; + /** + * Sets or retrieves the height of the object. + */ + height: string; + /** + * Gets or sets the optional alternative HTML script to execute if the object fails to load. + */ + altHtml: string; + /** + * Address of a pointer to the document this page or frame contains. If there is no document, then null will be returned. + */ + contentDocument: Document; + /** + * Sets or retrieves the URL of the component. + */ + codeBase: string; + /** + * Sets or retrieves a character string that can be used to implement your own declare functionality for the object. + */ + declare: boolean; + /** + * Returns the content type of the object. + */ + type: string; + /** + * Retrieves a string of the URL where the object tag can be found. This is often the href of the document that the object is in, or the value set by a base element. + */ + BaseHref: string; +} +declare var HTMLAppletElement: { + prototype: HTMLAppletElement; + new (): HTMLAppletElement; +} + +interface TextMetrics { + width: number; +} +declare var TextMetrics: { + prototype: TextMetrics; + new (): TextMetrics; +} + +interface DocumentEvent { + createEvent(eventInterface: string): Event; +} + +interface HTMLOListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle { + /** + * The starting number. + */ + start: number; +} +declare var HTMLOListElement: { + prototype: HTMLOListElement; + new (): HTMLOListElement; +} + +interface SVGPathSegLinetoVerticalRel extends SVGPathSeg { + y: number; +} +declare var SVGPathSegLinetoVerticalRel: { + prototype: SVGPathSegLinetoVerticalRel; + new (): SVGPathSegLinetoVerticalRel; +} + +interface SVGAnimatedString { + animVal: string; + baseVal: string; +} +declare var SVGAnimatedString: { + prototype: SVGAnimatedString; + new (): SVGAnimatedString; +} + +interface CDATASection extends Text { +} +declare var CDATASection: { + prototype: CDATASection; + new (): CDATASection; +} + +interface StyleMedia { + type: string; + matchMedium(mediaquery: string): boolean; +} +declare var StyleMedia: { + prototype: StyleMedia; + new (): StyleMedia; +} + +interface HTMLSelectElement extends HTMLElement, MSHTMLCollectionExtensions, MSDataBindingExtensions { + options: HTMLSelectElement; + /** + * Sets or retrieves the value which is returned to the server when the form control is submitted. + */ + value: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Sets or retrieves the number of rows in the list box. + */ + size: number; + /** + * Sets or retrieves the number of objects in a collection. + */ + length: number; + /** + * Sets or retrieves the index of the selected option in a select object. + */ + selectedIndex: number; + /** + * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. + */ + multiple: boolean; + /** + * Retrieves the type of select control based on the value of the MULTIPLE attribute. + */ + type: string; + /** + * Removes an element from the collection. + * @param index Number that specifies the zero-based index of the element to remove from the collection. + */ + remove(index?: number): void; + /** + * Adds an element to the areas, controlRange, or options collection. + * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection. + * @param before Variant of type Object that specifies an element to insert before, or null to append the object to the collection. + */ + add(element: HTMLElement, before?: any): void; + /** + * Retrieves a select object or an object from an options collection. + * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is an integer, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made. + * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned. + */ + item(name?: any, index?: any): any; + /** + * Retrieves a select object or an object from an options collection. + * @param namedItem A String that specifies the name or id property of the object to retrieve. A collection is returned if more than one match is made. + */ + namedItem(name: string): any; + [name: string]: any; +} +declare var HTMLSelectElement: { + prototype: HTMLSelectElement; + new (): HTMLSelectElement; +} + +interface TextRange { + boundingLeft: number; + htmlText: string; + offsetLeft: number; + boundingWidth: number; + boundingHeight: number; + boundingTop: number; + text: string; + offsetTop: number; + moveToPoint(x: number, y: number): void; + queryCommandValue(cmdID: string): any; + getBookmark(): string; + move(unit: string, count?: number): number; + queryCommandIndeterm(cmdID: string): boolean; + scrollIntoView(fStart?: boolean): void; + findText(string: string, count?: number, flags?: number): boolean; + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean; + getBoundingClientRect(): ClientRect; + moveToBookmark(bookmark: string): boolean; + isEqual(range: TextRange): boolean; + duplicate(): TextRange; + collapse(start?: boolean): void; + queryCommandText(cmdID: string): string; + select(): void; + pasteHTML(html: string): void; + inRange(range: TextRange): boolean; + moveEnd(unit: string, count?: number): number; + getClientRects(): ClientRectList; + moveStart(unit: string, count?: number): number; + parentElement(): Element; + queryCommandState(cmdID: string): boolean; + compareEndPoints(how: string, sourceRange: TextRange): number; + execCommandShowHelp(cmdID: string): boolean; + moveToElementText(element: Element): void; + expand(Unit: string): boolean; + queryCommandSupported(cmdID: string): boolean; + setEndPoint(how: string, SourceRange: TextRange): void; + queryCommandEnabled(cmdID: string): boolean; +} +declare var TextRange: { + prototype: TextRange; + new (): TextRange; +} + +interface SVGTests { + requiredFeatures: SVGStringList; + requiredExtensions: SVGStringList; + systemLanguage: SVGStringList; + hasExtension(extension: string): boolean; +} + +interface HTMLBlockElement extends HTMLElement, DOML2DeprecatedTextFlowControl { + /** + * Sets or retrieves the width of the object. + */ + width: number; + /** + * Sets or retrieves reference information about the object. + */ + cite: string; +} +declare var HTMLBlockElement: { + prototype: HTMLBlockElement; + new (): HTMLBlockElement; +} + +interface CSSStyleSheet extends StyleSheet { + owningElement: Element; + imports: StyleSheetList; + isAlternate: boolean; + rules: MSCSSRuleList; + isPrefAlternate: boolean; + readOnly: boolean; + cssText: string; + ownerRule: CSSRule; + href: string; + cssRules: CSSRuleList; + id: string; + pages: StyleSheetPageList; + addImport(bstrURL: string, lIndex?: number): number; + addPageRule(bstrSelector: string, bstrStyle: string, lIndex?: number): number; + insertRule(rule: string, index?: number): number; + removeRule(lIndex: number): void; + deleteRule(index?: number): void; + addRule(bstrSelector: string, bstrStyle?: string, lIndex?: number): number; + removeImport(lIndex: number): void; +} +declare var CSSStyleSheet: { + prototype: CSSStyleSheet; + new (): CSSStyleSheet; +} + +interface MSSelection { + type: string; + typeDetail: string; + createRange(): TextRange; + clear(): void; + createRangeCollection(): TextRangeCollection; + empty(): void; +} +declare var MSSelection: { + prototype: MSSelection; + new (): MSSelection; +} + +interface HTMLMetaElement extends HTMLElement { + /** + * Gets or sets information used to bind the value of a content attribute of a meta element to an HTTP response header. + */ + httpEquiv: string; + /** + * Sets or retrieves the value specified in the content attribute of the meta object. + */ + name: string; + /** + * Gets or sets meta-information to associate with httpEquiv or name. + */ + content: string; + /** + * Sets or retrieves the URL property that will be loaded after the specified time has elapsed. + */ + url: string; + /** + * Sets or retrieves a scheme to be used in interpreting the value of a property specified for the object. + */ + scheme: string; + /** + * Sets or retrieves the character set used to encode the object. + */ + charset: string; +} +declare var HTMLMetaElement: { + prototype: HTMLMetaElement; + new (): HTMLMetaElement; +} + +interface SVGPatternElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests, SVGFitToViewBox, SVGExternalResourcesRequired, SVGURIReference { + patternUnits: SVGAnimatedEnumeration; + y: SVGAnimatedLength; + width: SVGAnimatedLength; + x: SVGAnimatedLength; + patternContentUnits: SVGAnimatedEnumeration; + patternTransform: SVGAnimatedTransformList; + height: SVGAnimatedLength; +} +declare var SVGPatternElement: { + prototype: SVGPatternElement; + new (): SVGPatternElement; +} + +interface SVGAnimatedAngle { + animVal: SVGAngle; + baseVal: SVGAngle; +} +declare var SVGAnimatedAngle: { + prototype: SVGAnimatedAngle; + new (): SVGAnimatedAngle; +} + +interface Selection { + isCollapsed: boolean; + anchorNode: Node; + focusNode: Node; + anchorOffset: number; + focusOffset: number; + rangeCount: number; + addRange(range: Range): void; + collapseToEnd(): void; + toString(): string; + selectAllChildren(parentNode: Node): void; + getRangeAt(index: number): Range; + collapse(parentNode: Node, offset: number): void; + removeAllRanges(): void; + collapseToStart(): void; + deleteFromDocument(): void; + removeRange(range: Range): void; +} +declare var Selection: { + prototype: Selection; + new (): Selection; +} + +interface SVGScriptElement extends SVGElement, SVGExternalResourcesRequired, SVGURIReference { + type: string; +} +declare var SVGScriptElement: { + prototype: SVGScriptElement; + new (): SVGScriptElement; +} + +interface HTMLDDElement extends HTMLElement { + /** + * Sets or retrieves whether the browser automatically performs wordwrap. + */ + noWrap: boolean; +} +declare var HTMLDDElement: { + prototype: HTMLDDElement; + new (): HTMLDDElement; +} + +interface MSDataBindingRecordSetReadonlyExtensions { + recordset: Object; + namedRecordset(dataMember: string, hierarchy?: any): Object; +} + +interface CSSStyleRule extends CSSRule { + selectorText: string; + style: MSStyleCSSProperties; + readOnly: boolean; +} +declare var CSSStyleRule: { + prototype: CSSStyleRule; + new (): CSSStyleRule; +} + +interface NodeIterator { + whatToShow: number; + filter: NodeFilter; + root: Node; + expandEntityReferences: boolean; + nextNode(): Node; + detach(): void; + previousNode(): Node; +} +declare var NodeIterator: { + prototype: NodeIterator; + new (): NodeIterator; +} + +interface SVGViewElement extends SVGElement, SVGZoomAndPan, SVGFitToViewBox, SVGExternalResourcesRequired { + viewTarget: SVGStringList; +} +declare var SVGViewElement: { + prototype: SVGViewElement; + new (): SVGViewElement; +} + +interface HTMLLinkElement extends HTMLElement, LinkStyle { + /** + * Sets or retrieves the relationship between the object and the destination of the link. + */ + rel: string; + /** + * Sets or retrieves the window or frame at which to target content. + */ + target: string; + /** + * Sets or retrieves a destination URL or an anchor point. + */ + href: string; + /** + * Sets or retrieves the media type. + */ + media: string; + /** + * Sets or retrieves the relationship between the object and the destination of the link. + */ + rev: string; + /** + * Sets or retrieves the MIME type of the object. + */ + type: string; + /** + * Sets or retrieves the character set used to encode the object. + */ + charset: string; + /** + * Sets or retrieves the language code of the object. + */ + hreflang: string; +} +declare var HTMLLinkElement: { + prototype: HTMLLinkElement; + new (): HTMLLinkElement; +} + +interface SVGLocatable { + farthestViewportElement: SVGElement; + nearestViewportElement: SVGElement; + getBBox(): SVGRect; + getTransformToElement(element: SVGElement): SVGMatrix; + getCTM(): SVGMatrix; + getScreenCTM(): SVGMatrix; +} + +interface HTMLFontElement extends HTMLElement, DOML2DeprecatedColorProperty, DOML2DeprecatedSizeProperty { + /** + * Sets or retrieves the current typeface family. + */ + face: string; +} +declare var HTMLFontElement: { + prototype: HTMLFontElement; + new (): HTMLFontElement; +} + +interface SVGTitleElement extends SVGElement, SVGStylable, SVGLangSpace { +} +declare var SVGTitleElement: { + prototype: SVGTitleElement; + new (): SVGTitleElement; +} + +interface ControlRangeCollection { + length: number; + queryCommandValue(cmdID: string): any; + remove(index: number): void; + add(item: Element): void; + queryCommandIndeterm(cmdID: string): boolean; + scrollIntoView(varargStart?: any): void; + item(index: number): Element; + [index: number]: Element; + execCommand(cmdID: string, showUI?: boolean, value?: any): boolean; + addElement(item: Element): void; + queryCommandState(cmdID: string): boolean; + queryCommandSupported(cmdID: string): boolean; + queryCommandEnabled(cmdID: string): boolean; + queryCommandText(cmdID: string): string; + select(): void; +} +declare var ControlRangeCollection: { + prototype: ControlRangeCollection; + new (): ControlRangeCollection; +} + +interface MSNamespaceInfo extends MSEventAttachmentTarget { + urn: string; + onreadystatechange: (ev: Event) => any; + addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; + name: string; + readyState: string; + doImport(implementationUrl: string): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var MSNamespaceInfo: { + prototype: MSNamespaceInfo; + new (): MSNamespaceInfo; +} + +interface WindowSessionStorage { + sessionStorage: Storage; +} + +interface SVGAnimatedTransformList { + animVal: SVGTransformList; + baseVal: SVGTransformList; +} +declare var SVGAnimatedTransformList: { + prototype: SVGAnimatedTransformList; + new (): SVGAnimatedTransformList; +} + +interface HTMLTableCaptionElement extends HTMLElement { + /** + * Sets or retrieves the alignment of the caption or legend. + */ + align: string; + /** + * Sets or retrieves whether the caption appears at the top or bottom of the table. + */ + vAlign: string; +} +declare var HTMLTableCaptionElement: { + prototype: HTMLTableCaptionElement; + new (): HTMLTableCaptionElement; +} + +interface HTMLOptionElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the ordinal position of an option in a list box. + */ + index: number; + /** + * Sets or retrieves the status of an option. + */ + defaultSelected: boolean; + /** + * Sets or retrieves the value which is returned to the server when the form control is submitted. + */ + value: string; + /** + * Sets or retrieves the text string specified by the option tag. + */ + text: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves a value that you can use to implement your own label functionality for the object. + */ + label: string; + /** + * Sets or retrieves whether the option in the list box is the default item. + */ + selected: boolean; + create(): HTMLOptionElement; +} +declare var HTMLOptionElement: { + prototype: HTMLOptionElement; + new (): HTMLOptionElement; +} + +interface HTMLMapElement extends HTMLElement { + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Retrieves a collection of the area objects defined for the given map object. + */ + areas: HTMLAreasCollection; +} +declare var HTMLMapElement: { + prototype: HTMLMapElement; + new (): HTMLMapElement; +} + +interface HTMLMenuElement extends HTMLElement, DOML2DeprecatedListSpaceReduction { + type: string; +} +declare var HTMLMenuElement: { + prototype: HTMLMenuElement; + new (): HTMLMenuElement; +} + +interface MouseWheelEvent extends MouseEvent { + wheelDelta: number; + initMouseWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, wheelDeltaArg: number): void; +} +declare var MouseWheelEvent: { + prototype: MouseWheelEvent; + new (): MouseWheelEvent; +} + +interface SVGFitToViewBox { + viewBox: SVGAnimatedRect; + preserveAspectRatio: SVGAnimatedPreserveAspectRatio; +} + +interface SVGPointList { + numberOfItems: number; + replaceItem(newItem: SVGPoint, index: number): SVGPoint; + getItem(index: number): SVGPoint; + clear(): void; + appendItem(newItem: SVGPoint): SVGPoint; + initialize(newItem: SVGPoint): SVGPoint; + removeItem(index: number): SVGPoint; + insertItemBefore(newItem: SVGPoint, index: number): SVGPoint; +} +declare var SVGPointList: { + prototype: SVGPointList; + new (): SVGPointList; +} + +interface SVGAnimatedLengthList { + animVal: SVGLengthList; + baseVal: SVGLengthList; +} +declare var SVGAnimatedLengthList: { + prototype: SVGAnimatedLengthList; + new (): SVGAnimatedLengthList; +} + +interface Window extends EventTarget, MSEventAttachmentTarget, WindowLocalStorage, MSWindowExtensions, WindowSessionStorage, WindowTimers { + ondragend: (ev: DragEvent) => any; + addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onkeydown: (ev: KeyboardEvent) => any; + addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + ondragover: (ev: DragEvent) => any; + addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onkeyup: (ev: KeyboardEvent) => any; + addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + onreset: (ev: Event) => any; + addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void; + onmouseup: (ev: MouseEvent) => any; + addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + ondragstart: (ev: DragEvent) => any; + addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + ondrag: (ev: DragEvent) => any; + addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + screenX: number; + onmouseover: (ev: MouseEvent) => any; + addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + ondragleave: (ev: DragEvent) => any; + addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + history: History; + pageXOffset: number; + name: string; + onafterprint: (ev: Event) => any; + addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void; + onpause: (ev: Event) => any; + addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void; + onbeforeprint: (ev: Event) => any; + addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void; + top: Window; + onmousedown: (ev: MouseEvent) => any; + addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onseeked: (ev: Event) => any; + addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void; + opener: Window; + onclick: (ev: MouseEvent) => any; + addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + innerHeight: number; + onwaiting: (ev: Event) => any; + addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; + ononline: (ev: Event) => any; + addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void; + ondurationchange: (ev: Event) => any; + addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void; + frames: Window; + onblur: (ev: FocusEvent) => any; + addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onemptied: (ev: Event) => any; + addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void; + onseeking: (ev: Event) => any; + addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void; + oncanplay: (ev: Event) => any; + addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void; + outerWidth: number; + onstalled: (ev: Event) => any; + addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void; + onmousemove: (ev: MouseEvent) => any; + addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + innerWidth: number; + onoffline: (ev: Event) => any; + addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void; + length: number; + screen: Screen; + onbeforeunload: (ev: BeforeUnloadEvent) => any; + addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void; + onratechange: (ev: Event) => any; + addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void; + onstorage: (ev: StorageEvent) => any; + addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void; + onloadstart: (ev: Event) => any; + addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void; + ondragenter: (ev: DragEvent) => any; + addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onsubmit: (ev: Event) => any; + addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void; + self: Window; + document: Document; + onprogress: (ev: any) => any; + addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; + ondblclick: (ev: MouseEvent) => any; + addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + pageYOffset: number; + oncontextmenu: (ev: MouseEvent) => any; + addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onchange: (ev: Event) => any; + addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void; + onloadedmetadata: (ev: Event) => any; + addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void; + onplay: (ev: Event) => any; + addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void; + onerror: ErrorEventHandler; + onplaying: (ev: Event) => any; + addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void; + parent: Window; + location: Location; + oncanplaythrough: (ev: Event) => any; + addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void; + onabort: (ev: UIEvent) => any; + addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + onreadystatechange: (ev: Event) => any; + addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; + outerHeight: number; + onkeypress: (ev: KeyboardEvent) => any; + addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + frameElement: Element; + onloadeddata: (ev: Event) => any; + addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void; + onsuspend: (ev: Event) => any; + addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void; + window: Window; + onfocus: (ev: FocusEvent) => any; + addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onmessage: (ev: MessageEvent) => any; + addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void; + ontimeupdate: (ev: Event) => any; + addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void; + onresize: (ev: UIEvent) => any; + addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + onselect: (ev: UIEvent) => any; + addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + navigator: Navigator; + styleMedia: StyleMedia; + ondrop: (ev: DragEvent) => any; + addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onmouseout: (ev: MouseEvent) => any; + addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onended: (ev: Event) => any; + addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void; + onhashchange: (ev: Event) => any; + addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void; + onunload: (ev: Event) => any; + addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void; + onscroll: (ev: UIEvent) => any; + addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + screenY: number; + onmousewheel: (ev: MouseWheelEvent) => any; + addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + onvolumechange: (ev: Event) => any; + addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; + oninput: (ev: Event) => any; + addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void; + performance: Performance; + alert(message?: any): void; + scroll(x?: number, y?: number): void; + focus(): void; + scrollTo(x?: number, y?: number): void; + print(): void; + prompt(message?: string, defaul?: string): string; + toString(): string; + open(url?: string, target?: string, features?: string, replace?: boolean): Window; + scrollBy(x?: number, y?: number): void; + confirm(message?: string): boolean; + close(): void; + postMessage(message: any, targetOrigin: string, ports?: any): void; + showModalDialog(url?: string, argument?: any, options?: any): any; + blur(): void; + getSelection(): Selection; + getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var Window: { + prototype: Window; + new (): Window; +} + +interface SVGAnimatedPreserveAspectRatio { + animVal: SVGPreserveAspectRatio; + baseVal: SVGPreserveAspectRatio; +} +declare var SVGAnimatedPreserveAspectRatio: { + prototype: SVGAnimatedPreserveAspectRatio; + new (): SVGAnimatedPreserveAspectRatio; +} + +interface MSSiteModeEvent extends Event { + buttonID: number; + actionURL: string; +} +declare var MSSiteModeEvent: { + prototype: MSSiteModeEvent; + new (): MSSiteModeEvent; +} + +interface DOML2DeprecatedTextFlowControl { + clear: string; +} + +interface StyleSheetPageList { + length: number; + item(index: number): CSSPageRule; + [index: number]: CSSPageRule; +} +declare var StyleSheetPageList: { + prototype: StyleSheetPageList; + new (): StyleSheetPageList; +} + +interface MSCSSProperties extends CSSStyleDeclaration { + scrollbarShadowColor: string; + scrollbarHighlightColor: string; + layoutGridChar: string; + layoutGridType: string; + textAutospace: string; + textKashidaSpace: string; + writingMode: string; + scrollbarFaceColor: string; + backgroundPositionY: string; + lineBreak: string; + imeMode: string; + msBlockProgression: string; + layoutGridLine: string; + scrollbarBaseColor: string; + layoutGrid: string; + layoutFlow: string; + textKashida: string; + filter: string; + zoom: string; + scrollbarArrowColor: string; + behavior: string; + backgroundPositionX: string; + accelerator: string; + layoutGridMode: string; + textJustifyTrim: string; + scrollbar3dLightColor: string; + msInterpolationMode: string; + scrollbarTrackColor: string; + scrollbarDarkShadowColor: string; + styleFloat: string; + getAttribute(attributeName: string, flags?: number): any; + setAttribute(attributeName: string, AttributeValue: any, flags?: number): void; + removeAttribute(attributeName: string, flags?: number): boolean; +} +declare var MSCSSProperties: { + prototype: MSCSSProperties; + new (): MSCSSProperties; +} + +interface HTMLCollection extends MSHTMLCollectionExtensions { + /** + * Sets or retrieves the number of objects in a collection. + */ + length: number; + /** + * Retrieves an object from various collections. + */ + item(nameOrIndex?: any, optionalIndex?: any): Element; + /** + * Retrieves a select object or an object from an options collection. + */ + namedItem(name: string): Element; + [name: number]: Element; +} +declare var HTMLCollection: { + prototype: HTMLCollection; + new (): HTMLCollection; +} + +interface SVGExternalResourcesRequired { + externalResourcesRequired: SVGAnimatedBoolean; +} + +interface HTMLImageElement extends HTMLElement, MSImageResourceExtensions, MSDataBindingExtensions, MSResourceMetadata { + /** + * Sets or retrieves the width of the object. + */ + width: number; + /** + * Sets or retrieves the vertical margin for the object. + */ + vspace: number; + /** + * The original height of the image resource before sizing. + */ + naturalHeight: number; + /** + * Sets or retrieves a text alternative to the graphic. + */ + alt: string; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * The address or URL of the a media resource that is to be considered. + */ + src: string; + /** + * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. + */ + useMap: string; + /** + * The original width of the image resource before sizing. + */ + naturalWidth: number; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Sets or retrieves the height of the object. + */ + height: number; + /** + * Specifies the properties of a border drawn around an object. + */ + border: string; + /** + * Sets or retrieves the width of the border to draw around the object. + */ + hspace: number; + /** + * Sets or retrieves a Uniform Resource Identifier (URI) to a long description of the object. + */ + longDesc: string; + /** + * Contains the hypertext reference (HREF) of the URL. + */ + href: string; + /** + * Sets or retrieves whether the image is a server-side image map. + */ + isMap: boolean; + /** + * Retrieves whether the object is fully loaded. + */ + complete: boolean; + create(): HTMLImageElement; +} +declare var HTMLImageElement: { + prototype: HTMLImageElement; + new (): HTMLImageElement; +} + +interface HTMLAreaElement extends HTMLElement { + /** + * Sets or retrieves the protocol portion of a URL. + */ + protocol: string; + /** + * Sets or retrieves the substring of the href property that follows the question mark. + */ + search: string; + /** + * Sets or retrieves a text alternative to the graphic. + */ + alt: string; + /** + * Sets or retrieves the coordinates of the object. + */ + coords: string; + /** + * Sets or retrieves the host name part of the location or URL. + */ + hostname: string; + /** + * Sets or retrieves the port number associated with a URL. + */ + port: string; + /** + * Sets or retrieves the file name or path specified by the object. + */ + pathname: string; + /** + * Sets or retrieves the hostname and port number of the location or URL. + */ + host: string; + /** + * Sets or retrieves the subsection of the href property that follows the number sign (#). + */ + hash: string; + /** + * Sets or retrieves the window or frame at which to target content. + */ + target: string; + /** + * Sets or retrieves a destination URL or an anchor point. + */ + href: string; + /** + * Sets or gets whether clicks in this region cause action. + */ + noHref: boolean; + /** + * Sets or retrieves the shape of the object. + */ + shape: string; + /** + * Returns a string representation of an object. + */ + toString(): string; +} +declare var HTMLAreaElement: { + prototype: HTMLAreaElement; + new (): HTMLAreaElement; +} + +interface EventTarget { + removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + dispatchEvent(evt: Event): boolean; +} + +interface SVGAngle { + valueAsString: string; + valueInSpecifiedUnits: number; + value: number; + unitType: number; + newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void; + convertToSpecifiedUnits(unitType: number): void; + SVG_ANGLETYPE_RAD: number; + SVG_ANGLETYPE_UNKNOWN: number; + SVG_ANGLETYPE_UNSPECIFIED: number; + SVG_ANGLETYPE_DEG: number; + SVG_ANGLETYPE_GRAD: number; +} +declare var SVGAngle: { + prototype: SVGAngle; + new (): SVGAngle; + SVG_ANGLETYPE_RAD: number; + SVG_ANGLETYPE_UNKNOWN: number; + SVG_ANGLETYPE_UNSPECIFIED: number; + SVG_ANGLETYPE_DEG: number; + SVG_ANGLETYPE_GRAD: number; +} + +interface HTMLButtonElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the default or selected value of the control. + */ + value: string; + status: any; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Gets the classification and default behavior of the button. + */ + type: string; + /** + * Creates a TextRange object for the element. + */ + createTextRange(): TextRange; +} +declare var HTMLButtonElement: { + prototype: HTMLButtonElement; + new (): HTMLButtonElement; +} + +interface HTMLSourceElement extends HTMLElement { + /** + * The address or URL of the a media resource that is to be considered. + */ + src: string; + /** + * Gets or sets the intended media type of the media source. + */ + media: string; + /** + * Gets or sets the MIME type of a media resource. + */ + type: string; +} +declare var HTMLSourceElement: { + prototype: HTMLSourceElement; + new (): HTMLSourceElement; +} + +interface CanvasGradient { + addColorStop(offset: number, color: string): void; +} +declare var CanvasGradient: { + prototype: CanvasGradient; + new (): CanvasGradient; +} + +interface KeyboardEvent extends UIEvent { + location: number; + keyCode: number; + shiftKey: boolean; + which: number; + locale: string; + key: string; + altKey: boolean; + metaKey: boolean; + char: string; + ctrlKey: boolean; + repeat: boolean; + charCode: number; + getModifierState(keyArg: string): boolean; + initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void; + DOM_KEY_LOCATION_RIGHT: number; + DOM_KEY_LOCATION_STANDARD: number; + DOM_KEY_LOCATION_LEFT: number; + DOM_KEY_LOCATION_NUMPAD: number; + DOM_KEY_LOCATION_JOYSTICK: number; + DOM_KEY_LOCATION_MOBILE: number; +} +declare var KeyboardEvent: { + prototype: KeyboardEvent; + new (): KeyboardEvent; + DOM_KEY_LOCATION_RIGHT: number; + DOM_KEY_LOCATION_STANDARD: number; + DOM_KEY_LOCATION_LEFT: number; + DOM_KEY_LOCATION_NUMPAD: number; + DOM_KEY_LOCATION_JOYSTICK: number; + DOM_KEY_LOCATION_MOBILE: number; +} + +interface Document extends Node, NodeSelector, MSEventAttachmentTarget, DocumentEvent, MSResourceMetadata, MSNodeExtensions { + /** + * Retrieves the collection of user agents and versions declared in the X-UA-Compatible + */ + compatible: MSCompatibleInfoCollection; + /** + * Fires when the user presses a key. + * @param ev The keyboard event + */ + onkeydown: (ev: KeyboardEvent) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + /** + * Fires when the user releases a key. + * @param ev The keyboard event + */ + onkeyup: (ev: KeyboardEvent) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + + /** + * Gets the implementation object of the current document. + */ + implementation: DOMImplementation; + /** + * Fires when the user resets a form. + * @param ev The event. + */ + onreset: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Retrieves a collection of all script objects in the document. + */ + scripts: HTMLCollection; + + /** + * Fires when the user presses the F1 key while the browser is the active window. + * @param ev The event. + */ + onhelp: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires on the target object when the user moves the mouse out of a valid drop target during a drag operation. + * @param ev The drag event. + */ + ondragleave: (ev: DragEvent) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Gets or sets the character set used to encode the object. + */ + charset: string; + + /** + * Fires for an element just prior to setting focus on that element. + * @param ev The focus event + */ + onfocusin: (ev: FocusEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + + /** + * Sets or gets the color of the links that the user has visited. + */ + vlinkColor: string; + + /** + * Occurs when the seek operation ends. + * @param ev The event. + */ + onseeked: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void; + security: string; + + /** + * Contains the title of the document. + */ + title: string; + + /** + * Retrieves a collection of namespace objects. + */ + namespaces: MSNamespaceInfoCollection; + + /** + * Gets the default character set from the current regional language settings. + */ + defaultCharset: string; + + /** + * Retrieves a collection of all embed objects in the document. + */ + embeds: HTMLCollection; + + /** + * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document. + */ + styleSheets: StyleSheetList; + + /** + * Retrieves a collection of all window objects defined by the given document or defined by the document associated with the given window. + */ + frames: Window; + + /** + * Occurs when the duration attribute is updated. + * @param ev The event. + */ + ondurationchange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Returns a reference to the collection of elements contained by the object. + */ + all: HTMLCollection; + + /** + * Retrieves a collection, in source order, of all form objects in the document. + */ + forms: HTMLCollection; + + /** + * Fires when the object loses the input focus. + * @param ev The focus event. + */ + onblur: (ev: FocusEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + + /** + * Sets or retrieves a value that indicates the reading order of the object. + */ + dir: string; + + /** + * Occurs when the media element is reset to its initial state. + * @param ev The event. + */ + onemptied: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Sets or gets a value that indicates whether the document can be edited. + */ + designMode: string; + + /** + * Occurs when the current playback position is moved. + * @param ev The event. + */ + onseeking: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the activeElement is changed from the current object to another object in the parent document. + * @param ev The UI Event + */ + ondeactivate: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when playback is possible, but would require further buffering. + * @param ev The event. + */ + oncanplay: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the data set exposed by a data source object changes. + * @param ev The event. + */ + ondatasetchanged: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires when rows are about to be deleted from the recordset. + * @param ev The event + */ + onrowsdelete: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + Script: MSScriptHost; + + /** + * Occurs when Internet Explorer begins looking for media data. + * @param ev The event. + */ + onloadstart: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Gets the URL for the document, stripped of any character encoding. + */ + URLUnencoded: string; + + defaultView: Window; + + /** + * Fires when the user is about to make a control selection of the object. + * @param ev The event. + */ + oncontrolselect: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires on the target element when the user drags the object to a valid drop target. + * @param ev The drag event. + */ + ondragenter: (ev: DragEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onsubmit: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Returns the character encoding used to create the webpage that is loaded into the document object. + */ + inputEncoding: string; + + /** + * Gets the object that has the focus when the parent document has focus. + */ + activeElement: Element; + + /** + * Fires when the contents of the object or selection have changed. + * @param ev The event. + */ + onchange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Retrieves a collection of all a objects that specify the href property and all area objects in the document. + */ + links: HTMLCollection; + + /** + * Retrieves an autogenerated, unique identifier for the object. + */ + uniqueID: string; + + /** + * Sets or gets the URL for the current document. + */ + URL: string; + + /** + * Fires immediately before the object is set as the active element. + * @param ev The event. + */ + onbeforeactivate: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + head: HTMLHeadElement; + cookie: string; + xmlEncoding: string; + oncanplaythrough: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Retrieves the document compatibility mode of the document. + */ + documentMode: number; + + characterSet: string; + + /** + * Retrieves a collection of all a objects that have a name and/or id property. Objects in this collection are in HTML source order. + */ + anchors: HTMLCollection; + + onbeforeupdate: (ev: MSEventObj) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires to indicate that all data is available from the data source object. + * @param ev The event. + */ + ondatasetcomplete: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + plugins: HTMLCollection; + + /** + * Occurs if the load operation has been intentionally halted. + * @param ev The event. + */ + onsuspend: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Gets the root svg element in the document hierarchy. + */ + rootElement: SVGSVGElement; + + /** + * Retrieves a value that indicates the current state of the object. + */ + readyState: string; + + /** + * Gets the URL of the location that referred the user to the current page. + */ + referrer: string; + + /** + * Sets or gets the color of all active links in the document. + */ + alinkColor: string; + + /** + * Fires on a databound object when an error occurs while updating the associated data in the data source object. + * @param ev The event. + */ + onerrorupdate: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Gets a reference to the container object of the window. + */ + parentWindow: Window; + + /** + * Fires when the user moves the mouse pointer outside the boundaries of the object. + * @param ev The mouse event. + */ + onmouseout: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when a user clicks a button in a Thumbnail Toolbar of a webpage running in Site Mode. + * @param ev The event. + */ + onmsthumbnailclick: (ev: MSSiteModeEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "msthumbnailclick", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the wheel button is rotated. + * @param ev The mouse event + */ + onmousewheel: (ev: MouseWheelEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when the volume is changed, or playback is muted or unmuted. + * @param ev The event. + */ + onvolumechange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when data changes in the data provider. + * @param ev The event. + */ + oncellchange: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires just before the data source control changes the current row in the object. + * @param ev The event. + */ + onrowexit: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires just after new rows are inserted in the current recordset. + * @param ev The event. + */ + onrowsinserted: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Gets or sets the version attribute specified in the declaration of an XML document. + */ + xmlVersion: string; + + msCapsLockWarningOff: boolean; + + /** + * Fires when a property changes on the object. + * @param ev The event. + */ + onpropertychange: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires on the source object when the user releases the mouse at the close of a drag operation. + * @param ev The event. + */ + ondragend: (ev: DragEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Gets an object representing the document type declaration associated with the current document. + */ + doctype: DocumentType; + + /** + * Fires on the target element continuously while the user drags the object over a valid drop target. + * @param ev The event. + */ + ondragover: (ev: DragEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Deprecated. Sets or retrieves a value that indicates the background color behind the object. + */ + bgColor: string; + + /** + * Fires on the source object when the user starts to drag a text selection or selected object. + * @param ev The event. + */ + ondragstart: (ev: DragEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the user releases a mouse button while the mouse is over the object. + * @param ev The mouse event. + */ + onmouseup: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Fires on the source object continuously during a drag operation. + * @param ev The event. + */ + ondrag: (ev: DragEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the user moves the mouse pointer into the object. + * @param ev The mouse event. + */ + onmouseover: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Sets or gets the color of the document links. + */ + linkColor: string; + + /** + * Occurs when playback is paused. + * @param ev The event. + */ + onpause: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the user clicks the object with either mouse button. + * @param ev The mouse event. + */ + onmousedown: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the user clicks the left mouse button on the object + * @param ev The mouse event. + */ + onclick: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when playback stops because the next frame of a video resource is not available. + * @param ev The event. + */ + onwaiting: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the user clicks the Stop button or leaves the Web page. + * @param ev The event. + */ + onstop: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false)[rolls + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "stop", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Occurs when an item is removed from a Jump List of a webpage running in Site Mode. + * @param ev The event. + */ + onmssitemodejumplistitemremoved: (ev: MSSiteModeEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mssitemodejumplistitemremoved", listener: (ev: MSSiteModeEvent) => any, useCapture?: boolean): void; + + /** + * Retrieves a collection of all applet objects in the document. + */ + applets: HTMLCollection; + + /** + * Specifies the beginning and end of the document body. + */ + body: HTMLElement; + + /** + * Sets or gets the security domain of the document. + */ + domain: string; + + xmlStandalone: boolean; + + /** + * Represents the active selection, which is a highlighted block of text or other elements in the document that a user or a script can carry out some action on. + */ + selection: MSSelection; + + /** + * Occurs when the download has stopped. + * @param ev The event. + */ + onstalled: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the user moves the mouse over the object. + * @param ev The mouse event. + */ + onmousemove: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Gets a reference to the root node of the document. + */ + documentElement: HTMLElement; + + /** + * Fires before an object contained in an editable element enters a UI-activated state or when an editable container object is control selected. + * @param ev The event. + */ + onbeforeeditfocus: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Occurs when the playback rate is increased or decreased. + * @param ev The event. + */ + onratechange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Occurs to indicate progress while downloading media data. + * @param ev The event. + */ + onprogress: (ev: any) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; + + /** + * Fires when the user double-clicks the object. + * @param ev The mouse event. + */ + ondblclick: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the user clicks the right mouse button in the client area, opening the context menu. + * @param ev The mouse event. + */ + oncontextmenu: (ev: MouseEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when the duration and dimensions of the media have been determined. + * @param ev The event. + */ + onloadedmetadata: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void; + media: string; + + /** + * Fires when an error occurs during object loading. + * @param ev The event. + */ + onerror: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Occurs when the play method is requested. + * @param ev The event. + */ + onplay: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void; + onafterupdate: (ev: MSEventObj) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Occurs when the audio or video has started playing. + * @param ev The event. + */ + onplaying: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Retrieves a collection, in source order, of img objects in the document. + */ + images: HTMLCollection; + + /** + * Contains information about the current URL. + */ + location: Location; + + /** + * Fires when the user aborts the download. + * @param ev The event. + */ + onabort: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + + /** + * Fires for the current element with focus immediately after moving focus to another element. + * @param ev The event. + */ + onfocusout: (ev: FocusEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the selection state of a document changes. + * @param ev The event. + */ + onselectionchange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "selectionchange", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when a local DOM Storage area is written to disk. + * @param ev The event. + */ + onstoragecommit: (ev: StorageEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "storagecommit", listener: (ev: StorageEvent) => any, useCapture?: boolean): void; + + /** + * Fires periodically as data arrives from data source objects that asynchronously transmit their data. + * @param ev The event. + */ + ondataavailable: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires when the state of the object has changed. + * @param ev The event + */ + onreadystatechange: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Gets the date that the page was last modified, if the page supplies one. + */ + lastModified: string; + + /** + * Fires when the user presses an alphanumeric key. + * @param ev The event. + */ + onkeypress: (ev: KeyboardEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when media data is loaded at the current playback position. + * @param ev The event. + */ + onloadeddata: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires immediately before the activeElement is changed from the current object to another object in the parent document. + * @param ev The event. + */ + onbeforedeactivate: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + + /** + * Fires when the object is set as the active element. + * @param ev The event. + */ + onactivate: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + + onselectstart: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the object receives focus. + * @param ev The event. + */ + onfocus: (ev: FocusEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + + /** + * Sets or gets the foreground (text) color of the document. + */ + fgColor: string; + + /** + * Occurs to indicate the current playback position. + * @param ev The event. + */ + ontimeupdate: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Fires when the current selection changes. + * @param ev The event. + */ + onselect: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + ondrop: (ev: DragEvent) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + + /** + * Occurs when the end of playback is reached. + * @param ev The event + */ + onended: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Gets a value that indicates whether standards-compliant mode is switched on for the object. + */ + compatMode: string; + + /** + * Fires when the user repositions the scroll box in the scroll bar on the object. + * @param ev The event. + */ + onscroll: (ev: UIEvent) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + + /** + * Fires to indicate that the current row has changed in the data source and new data values are available on the object. + * @param ev The event. + */ + onrowenter: (ev: MSEventObj) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + + /** + * Fires immediately after the browser loads the object. + * @param ev The event. + */ + onload: (ev: Event) => any; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + oninput: (ev: Event) => any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event to register + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void; + + /** + * Returns the current value of the document, range, or current selection for the given command. + * @param commandId String that specifies a command identifier. + */ + queryCommandValue(commandId: string): string; + + adoptNode(source: Node): Node; + + /** + * Returns a Boolean value that indicates whether the specified command is in the indeterminate state. + * @param commandId String that specifies a command identifier. + */ + queryCommandIndeterm(commandId: string): boolean; + + getElementsByTagNameNS(namespaceURI: string, localName: string): NodeList; + createProcessingInstruction(target: string, data: string): ProcessingInstruction; + + /** + * Executes a command on the current document, current selection, or the given range. + * @param commandId String that specifies the command to execute. This command can be any of the command identifiers that can be executed in script. + * @param showUI Display the user interface, defaults to false. + * @param value Value to assign. + */ + execCommand(commandId: string, showUI?: boolean, value?: any): boolean; + + /** + * Returns the element for the specified x coordinate and the specified y coordinate. + * @param x The x-offset + * @param y The y-offset + */ + elementFromPoint(x: number, y: number): Element; + createCDATASection(data: string): CDATASection; + + /** + * Retrieves the string associated with a command. + * @param commandId String that contains the identifier of a command. This can be any command identifier given in the list of Command Identifiers. + */ + queryCommandText(commandId: string): string; + + /** + * Writes one or more HTML expressions to a document in the specified window. + * @param content Specifies the text and HTML tags to write. + */ + write(...content: string[]): void; + + /** + * Allows updating the print settings for the page. + */ + updateSettings(): void; + + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "a"): HTMLAnchorElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "abbr"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "address"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "area"): HTMLAreaElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "article"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "aside"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "audio"): HTMLAudioElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "b"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "base"): HTMLBaseElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "bdi"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "bdo"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "blockquote"): HTMLQuoteElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "body"): HTMLBodyElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "br"): HTMLBRElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "button"): HTMLButtonElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "canvas"): HTMLCanvasElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "caption"): HTMLTableCaptionElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "cite"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "code"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "col"): HTMLTableColElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "colgroup"): HTMLTableColElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "datalist"): HTMLDataListElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "dd"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "del"): HTMLModElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "dfn"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "div"): HTMLDivElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "dl"): HTMLDListElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "dt"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "em"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "embed"): HTMLEmbedElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "fieldset"): HTMLFieldSetElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "figcaption"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "figure"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "footer"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "form"): HTMLFormElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h1"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h2"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h3"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h4"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h5"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "h6"): HTMLHeadingElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "head"): HTMLHeadElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "header"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "hgroup"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "hr"): HTMLHRElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "html"): HTMLHtmlElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "i"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "iframe"): HTMLIFrameElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "img"): HTMLImageElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "input"): HTMLInputElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "ins"): HTMLModElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "kbd"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "label"): HTMLLabelElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "legend"): HTMLLegendElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "li"): HTMLLIElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "link"): HTMLLinkElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "main"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "map"): HTMLMapElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "mark"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "menu"): HTMLMenuElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "meta"): HTMLMetaElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "nav"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "noscript"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "object"): HTMLObjectElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "ol"): HTMLOListElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "optgroup"): HTMLOptGroupElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "option"): HTMLOptionElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "p"): HTMLParagraphElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "param"): HTMLParamElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "pre"): HTMLPreElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "progress"): HTMLProgressElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "q"): HTMLQuoteElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "rp"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "rt"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "ruby"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "s"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "samp"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "script"): HTMLScriptElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "section"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "select"): HTMLSelectElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "small"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "source"): HTMLSourceElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "span"): HTMLSpanElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "strong"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "style"): HTMLStyleElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "sub"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "summary"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "sup"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "table"): HTMLTableElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "tbody"): HTMLTableSectionElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "td"): HTMLTableDataCellElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "textarea"): HTMLTextAreaElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "tfoot"): HTMLTableSectionElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "th"): HTMLTableHeaderCellElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "thead"): HTMLTableSectionElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "title"): HTMLTitleElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "tr"): HTMLTableRowElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "track"): HTMLTrackElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "u"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "ul"): HTMLUListElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "var"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "video"): HTMLVideoElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: "wbr"): HTMLElement; + /** + * Creates an instance of the element for the specified tag. + * @param tagName The name of an element. + */ + createElement(tagName: string): HTMLElement; + + /** + * Removes mouse capture from the object in the current document. + */ + releaseCapture(): void; + + /** + * Writes one or more HTML expressions, followed by a carriage return, to a document in the specified window. + * @param content The text and HTML tags to write. + */ + writeln(...content: string[]): void; + createElementNS(namespaceURI: string, qualifiedName: string): Element; + + /** + * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method. + * @param url Specifies a MIME type for the document. + * @param name Specifies the name of the window. This name is used as the value for the TARGET attribute on a form or an anchor element. + * @param features Contains a list of items separated by commas. Each item consists of an option and a value, separated by an equals sign (for example, "fullscreen=yes, toolbar=yes"). The following values are supported. + * @param replace Specifies whether the existing entry for the document is replaced in the history list. + */ + open(url?: string, name?: string, features?: string, replace?: boolean): any; + + /** + * Returns a Boolean value that indicates whether the current command is supported on the current range. + * @param commandId Specifies a command identifier. + */ + queryCommandSupported(commandId: string): boolean; + + /** + * Creates a TreeWalker object that you can use to traverse filtered lists of nodes or elements in a document. + * @param root The root element or node to start traversing on. + * @param whatToShow The type of nodes or elements to appear in the node list. For more information, see whatToShow. + * @param filter A custom NodeFilter function to use. + * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded. + */ + createTreeWalker(root: Node, whatToShow: number, filter: NodeFilter, entityReferenceExpansion: boolean): TreeWalker; + createAttributeNS(namespaceURI: string, qualifiedName: string): Attr; + + /** + * Returns a Boolean value that indicates whether a specified command can be successfully executed using execCommand, given the current state of the document. + * @param commandId Specifies a command identifier. + */ + queryCommandEnabled(commandId: string): boolean; + + /** + * Causes the element to receive the focus and executes the code specified by the onfocus event. + */ + focus(): void; + + /** + * Closes an output stream and forces the sent data to display. + */ + close(): void; + + getElementsByClassName(classNames: string): NodeList; + importNode(importedNode: Node, deep: boolean): Node; + + /** + * Returns an empty range object that has both of its boundary points positioned at the beginning of the document. + */ + createRange(): Range; + + /** + * Fires a specified event on the object. + * @param eventName Specifies the name of the event to fire. + * @param eventObj Object that specifies the event object from which to obtain event object properties. + */ + fireEvent(eventName: string, eventObj?: any): boolean; + + /** + * Creates a comment object with the specified data. + * @param data Sets the comment object's data. + */ + createComment(data: string): Comment; + + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "a"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "abbr"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "address"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "area"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "article"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "aside"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "audio"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "b"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "base"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "bdi"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "bdo"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "blockquote"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "body"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "br"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "button"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "canvas"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "caption"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "cite"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "code"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "col"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "colgroup"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "datalist"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "dd"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "del"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "dfn"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "div"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "dl"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "dt"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "em"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "embed"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "fieldset"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "figcaption"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "figure"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "footer"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "form"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h1"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h2"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h3"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h4"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h5"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "h6"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "head"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "header"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "hgroup"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "hr"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "html"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "i"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "iframe"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "img"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "input"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "ins"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "kbd"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "label"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "legend"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "li"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "link"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "main"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "map"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "mark"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "menu"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "meta"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "nav"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "noscript"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "object"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "ol"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "optgroup"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "option"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "p"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "param"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "pre"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "progress"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "q"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "rp"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "rt"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "ruby"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "s"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "samp"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "script"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "section"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "select"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "small"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "source"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "span"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "strong"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "style"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "sub"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "summary"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "sup"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "table"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "tbody"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "td"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "textarea"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "tfoot"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "th"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "thead"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "title"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "tr"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "track"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "u"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "ul"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "var"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "video"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: "wbr"): NodeListOf; + /** + * Retrieves a collection of objects based on the specified element name. + * @param name Specifies the name of an element. + */ + getElementsByTagName(name: string): NodeList; + + /** + * Creates a new document. + */ + createDocumentFragment(): DocumentFragment; + + /** + * Creates a style sheet for the document. + * @param href Specifies how to add the style sheet to the document. If a file name is specified for the URL, the style information is added as a link object. If the URL contains style information, it is added to the style object. + * @param index Specifies the index that indicates where the new style sheet is inserted in the styleSheets collection. The default is to insert the new style sheet at the end of the collection. + */ + createStyleSheet(href?: string, index?: number): CSSStyleSheet; + + /** + * Gets a collection of objects based on the value of the NAME or ID attribute. + * @param elementName Gets a collection of objects based on the value of the NAME or ID attribute. + */ + getElementsByName(elementName: string): NodeList; + + /** + * Returns a Boolean value that indicates the current state of the command. + * @param commandId String that specifies a command identifier. + */ + queryCommandState(commandId: string): boolean; + + /** + * Gets a value indicating whether the object currently has focus. + */ + hasFocus(): boolean; + + /** + * Displays help information for the given command identifier. + * @param commandId Displays help information for the given command identifier. + */ + execCommandShowHelp(commandId: string): boolean; + + /** + * Creates an attribute object with a specified name. + * @param name String that sets the attribute object's name. + */ + createAttribute(name: string): Attr; + + /** + * Creates a text string from the specified value. + * @param data String that specifies the nodeValue property of the text node. + */ + createTextNode(data: string): Text; + + /** + * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document. + * @param root The root element or node to start traversing on. + * @param whatToShow The type of nodes or elements to appear in the node list + * @param filter A custom NodeFilter function to use. For more information, see filter. Use null for no filter. + * @param entityReferenceExpansion A flag that specifies whether entity reference nodes are expanded. + */ + createNodeIterator(root: Node, whatToShow: number, filter: NodeFilter, entityReferenceExpansion: boolean): NodeIterator; + + /** + * Generates an event object to pass event context information when you use the fireEvent method. + * @param eventObj An object that specifies an existing event object on which to base the new object. + */ + createEventObject(eventObj?: any): MSEventObj; + + /** + * Returns an object representing the current selection of the document that is loaded into the object displaying a webpage. + */ + getSelection(): Selection; + + /** + * Returns a reference to the first object with the specified value of the ID or NAME attribute. + * @param elementId String that specifies the ID value. Case-insensitive. + */ + getElementById(elementId: string): HTMLElement; + + /** + * Registers an event handler for the specified event type. + * @param type The type of event type to register. + * @param listener The event handler function to associate with the event. + * @param useCapture Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: "DOMContentLoaded", listener: (ev: Event) => any, useCapture?: boolean): void; + /** + * Registers an event handler for the specified event type. + * @param type The type of event type to register. + * @param listener The event handler function to associate with the event. + * @param useCapture Boolean value that specifies the event phase to add the event handler for: + * true (true) + * Register the event handler for the capturing phase. + * false (false) + * Register the event handler for the bubbling phase. + */ + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +declare var Document: { + prototype: Document; + new (): Document; +} + +interface MessageEvent extends Event { + source: Window; + origin: string; + data: any; + initMessageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, dataArg: any, originArg: string, lastEventIdArg: string, sourceArg: Window): void; +} +declare var MessageEvent: { + prototype: MessageEvent; + new (): MessageEvent; +} + +interface SVGElement extends Element { + onmouseover: (ev: MouseEvent) => any; + addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + viewportElement: SVGElement; + onmousemove: (ev: MouseEvent) => any; + addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onmouseout: (ev: MouseEvent) => any; + addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + ondblclick: (ev: MouseEvent) => any; + addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onfocusout: (ev: FocusEvent) => any; + addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onfocusin: (ev: FocusEvent) => any; + addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + xmlbase: string; + onmousedown: (ev: MouseEvent) => any; + addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + onmouseup: (ev: MouseEvent) => any; + addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onclick: (ev: MouseEvent) => any; + addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + ownerSVGElement: SVGSVGElement; + id: string; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var SVGElement: { + prototype: SVGElement; + new (): SVGElement; +} + +interface HTMLScriptElement extends HTMLElement { + /** + * Sets or retrieves the status of the script. + */ + defer: boolean; + /** + * Retrieves or sets the text of the object as a string. + */ + text: string; + /** + * Retrieves the URL to an external file that contains the source code or data. + */ + src: string; + /** + * Sets or retrieves the object that is bound to the event script. + */ + htmlFor: string; + /** + * Sets or retrieves the character set used to encode the object. + */ + charset: string; + /** + * Sets or retrieves the MIME type for the associated scripting engine. + */ + type: string; + /** + * Sets or retrieves the event for which the script is written. + */ + event: string; +} +declare var HTMLScriptElement: { + prototype: HTMLScriptElement; + new (): HTMLScriptElement; +} + +interface HTMLTableRowElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundColorStyle { + /** + * Retrieves the position of the object in the rows collection for the table. + */ + rowIndex: number; + /** + * Retrieves a collection of all cells in the table row. + */ + cells: HTMLCollection; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorLight: any; + /** + * Retrieves the position of the object in the collection. + */ + sectionRowIndex: number; + /** + * Sets or retrieves the border color of the object. + */ + borderColor: any; + /** + * Sets or retrieves the height of the object. + */ + height: any; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorDark: any; + /** + * Removes the specified cell from the table row, as well as from the cells collection. + * @param index Number that specifies the zero-based position of the cell to remove from the table row. If no value is provided, the last cell in the cells collection is deleted. + */ + deleteCell(index?: number): void; + /** + * Creates a new cell in the table row, and adds the cell to the cells collection. + * @param index Number that specifies where to insert the cell in the tr. The default value is -1, which appends the new cell to the end of the cells collection. + */ + insertCell(index?: number): HTMLElement; +} +declare var HTMLTableRowElement: { + prototype: HTMLTableRowElement; + new (): HTMLTableRowElement; +} + +interface CanvasRenderingContext2D { + miterLimit: number; + font: string; + globalCompositeOperation: string; + msFillRule: string; + lineCap: string; + msImageSmoothingEnabled: boolean; + lineDashOffset: number; + shadowColor: string; + lineJoin: string; + shadowOffsetX: number; + lineWidth: number; + canvas: HTMLCanvasElement; + strokeStyle: any; + globalAlpha: number; + shadowOffsetY: number; + fillStyle: any; + shadowBlur: number; + textAlign: string; + textBaseline: string; + restore(): void; + setTransform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void; + save(): void; + arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void; + measureText(text: string): TextMetrics; + isPointInPath(x: number, y: number, fillRule?: string): boolean; + quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void; + putImageData(imagedata: ImageData, dx: number, dy: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void; + rotate(angle: number): void; + fillText(text: string, x: number, y: number, maxWidth?: number): void; + translate(x: number, y: number): void; + scale(x: number, y: number): void; + createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient; + lineTo(x: number, y: number): void; + getLineDash(): Array; + fill(fillRule?: string): void; + createImageData(imageDataOrSw: any, sh?: number): ImageData; + createPattern(image: HTMLElement, repetition: string): CanvasPattern; + closePath(): void; + rect(x: number, y: number, w: number, h: number): void; + clip(fillRule?: string): void; + clearRect(x: number, y: number, w: number, h: number): void; + moveTo(x: number, y: number): void; + getImageData(sx: number, sy: number, sw: number, sh: number): ImageData; + fillRect(x: number, y: number, w: number, h: number): void; + bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void; + drawImage(image: HTMLElement, offsetX: number, offsetY: number, width?: number, height?: number, canvasOffsetX?: number, canvasOffsetY?: number, canvasImageWidth?: number, canvasImageHeight?: number): void; + transform(m11: number, m12: number, m21: number, m22: number, dx: number, dy: number): void; + stroke(): void; + strokeRect(x: number, y: number, w: number, h: number): void; + setLineDash(segments: Array): void; + strokeText(text: string, x: number, y: number, maxWidth?: number): void; + beginPath(): void; + arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void; + createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient; +} +declare var CanvasRenderingContext2D: { + prototype: CanvasRenderingContext2D; + new (): CanvasRenderingContext2D; +} + +interface MSCSSRuleList { + length: number; + item(index?: number): CSSStyleRule; + [index: number]: CSSStyleRule; +} +declare var MSCSSRuleList: { + prototype: MSCSSRuleList; + new (): MSCSSRuleList; +} + +interface SVGPathSegLinetoHorizontalAbs extends SVGPathSeg { + x: number; +} +declare var SVGPathSegLinetoHorizontalAbs: { + prototype: SVGPathSegLinetoHorizontalAbs; + new (): SVGPathSegLinetoHorizontalAbs; +} + +interface SVGPathSegArcAbs extends SVGPathSeg { + y: number; + sweepFlag: boolean; + r2: number; + x: number; + angle: number; + r1: number; + largeArcFlag: boolean; +} +declare var SVGPathSegArcAbs: { + prototype: SVGPathSegArcAbs; + new (): SVGPathSegArcAbs; +} + +interface SVGTransformList { + numberOfItems: number; + getItem(index: number): SVGTransform; + consolidate(): SVGTransform; + clear(): void; + appendItem(newItem: SVGTransform): SVGTransform; + initialize(newItem: SVGTransform): SVGTransform; + removeItem(index: number): SVGTransform; + insertItemBefore(newItem: SVGTransform, index: number): SVGTransform; + replaceItem(newItem: SVGTransform, index: number): SVGTransform; + createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform; +} +declare var SVGTransformList: { + prototype: SVGTransformList; + new (): SVGTransformList; +} + +interface HTMLHtmlElement extends HTMLElement { + /** + * Sets or retrieves the DTD version that governs the current document. + */ + version: string; +} +declare var HTMLHtmlElement: { + prototype: HTMLHtmlElement; + new (): HTMLHtmlElement; +} + +interface SVGPathSegClosePath extends SVGPathSeg { +} +declare var SVGPathSegClosePath: { + prototype: SVGPathSegClosePath; + new (): SVGPathSegClosePath; +} + +interface HTMLFrameElement extends HTMLElement, GetSVGDocument, MSDataBindingExtensions { + /** + * Sets or retrieves the width of the object. + */ + width: any; + /** + * Sets or retrieves whether the frame can be scrolled. + */ + scrolling: string; + /** + * Sets or retrieves the top and bottom margin heights before displaying the text in a frame. + */ + marginHeight: string; + /** + * Sets or retrieves the left and right margin widths before displaying the text in a frame. + */ + marginWidth: string; + /** + * Sets or retrieves the border color of the object. + */ + borderColor: any; + /** + * Sets or retrieves the amount of additional space between the frames. + */ + frameSpacing: any; + /** + * Sets or retrieves whether to display a border for the frame. + */ + frameBorder: string; + /** + * Sets or retrieves whether the user can resize the frame. + */ + noResize: boolean; + /** + * Retrieves the object of the specified. + */ + contentWindow: Window; + /** + * Sets or retrieves a URL to be loaded by the object. + */ + src: string; + /** + * Sets or retrieves the frame name. + */ + name: string; + /** + * Sets or retrieves the height of the object. + */ + height: any; + /** + * Retrieves the document object of the page or frame. + */ + contentDocument: Document; + /** + * Specifies the properties of a border drawn around an object. + */ + border: string; + /** + * Sets or retrieves a URI to a long description of the object. + */ + longDesc: string; + /** + * Raised when the object has been completely received from the server. + */ + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + /** + * Sets the value indicating whether the source file of a frame or iframe has specific security restrictions applied. + */ + security: any; + /** + * Registers an event handler for the specified event type. + * @param type The type of event type to register. + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for. If true, register the event handler for the capturing phase. If false, Register the event handler for the bubbling phase. + */ + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLFrameElement: { + prototype: HTMLFrameElement; + new (): HTMLFrameElement; +} + +interface SVGAnimatedLength { + animVal: SVGLength; + baseVal: SVGLength; +} +declare var SVGAnimatedLength: { + prototype: SVGAnimatedLength; + new (): SVGAnimatedLength; +} + +interface SVGAnimatedPoints { + points: SVGPointList; + animatedPoints: SVGPointList; +} + +interface SVGDefsElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { +} +declare var SVGDefsElement: { + prototype: SVGDefsElement; + new (): SVGDefsElement; +} + +interface HTMLQuoteElement extends HTMLElement { + /** + * Sets or retrieves the date and time of a modification to the object. + */ + dateTime: string; + /** + * Sets or retrieves reference information about the object. + */ + cite: string; +} +declare var HTMLQuoteElement: { + prototype: HTMLQuoteElement; + new (): HTMLQuoteElement; +} + +interface CSSMediaRule extends CSSRule { + media: MediaList; + cssRules: CSSRuleList; + insertRule(rule: string, index?: number): number; + deleteRule(index?: number): void; +} +declare var CSSMediaRule: { + prototype: CSSMediaRule; + new (): CSSMediaRule; +} + +interface WindowModal { + dialogArguments: any; + returnValue: any; +} + +interface XMLHttpRequest extends EventTarget { + responseBody: any; + status: number; + readyState: number; + responseText: string; + responseXML: Document; + ontimeout: (ev: Event) => any; + addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void; + statusText: string; + onreadystatechange: (ev: Event) => any; + addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; + timeout: number; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + open(method: string, url: string, async?: boolean, user?: string, password?: string): void; + create(): XMLHttpRequest; + send(data?: any): void; + abort(): void; + getAllResponseHeaders(): string; + setRequestHeader(header: string, value: string): void; + getResponseHeader(header: string): string; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + LOADING: number; + DONE: number; + UNSENT: number; + OPENED: number; + HEADERS_RECEIVED: number; +} +declare var XMLHttpRequest: { + prototype: XMLHttpRequest; + new (): XMLHttpRequest; + LOADING: number; + DONE: number; + UNSENT: number; + OPENED: number; + HEADERS_RECEIVED: number; +} + +interface HTMLTableHeaderCellElement extends HTMLTableCellElement { + /** + * Sets or retrieves the group of cells in a table to which the object's information applies. + */ + scope: string; +} +declare var HTMLTableHeaderCellElement: { + prototype: HTMLTableHeaderCellElement; + new (): HTMLTableHeaderCellElement; +} + +interface HTMLDListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction { +} +declare var HTMLDListElement: { + prototype: HTMLDListElement; + new (): HTMLDListElement; +} + +interface MSDataBindingExtensions { + dataSrc: string; + dataFormatAs: string; + dataFld: string; +} + +interface SVGPathSegLinetoHorizontalRel extends SVGPathSeg { + x: number; +} +declare var SVGPathSegLinetoHorizontalRel: { + prototype: SVGPathSegLinetoHorizontalRel; + new (): SVGPathSegLinetoHorizontalRel; +} + +interface SVGEllipseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + ry: SVGAnimatedLength; + cx: SVGAnimatedLength; + rx: SVGAnimatedLength; + cy: SVGAnimatedLength; +} +declare var SVGEllipseElement: { + prototype: SVGEllipseElement; + new (): SVGEllipseElement; +} + +interface SVGAElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference { + target: SVGAnimatedString; +} +declare var SVGAElement: { + prototype: SVGAElement; + new (): SVGAElement; +} + +interface SVGStylable { + className: SVGAnimatedString; + style: CSSStyleDeclaration; +} + +interface SVGTransformable extends SVGLocatable { + transform: SVGAnimatedTransformList; +} + +interface HTMLFrameSetElement extends HTMLElement { + ononline: (ev: Event) => any; + addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void; + /** + * Sets or retrieves the border color of the object. + */ + borderColor: any; + /** + * Sets or retrieves the frame heights of the object. + */ + rows: string; + /** + * Sets or retrieves the frame widths of the object. + */ + cols: string; + /** + * Fires when the object loses the input focus. + */ + onblur: (ev: FocusEvent) => any; + addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + /** + * Sets or retrieves the amount of additional space between the frames. + */ + frameSpacing: any; + /** + * Fires when the object receives focus. + */ + onfocus: (ev: FocusEvent) => any; + addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onmessage: (ev: MessageEvent) => any; + addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void; + onerror: (ev: Event) => any; + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + /** + * Sets or retrieves whether to display a border for the frame. + */ + frameBorder: string; + onresize: (ev: UIEvent) => any; + addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + name: string; + onafterprint: (ev: Event) => any; + addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void; + onbeforeprint: (ev: Event) => any; + addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void; + onoffline: (ev: Event) => any; + addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void; + border: string; + onunload: (ev: Event) => any; + addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void; + onhashchange: (ev: Event) => any; + addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + onbeforeunload: (ev: BeforeUnloadEvent) => any; + addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void; + onstorage: (ev: StorageEvent) => any; + addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLFrameSetElement: { + prototype: HTMLFrameSetElement; + new (): HTMLFrameSetElement; +} + +interface Screen { + width: number; + deviceXDPI: number; + fontSmoothingEnabled: boolean; + bufferDepth: number; + logicalXDPI: number; + systemXDPI: number; + availHeight: number; + height: number; + logicalYDPI: number; + systemYDPI: number; + updateInterval: number; + colorDepth: number; + availWidth: number; + deviceYDPI: number; + pixelDepth: number; +} +declare var Screen: { + prototype: Screen; + new (): Screen; +} + +interface Coordinates { + altitudeAccuracy: number; + longitude: number; + latitude: number; + speed: number; + heading: number; + altitude: number; + accuracy: number; +} +declare var Coordinates: { + prototype: Coordinates; + new (): Coordinates; +} + +interface NavigatorGeolocation { + geolocation: Geolocation; +} + +interface NavigatorContentUtils { +} + +interface EventListener { + (evt: Event): void; +} + +interface SVGLangSpace { + xmllang: string; + xmlspace: string; +} + +interface DataTransfer { + effectAllowed: string; + dropEffect: string; + clearData(format?: string): boolean; + setData(format: string, data: string): boolean; + getData(format: string): string; +} +declare var DataTransfer: { + prototype: DataTransfer; + new (): DataTransfer; +} + +interface FocusEvent extends UIEvent { + relatedTarget: EventTarget; + initFocusEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, relatedTargetArg: EventTarget): void; +} +declare var FocusEvent: { + prototype: FocusEvent; + new (): FocusEvent; +} + +interface Range { + startOffset: number; + collapsed: boolean; + endOffset: number; + startContainer: Node; + endContainer: Node; + commonAncestorContainer: Node; + setStart(refNode: Node, offset: number): void; + setEndBefore(refNode: Node): void; + setStartBefore(refNode: Node): void; + selectNode(refNode: Node): void; + detach(): void; + getBoundingClientRect(): ClientRect; + toString(): string; + compareBoundaryPoints(how: number, sourceRange: Range): number; + insertNode(newNode: Node): void; + collapse(toStart: boolean): void; + selectNodeContents(refNode: Node): void; + cloneContents(): DocumentFragment; + setEnd(refNode: Node, offset: number): void; + cloneRange(): Range; + getClientRects(): ClientRectList; + surroundContents(newParent: Node): void; + deleteContents(): void; + setStartAfter(refNode: Node): void; + extractContents(): DocumentFragment; + setEndAfter(refNode: Node): void; + END_TO_END: number; + START_TO_START: number; + START_TO_END: number; + END_TO_START: number; +} +declare var Range: { + prototype: Range; + new (): Range; + END_TO_END: number; + START_TO_START: number; + START_TO_END: number; + END_TO_START: number; +} + +interface SVGPoint { + y: number; + x: number; + matrixTransform(matrix: SVGMatrix): SVGPoint; +} +declare var SVGPoint: { + prototype: SVGPoint; + new (): SVGPoint; +} + +interface MSPluginsCollection { + length: number; + refresh(reload?: boolean): void; +} +declare var MSPluginsCollection: { + prototype: MSPluginsCollection; + new (): MSPluginsCollection; +} + +interface SVGAnimatedNumberList { + animVal: SVGNumberList; + baseVal: SVGNumberList; +} +declare var SVGAnimatedNumberList: { + prototype: SVGAnimatedNumberList; + new (): SVGAnimatedNumberList; +} + +interface SVGSVGElement extends SVGElement, SVGStylable, SVGZoomAndPan, DocumentEvent, SVGLangSpace, SVGLocatable, SVGTests, SVGFitToViewBox, SVGExternalResourcesRequired { + width: SVGAnimatedLength; + x: SVGAnimatedLength; + contentStyleType: string; + onzoom: (ev: any) => any; + addEventListener(type: "zoom", listener: (ev: any) => any, useCapture?: boolean): void; + y: SVGAnimatedLength; + viewport: SVGRect; + onerror: (ev: Event) => any; + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + pixelUnitToMillimeterY: number; + onresize: (ev: UIEvent) => any; + addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + screenPixelToMillimeterY: number; + height: SVGAnimatedLength; + onabort: (ev: UIEvent) => any; + addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + contentScriptType: string; + pixelUnitToMillimeterX: number; + currentTranslate: SVGPoint; + onunload: (ev: Event) => any; + addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void; + currentScale: number; + onscroll: (ev: UIEvent) => any; + addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + screenPixelToMillimeterX: number; + setCurrentTime(seconds: number): void; + createSVGLength(): SVGLength; + getIntersectionList(rect: SVGRect, referenceElement: SVGElement): NodeList; + unpauseAnimations(): void; + createSVGRect(): SVGRect; + checkIntersection(element: SVGElement, rect: SVGRect): boolean; + unsuspendRedrawAll(): void; + pauseAnimations(): void; + suspendRedraw(maxWaitMilliseconds: number): number; + deselectAll(): void; + createSVGAngle(): SVGAngle; + getEnclosureList(rect: SVGRect, referenceElement: SVGElement): NodeList; + createSVGTransform(): SVGTransform; + unsuspendRedraw(suspendHandleID: number): void; + forceRedraw(): void; + getCurrentTime(): number; + checkEnclosure(element: SVGElement, rect: SVGRect): boolean; + createSVGMatrix(): SVGMatrix; + createSVGPoint(): SVGPoint; + createSVGNumber(): SVGNumber; + createSVGTransformFromMatrix(matrix: SVGMatrix): SVGTransform; + getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration; + getElementById(elementId: string): Element; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var SVGSVGElement: { + prototype: SVGSVGElement; + new (): SVGSVGElement; +} + +interface HTMLLabelElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the object to which the given label object is assigned. + */ + htmlFor: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; +} +declare var HTMLLabelElement: { + prototype: HTMLLabelElement; + new (): HTMLLabelElement; +} + +interface MSResourceMetadata { + protocol: string; + fileSize: string; + fileUpdatedDate: string; + nameProp: string; + fileCreatedDate: string; + fileModifiedDate: string; + mimeType: string; +} + +interface HTMLLegendElement extends HTMLElement, MSDataBindingExtensions { + /** + * Retrieves a reference to the form that the object is embedded in. + */ + align: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; +} +declare var HTMLLegendElement: { + prototype: HTMLLegendElement; + new (): HTMLLegendElement; +} + +interface HTMLDirectoryElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle { +} +declare var HTMLDirectoryElement: { + prototype: HTMLDirectoryElement; + new (): HTMLDirectoryElement; +} + +interface SVGAnimatedInteger { + animVal: number; + baseVal: number; +} +declare var SVGAnimatedInteger: { + prototype: SVGAnimatedInteger; + new (): SVGAnimatedInteger; +} + +interface SVGTextElement extends SVGTextPositioningElement, SVGTransformable { +} +declare var SVGTextElement: { + prototype: SVGTextElement; + new (): SVGTextElement; +} + +interface SVGTSpanElement extends SVGTextPositioningElement { +} +declare var SVGTSpanElement: { + prototype: SVGTSpanElement; + new (): SVGTSpanElement; +} + +interface HTMLLIElement extends HTMLElement, DOML2DeprecatedListNumberingAndBulletStyle { + /** + * Sets or retrieves the value of a list item. + */ + value: number; +} +declare var HTMLLIElement: { + prototype: HTMLLIElement; + new (): HTMLLIElement; +} + +interface SVGPathSegLinetoVerticalAbs extends SVGPathSeg { + y: number; +} +declare var SVGPathSegLinetoVerticalAbs: { + prototype: SVGPathSegLinetoVerticalAbs; + new (): SVGPathSegLinetoVerticalAbs; +} + +interface MSStorageExtensions { + remainingSpace: number; +} + +interface SVGStyleElement extends SVGElement, SVGLangSpace { + media: string; + type: string; + title: string; +} +declare var SVGStyleElement: { + prototype: SVGStyleElement; + new (): SVGStyleElement; +} + +interface MSCurrentStyleCSSProperties extends MSCSSProperties { + blockDirection: string; + clipBottom: string; + clipLeft: string; + clipRight: string; + clipTop: string; + hasLayout: string; +} +declare var MSCurrentStyleCSSProperties: { + prototype: MSCurrentStyleCSSProperties; + new (): MSCurrentStyleCSSProperties; +} + +interface MSHTMLCollectionExtensions { + urns(urn: any): Object; + tags(tagName: any): Object; +} + +interface Storage extends MSStorageExtensions { + length: number; + getItem(key: string): any; + [key: string]: any; + setItem(key: string, data: string): void; + clear(): void; + removeItem(key: string): void; + key(index: number): string; + [index: number]: any; +} +declare var Storage: { + prototype: Storage; + new (): Storage; +} + +interface HTMLIFrameElement extends HTMLElement, GetSVGDocument, MSDataBindingExtensions { + /** + * Sets or retrieves the width of the object. + */ + width: string; + /** + * Sets or retrieves whether the frame can be scrolled. + */ + scrolling: string; + /** + * Sets or retrieves the top and bottom margin heights before displaying the text in a frame. + */ + marginHeight: string; + /** + * Sets or retrieves the left and right margin widths before displaying the text in a frame. + */ + marginWidth: string; + /** + * Sets or retrieves the amount of additional space between the frames. + */ + frameSpacing: any; + /** + * Sets or retrieves whether to display a border for the frame. + */ + frameBorder: string; + /** + * Sets or retrieves whether the user can resize the frame. + */ + noResize: boolean; + /** + * Sets or retrieves the vertical margin for the object. + */ + vspace: number; + /** + * Retrieves the object of the specified. + */ + contentWindow: Window; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Sets or retrieves a URL to be loaded by the object. + */ + src: string; + /** + * Sets or retrieves the frame name. + */ + name: string; + /** + * Sets or retrieves the height of the object. + */ + height: string; + /** + * Specifies the properties of a border drawn around an object. + */ + border: string; + /** + * Retrieves the document object of the page or frame. + */ + contentDocument: Document; + /** + * Sets or retrieves the horizontal margin for the object. + */ + hspace: number; + /** + * Sets or retrieves a URI to a long description of the object. + */ + longDesc: string; + /** + * Sets the value indicating whether the source file of a frame or iframe has specific security restrictions applied. + */ + security: any; + /** + * Raised when the object has been completely received from the server. + */ + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + /** + * Registers an event handler for the specified event type. + * @param type The type of event type to register. + * @param listener The event handler function to associate with the event. + * @param useCapture A Boolean value that specifies the event phase to add the event handler for. If true, register the event handler for the capturing phase. If false, Register the event handler for the bubbling phase. + */ + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLIFrameElement: { + prototype: HTMLIFrameElement; + new (): HTMLIFrameElement; +} + +interface TextRangeCollection { + length: number; + item(index: number): TextRange; + [index: number]: TextRange; +} +declare var TextRangeCollection: { + prototype: TextRangeCollection; + new (): TextRangeCollection; +} + +interface HTMLBodyElement extends HTMLElement, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle { + scroll: string; + ononline: (ev: Event) => any; + addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void; + onblur: (ev: FocusEvent) => any; + addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + noWrap: boolean; + onfocus: (ev: FocusEvent) => any; + addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onmessage: (ev: MessageEvent) => any; + addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void; + text: any; + onerror: (ev: Event) => any; + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + bgProperties: string; + onresize: (ev: UIEvent) => any; + addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + link: any; + aLink: any; + bottomMargin: any; + topMargin: any; + onafterprint: (ev: Event) => any; + addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void; + vLink: any; + onbeforeprint: (ev: Event) => any; + addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void; + onoffline: (ev: Event) => any; + addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void; + onunload: (ev: Event) => any; + addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void; + onhashchange: (ev: Event) => any; + addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + rightMargin: any; + onbeforeunload: (ev: BeforeUnloadEvent) => any; + addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void; + leftMargin: any; + onstorage: (ev: StorageEvent) => any; + addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void; + createTextRange(): TextRange; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLBodyElement: { + prototype: HTMLBodyElement; + new (): HTMLBodyElement; +} + +interface DocumentType extends Node { + name: string; + notations: NamedNodeMap; + systemId: string; + internalSubset: string; + entities: NamedNodeMap; + publicId: string; +} +declare var DocumentType: { + prototype: DocumentType; + new (): DocumentType; +} + +interface SVGRadialGradientElement extends SVGGradientElement { + cx: SVGAnimatedLength; + r: SVGAnimatedLength; + cy: SVGAnimatedLength; + fx: SVGAnimatedLength; + fy: SVGAnimatedLength; +} +declare var SVGRadialGradientElement: { + prototype: SVGRadialGradientElement; + new (): SVGRadialGradientElement; +} + +interface MutationEvent extends Event { + newValue: string; + attrChange: number; + attrName: string; + prevValue: string; + relatedNode: Node; + initMutationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, relatedNodeArg: Node, prevValueArg: string, newValueArg: string, attrNameArg: string, attrChangeArg: number): void; + MODIFICATION: number; + REMOVAL: number; + ADDITION: number; +} +declare var MutationEvent: { + prototype: MutationEvent; + new (): MutationEvent; + MODIFICATION: number; + REMOVAL: number; + ADDITION: number; +} + +interface DragEvent extends MouseEvent { + dataTransfer: DataTransfer; + initDragEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, dataTransferArg: DataTransfer): void; +} +declare var DragEvent: { + prototype: DragEvent; + new (): DragEvent; +} + +interface HTMLTableSectionElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundColorStyle { + /** + * Sets or retrieves a value that indicates the table alignment. + */ + align: string; + /** + * Sets or retrieves the number of horizontal rows contained in the object. + */ + rows: HTMLCollection; + /** + * Removes the specified row (tr) from the element and from the rows collection. + * @param index Number that specifies the zero-based position in the rows collection of the row to remove. + */ + deleteRow(index?: number): void; + /** + * Moves a table row to a new position. + * @param indexFrom Number that specifies the index in the rows collection of the table row that is moved. + * @param indexTo Number that specifies where the row is moved within the rows collection. + */ + moveRow(indexFrom?: number, indexTo?: number): Object; + /** + * Creates a new row (tr) in the table, and adds the row to the rows collection. + * @param index Number that specifies where to insert the row in the rows collection. The default value is -1, which appends the new row to the end of the rows collection. + */ + insertRow(index?: number): HTMLElement; +} +declare var HTMLTableSectionElement: { + prototype: HTMLTableSectionElement; + new (): HTMLTableSectionElement; +} + +interface DOML2DeprecatedListNumberingAndBulletStyle { + type: string; +} + +interface HTMLInputElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the width of the object. + */ + width: string; + status: boolean; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Gets or sets the starting position or offset of a text selection. + */ + selectionStart: number; + indeterminate: boolean; + readOnly: boolean; + size: number; + loop: number; + /** + * Gets or sets the end position or offset of a text selection. + */ + selectionEnd: number; + /** + * Sets or retrieves the URL of the virtual reality modeling language (VRML) world to be displayed in the window. + */ + vrml: string; + /** + * Sets or retrieves a lower resolution image to display. + */ + lowsrc: string; + /** + * Sets or retrieves the vertical margin for the object. + */ + vspace: number; + /** + * Sets or retrieves a comma-separated list of content types. + */ + accept: string; + /** + * Sets or retrieves a text alternative to the graphic. + */ + alt: string; + /** + * Sets or retrieves the state of the check box or radio button. + */ + defaultChecked: boolean; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Returns the value of the data at the cursor's current position. + */ + value: string; + /** + * The address or URL of the a media resource that is to be considered. + */ + src: string; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. + */ + useMap: string; + /** + * Sets or retrieves the height of the object. + */ + height: string; + /** + * Sets or retrieves the width of the border to draw around the object. + */ + border: string; + dynsrc: string; + /** + * Sets or retrieves the state of the check box or radio button. + */ + checked: boolean; + /** + * Sets or retrieves the width of the border to draw around the object. + */ + hspace: number; + /** + * Sets or retrieves the maximum number of characters that the user can enter in a text control. + */ + maxLength: number; + /** + * Returns the content type of the object. + */ + type: string; + /** + * Sets or retrieves the initial contents of the object. + */ + defaultValue: string; + /** + * Retrieves whether the object is fully loaded. + */ + complete: boolean; + start: string; + /** + * Creates a TextRange object for the element. + */ + createTextRange(): TextRange; + /** + * Sets the start and end positions of a selection in a text field. + * @param start The offset into the text field for the start of the selection. + * @param end The offset into the text field for the end of the selection. + */ + setSelectionRange(start: number, end: number): void; + /** + * Makes the selection equal to the current object. + */ + select(): void; +} +declare var HTMLInputElement: { + prototype: HTMLInputElement; + new (): HTMLInputElement; +} + +interface HTMLAnchorElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the relationship between the object and the destination of the link. + */ + rel: string; + /** + * Contains the protocol of the URL. + */ + protocol: string; + /** + * Sets or retrieves the substring of the href property that follows the question mark. + */ + search: string; + /** + * Sets or retrieves the coordinates of the object. + */ + coords: string; + /** + * Contains the hostname of a URL. + */ + hostname: string; + /** + * Contains the pathname of the URL. + */ + pathname: string; + Methods: string; + /** + * Sets or retrieves the window or frame at which to target content. + */ + target: string; + protocolLong: string; + /** + * Sets or retrieves a destination URL or an anchor point. + */ + href: string; + /** + * Sets or retrieves the shape of the object. + */ + name: string; + /** + * Sets or retrieves the character set used to encode the object. + */ + charset: string; + /** + * Sets or retrieves the language code of the object. + */ + hreflang: string; + /** + * Sets or retrieves the port number associated with a URL. + */ + port: string; + /** + * Contains the hostname and port values of the URL. + */ + host: string; + /** + * Contains the anchor portion of the URL including the hash sign (#). + */ + hash: string; + nameProp: string; + urn: string; + /** + * Sets or retrieves the relationship between the object and the destination of the link. + */ + rev: string; + /** + * Sets or retrieves the shape of the object. + */ + shape: string; + type: string; + mimeType: string; + /** + * Returns a string representation of an object. + */ + toString(): string; +} +declare var HTMLAnchorElement: { + prototype: HTMLAnchorElement; + new (): HTMLAnchorElement; +} + +interface HTMLParamElement extends HTMLElement { + /** + * Sets or retrieves the value of an input parameter for an element. + */ + value: string; + /** + * Sets or retrieves the name of an input parameter for an element. + */ + name: string; + /** + * Sets or retrieves the content type of the resource designated by the value attribute. + */ + type: string; + /** + * Sets or retrieves the data type of the value attribute. + */ + valueType: string; +} +declare var HTMLParamElement: { + prototype: HTMLParamElement; + new (): HTMLParamElement; +} + +interface SVGImageElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + preserveAspectRatio: SVGAnimatedPreserveAspectRatio; + x: SVGAnimatedLength; + height: SVGAnimatedLength; +} +declare var SVGImageElement: { + prototype: SVGImageElement; + new (): SVGImageElement; +} + +interface SVGAnimatedNumber { + animVal: number; + baseVal: number; +} +declare var SVGAnimatedNumber: { + prototype: SVGAnimatedNumber; + new (): SVGAnimatedNumber; +} + +interface PerformanceTiming { + redirectStart: number; + domainLookupEnd: number; + responseStart: number; + domComplete: number; + domainLookupStart: number; + loadEventStart: number; + msFirstPaint: number; + unloadEventEnd: number; + fetchStart: number; + requestStart: number; + domInteractive: number; + navigationStart: number; + connectEnd: number; + loadEventEnd: number; + connectStart: number; + responseEnd: number; + domLoading: number; + redirectEnd: number; + unloadEventStart: number; + domContentLoadedEventStart: number; + domContentLoadedEventEnd: number; + toJSON(): any; +} +declare var PerformanceTiming: { + prototype: PerformanceTiming; + new (): PerformanceTiming; +} + +interface HTMLPreElement extends HTMLElement, DOML2DeprecatedTextFlowControl { + /** + * Sets or gets a value that you can use to implement your own width functionality for the object. + */ + width: number; + /** + * Indicates a citation by rendering text in italic type. + */ + cite: string; +} +declare var HTMLPreElement: { + prototype: HTMLPreElement; + new (): HTMLPreElement; +} + +interface EventException { + code: number; + message: string; + toString(): string; + DISPATCH_REQUEST_ERR: number; + UNSPECIFIED_EVENT_TYPE_ERR: number; +} +declare var EventException: { + prototype: EventException; + new (): EventException; + DISPATCH_REQUEST_ERR: number; + UNSPECIFIED_EVENT_TYPE_ERR: number; +} + +interface MSNavigatorDoNotTrack { + msDoNotTrack: string; +} + +interface NavigatorOnLine { + onLine: boolean; +} + +interface WindowLocalStorage { + localStorage: Storage; +} + +interface SVGMetadataElement extends SVGElement { +} +declare var SVGMetadataElement: { + prototype: SVGMetadataElement; + new (): SVGMetadataElement; +} + +interface SVGPathSegArcRel extends SVGPathSeg { + y: number; + sweepFlag: boolean; + r2: number; + x: number; + angle: number; + r1: number; + largeArcFlag: boolean; +} +declare var SVGPathSegArcRel: { + prototype: SVGPathSegArcRel; + new (): SVGPathSegArcRel; +} + +interface SVGPathSegMovetoAbs extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegMovetoAbs: { + prototype: SVGPathSegMovetoAbs; + new (): SVGPathSegMovetoAbs; +} + +interface SVGStringList { + numberOfItems: number; + replaceItem(newItem: string, index: number): string; + getItem(index: number): string; + clear(): void; + appendItem(newItem: string): string; + initialize(newItem: string): string; + removeItem(index: number): string; + insertItemBefore(newItem: string, index: number): string; +} +declare var SVGStringList: { + prototype: SVGStringList; + new (): SVGStringList; +} + +interface XDomainRequest { + timeout: number; + onerror: (ev: Event) => any; + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + onprogress: (ev: any) => any; + addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; + ontimeout: (ev: Event) => any; + addEventListener(type: "timeout", listener: (ev: Event) => any, useCapture?: boolean): void; + responseText: string; + contentType: string; + open(method: string, url: string): void; + create(): XDomainRequest; + abort(): void; + send(data?: any): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var XDomainRequest: { + prototype: XDomainRequest; + new (): XDomainRequest; +} + +interface DOML2DeprecatedBackgroundColorStyle { + bgColor: any; +} + +interface ElementTraversal { + childElementCount: number; + previousElementSibling: Element; + lastElementChild: Element; + nextElementSibling: Element; + firstElementChild: Element; +} + +interface SVGLength { + valueAsString: string; + valueInSpecifiedUnits: number; + value: number; + unitType: number; + newValueSpecifiedUnits(unitType: number, valueInSpecifiedUnits: number): void; + convertToSpecifiedUnits(unitType: number): void; + SVG_LENGTHTYPE_NUMBER: number; + SVG_LENGTHTYPE_CM: number; + SVG_LENGTHTYPE_PC: number; + SVG_LENGTHTYPE_PERCENTAGE: number; + SVG_LENGTHTYPE_MM: number; + SVG_LENGTHTYPE_PT: number; + SVG_LENGTHTYPE_IN: number; + SVG_LENGTHTYPE_EMS: number; + SVG_LENGTHTYPE_PX: number; + SVG_LENGTHTYPE_UNKNOWN: number; + SVG_LENGTHTYPE_EXS: number; +} +declare var SVGLength: { + prototype: SVGLength; + new (): SVGLength; + SVG_LENGTHTYPE_NUMBER: number; + SVG_LENGTHTYPE_CM: number; + SVG_LENGTHTYPE_PC: number; + SVG_LENGTHTYPE_PERCENTAGE: number; + SVG_LENGTHTYPE_MM: number; + SVG_LENGTHTYPE_PT: number; + SVG_LENGTHTYPE_IN: number; + SVG_LENGTHTYPE_EMS: number; + SVG_LENGTHTYPE_PX: number; + SVG_LENGTHTYPE_UNKNOWN: number; + SVG_LENGTHTYPE_EXS: number; +} + +interface SVGPolygonElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests, SVGExternalResourcesRequired { +} +declare var SVGPolygonElement: { + prototype: SVGPolygonElement; + new (): SVGPolygonElement; +} + +interface HTMLPhraseElement extends HTMLElement { + /** + * Sets or retrieves the date and time of a modification to the object. + */ + dateTime: string; + /** + * Sets or retrieves reference information about the object. + */ + cite: string; +} +declare var HTMLPhraseElement: { + prototype: HTMLPhraseElement; + new (): HTMLPhraseElement; +} + +interface NavigatorStorageUtils { +} + +interface SVGPathSegCurvetoCubicRel extends SVGPathSeg { + y: number; + y1: number; + x2: number; + x: number; + x1: number; + y2: number; +} +declare var SVGPathSegCurvetoCubicRel: { + prototype: SVGPathSegCurvetoCubicRel; + new (): SVGPathSegCurvetoCubicRel; +} + +interface MSEventObj extends Event { + nextPage: string; + keyCode: number; + toElement: Element; + returnValue: any; + dataFld: string; + y: number; + dataTransfer: DataTransfer; + propertyName: string; + url: string; + offsetX: number; + recordset: Object; + screenX: number; + buttonID: number; + wheelDelta: number; + reason: number; + origin: string; + data: string; + srcFilter: Object; + boundElements: HTMLCollection; + cancelBubble: boolean; + altLeft: boolean; + behaviorCookie: number; + bookmarks: BookmarkCollection; + type: string; + repeat: boolean; + srcElement: Element; + source: Window; + fromElement: Element; + offsetY: number; + x: number; + behaviorPart: number; + qualifier: string; + altKey: boolean; + ctrlKey: boolean; + clientY: number; + shiftKey: boolean; + shiftLeft: boolean; + contentOverflow: boolean; + screenY: number; + ctrlLeft: boolean; + button: number; + srcUrn: string; + clientX: number; + actionURL: string; + getAttribute(strAttributeName: string, lFlags?: number): any; + setAttribute(strAttributeName: string, AttributeValue: any, lFlags?: number): void; + removeAttribute(strAttributeName: string, lFlags?: number): boolean; +} +declare var MSEventObj: { + prototype: MSEventObj; + new (): MSEventObj; +} + +interface SVGTextContentElement extends SVGElement, SVGStylable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + textLength: SVGAnimatedLength; + lengthAdjust: SVGAnimatedEnumeration; + getCharNumAtPosition(point: SVGPoint): number; + getStartPositionOfChar(charnum: number): SVGPoint; + getExtentOfChar(charnum: number): SVGRect; + getComputedTextLength(): number; + getSubStringLength(charnum: number, nchars: number): number; + selectSubString(charnum: number, nchars: number): void; + getNumberOfChars(): number; + getRotationOfChar(charnum: number): number; + getEndPositionOfChar(charnum: number): SVGPoint; + LENGTHADJUST_SPACING: number; + LENGTHADJUST_SPACINGANDGLYPHS: number; + LENGTHADJUST_UNKNOWN: number; +} +declare var SVGTextContentElement: { + prototype: SVGTextContentElement; + new (): SVGTextContentElement; + LENGTHADJUST_SPACING: number; + LENGTHADJUST_SPACINGANDGLYPHS: number; + LENGTHADJUST_UNKNOWN: number; +} + +interface DOML2DeprecatedColorProperty { + color: string; +} + +interface HTMLCanvasElement extends HTMLElement { + /** + * Gets or sets the width of a canvas element on a document. + */ + width: number; + /** + * Gets or sets the height of a canvas element on a document. + */ + height: number; + /** + * Returns the content of the current canvas as an image that you can use as a source for another canvas or an HTML element. + * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image. + */ + toDataURL(type?: string, ...args: any[]): string; + /** + * Returns an object that provides methods and properties for drawing and manipulating images and graphics on a canvas element in a document. A context object includes information about colors, line widths, fonts, and other graphic parameters that can be drawn on a canvas. + * @param contextId The identifier (ID) of the type of canvas to create. Internet Explorer 9 and Internet Explorer 10 support only a 2-D context using canvas.getContext("2d"); IE11 Preview also supports 3-D or WebGL context using canvas.getContext("experimental-webgl"); + */ + getContext(contextId: "2d"): CanvasRenderingContext2D; + getContext(contextId: string, ...args: any[]): any; +} +declare var HTMLCanvasElement: { + prototype: HTMLCanvasElement; + new (): HTMLCanvasElement; +} + +interface Location { + hash: string; + protocol: string; + search: string; + href: string; + hostname: string; + port: string; + pathname: string; + host: string; + reload(flag?: boolean): void; + replace(url: string): void; + assign(url: string): void; + toString(): string; +} +declare var Location: { + prototype: Location; + new (): Location; +} + +interface HTMLTitleElement extends HTMLElement { + /** + * Retrieves or sets the text of the object as a string. + */ + text: string; +} +declare var HTMLTitleElement: { + prototype: HTMLTitleElement; + new (): HTMLTitleElement; +} + +interface HTMLStyleElement extends HTMLElement, LinkStyle { + /** + * Sets or retrieves the media type. + */ + media: string; + /** + * Retrieves the CSS language in which the style sheet is written. + */ + type: string; +} +declare var HTMLStyleElement: { + prototype: HTMLStyleElement; + new (): HTMLStyleElement; +} + +interface PerformanceEntry { + name: string; + startTime: number; + duration: number; + entryType: string; +} +declare var PerformanceEntry: { + prototype: PerformanceEntry; + new (): PerformanceEntry; +} + +interface SVGTransform { + type: number; + angle: number; + matrix: SVGMatrix; + setTranslate(tx: number, ty: number): void; + setScale(sx: number, sy: number): void; + setMatrix(matrix: SVGMatrix): void; + setSkewY(angle: number): void; + setRotate(angle: number, cx: number, cy: number): void; + setSkewX(angle: number): void; + SVG_TRANSFORM_SKEWX: number; + SVG_TRANSFORM_UNKNOWN: number; + SVG_TRANSFORM_SCALE: number; + SVG_TRANSFORM_TRANSLATE: number; + SVG_TRANSFORM_MATRIX: number; + SVG_TRANSFORM_ROTATE: number; + SVG_TRANSFORM_SKEWY: number; +} +declare var SVGTransform: { + prototype: SVGTransform; + new (): SVGTransform; + SVG_TRANSFORM_SKEWX: number; + SVG_TRANSFORM_UNKNOWN: number; + SVG_TRANSFORM_SCALE: number; + SVG_TRANSFORM_TRANSLATE: number; + SVG_TRANSFORM_MATRIX: number; + SVG_TRANSFORM_ROTATE: number; + SVG_TRANSFORM_SKEWY: number; +} + +interface UIEvent extends Event { + detail: number; + view: Window; + initUIEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number): void; +} +declare var UIEvent: { + prototype: UIEvent; + new (): UIEvent; +} + +interface SVGURIReference { + href: SVGAnimatedString; +} + +interface SVGPathSeg { + pathSegType: number; + pathSegTypeAsLetter: string; + PATHSEG_MOVETO_REL: number; + PATHSEG_LINETO_VERTICAL_REL: number; + PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number; + PATHSEG_CURVETO_QUADRATIC_REL: number; + PATHSEG_CURVETO_CUBIC_ABS: number; + PATHSEG_LINETO_HORIZONTAL_ABS: number; + PATHSEG_CURVETO_QUADRATIC_ABS: number; + PATHSEG_LINETO_ABS: number; + PATHSEG_CLOSEPATH: number; + PATHSEG_LINETO_HORIZONTAL_REL: number; + PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number; + PATHSEG_LINETO_REL: number; + PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number; + PATHSEG_ARC_REL: number; + PATHSEG_CURVETO_CUBIC_REL: number; + PATHSEG_UNKNOWN: number; + PATHSEG_LINETO_VERTICAL_ABS: number; + PATHSEG_ARC_ABS: number; + PATHSEG_MOVETO_ABS: number; + PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number; +} +declare var SVGPathSeg: { + prototype: SVGPathSeg; + new (): SVGPathSeg; + PATHSEG_MOVETO_REL: number; + PATHSEG_LINETO_VERTICAL_REL: number; + PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: number; + PATHSEG_CURVETO_QUADRATIC_REL: number; + PATHSEG_CURVETO_CUBIC_ABS: number; + PATHSEG_LINETO_HORIZONTAL_ABS: number; + PATHSEG_CURVETO_QUADRATIC_ABS: number; + PATHSEG_LINETO_ABS: number; + PATHSEG_CLOSEPATH: number; + PATHSEG_LINETO_HORIZONTAL_REL: number; + PATHSEG_CURVETO_CUBIC_SMOOTH_REL: number; + PATHSEG_LINETO_REL: number; + PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: number; + PATHSEG_ARC_REL: number; + PATHSEG_CURVETO_CUBIC_REL: number; + PATHSEG_UNKNOWN: number; + PATHSEG_LINETO_VERTICAL_ABS: number; + PATHSEG_ARC_ABS: number; + PATHSEG_MOVETO_ABS: number; + PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: number; +} + +interface WheelEvent extends MouseEvent { + deltaZ: number; + deltaX: number; + deltaMode: number; + deltaY: number; + initWheelEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, buttonArg: number, relatedTargetArg: EventTarget, modifiersListArg: string, deltaXArg: number, deltaYArg: number, deltaZArg: number, deltaMode: number): void; + DOM_DELTA_PIXEL: number; + DOM_DELTA_LINE: number; + DOM_DELTA_PAGE: number; +} +declare var WheelEvent: { + prototype: WheelEvent; + new (): WheelEvent; + DOM_DELTA_PIXEL: number; + DOM_DELTA_LINE: number; + DOM_DELTA_PAGE: number; +} + +interface MSEventAttachmentTarget { + attachEvent(event: string, listener: EventListener): boolean; + detachEvent(event: string, listener: EventListener): void; +} + +interface SVGNumber { + value: number; +} +declare var SVGNumber: { + prototype: SVGNumber; + new (): SVGNumber; +} + +interface SVGPathElement extends SVGElement, SVGStylable, SVGAnimatedPathData, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + getPathSegAtLength(distance: number): number; + getPointAtLength(distance: number): SVGPoint; + createSVGPathSegCurvetoQuadraticAbs(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticAbs; + createSVGPathSegLinetoRel(x: number, y: number): SVGPathSegLinetoRel; + createSVGPathSegCurvetoQuadraticRel(x: number, y: number, x1: number, y1: number): SVGPathSegCurvetoQuadraticRel; + createSVGPathSegCurvetoCubicAbs(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicAbs; + createSVGPathSegLinetoAbs(x: number, y: number): SVGPathSegLinetoAbs; + createSVGPathSegClosePath(): SVGPathSegClosePath; + createSVGPathSegCurvetoCubicRel(x: number, y: number, x1: number, y1: number, x2: number, y2: number): SVGPathSegCurvetoCubicRel; + createSVGPathSegCurvetoQuadraticSmoothRel(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothRel; + createSVGPathSegMovetoRel(x: number, y: number): SVGPathSegMovetoRel; + createSVGPathSegCurvetoCubicSmoothAbs(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothAbs; + createSVGPathSegMovetoAbs(x: number, y: number): SVGPathSegMovetoAbs; + createSVGPathSegLinetoVerticalRel(y: number): SVGPathSegLinetoVerticalRel; + createSVGPathSegArcRel(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcRel; + createSVGPathSegCurvetoQuadraticSmoothAbs(x: number, y: number): SVGPathSegCurvetoQuadraticSmoothAbs; + createSVGPathSegLinetoHorizontalRel(x: number): SVGPathSegLinetoHorizontalRel; + getTotalLength(): number; + createSVGPathSegCurvetoCubicSmoothRel(x: number, y: number, x2: number, y2: number): SVGPathSegCurvetoCubicSmoothRel; + createSVGPathSegLinetoHorizontalAbs(x: number): SVGPathSegLinetoHorizontalAbs; + createSVGPathSegLinetoVerticalAbs(y: number): SVGPathSegLinetoVerticalAbs; + createSVGPathSegArcAbs(x: number, y: number, r1: number, r2: number, angle: number, largeArcFlag: boolean, sweepFlag: boolean): SVGPathSegArcAbs; +} +declare var SVGPathElement: { + prototype: SVGPathElement; + new (): SVGPathElement; +} + +interface MSCompatibleInfo { + version: string; + userAgent: string; +} +declare var MSCompatibleInfo: { + prototype: MSCompatibleInfo; + new (): MSCompatibleInfo; +} + +interface Text extends CharacterData, MSNodeExtensions { + wholeText: string; + splitText(offset: number): Text; + replaceWholeText(content: string): Text; +} +declare var Text: { + prototype: Text; + new (): Text; +} + +interface SVGAnimatedRect { + animVal: SVGRect; + baseVal: SVGRect; +} +declare var SVGAnimatedRect: { + prototype: SVGAnimatedRect; + new (): SVGAnimatedRect; +} + +interface CSSNamespaceRule extends CSSRule { + namespaceURI: string; + prefix: string; +} +declare var CSSNamespaceRule: { + prototype: CSSNamespaceRule; + new (): CSSNamespaceRule; +} + +interface SVGPathSegList { + numberOfItems: number; + replaceItem(newItem: SVGPathSeg, index: number): SVGPathSeg; + getItem(index: number): SVGPathSeg; + clear(): void; + appendItem(newItem: SVGPathSeg): SVGPathSeg; + initialize(newItem: SVGPathSeg): SVGPathSeg; + removeItem(index: number): SVGPathSeg; + insertItemBefore(newItem: SVGPathSeg, index: number): SVGPathSeg; +} +declare var SVGPathSegList: { + prototype: SVGPathSegList; + new (): SVGPathSegList; +} + +interface HTMLUnknownElement extends HTMLElement, MSDataBindingRecordSetReadonlyExtensions { +} +declare var HTMLUnknownElement: { + prototype: HTMLUnknownElement; + new (): HTMLUnknownElement; +} + +interface HTMLAudioElement extends HTMLMediaElement { +} +declare var HTMLAudioElement: { + prototype: HTMLAudioElement; + new (): HTMLAudioElement; +} + +interface MSImageResourceExtensions { + dynsrc: string; + vrml: string; + lowsrc: string; + start: string; + loop: number; +} + +interface PositionError { + code: number; + message: string; + toString(): string; + POSITION_UNAVAILABLE: number; + PERMISSION_DENIED: number; + TIMEOUT: number; +} +declare var PositionError: { + prototype: PositionError; + new (): PositionError; + POSITION_UNAVAILABLE: number; + PERMISSION_DENIED: number; + TIMEOUT: number; +} + +interface HTMLTableCellElement extends HTMLElement, HTMLTableAlignment, DOML2DeprecatedBackgroundStyle, DOML2DeprecatedBackgroundColorStyle { + /** + * Sets or retrieves the width of the object. + */ + width: number; + /** + * Sets or retrieves a list of header cells that provide information for the object. + */ + headers: string; + /** + * Retrieves the position of the object in the cells collection of a row. + */ + cellIndex: number; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorLight: any; + /** + * Sets or retrieves the number columns in the table that the object should span. + */ + colSpan: number; + /** + * Sets or retrieves the border color of the object. + */ + borderColor: any; + /** + * Sets or retrieves a comma-delimited list of conceptual categories associated with the object. + */ + axis: string; + /** + * Sets or retrieves the height of the object. + */ + height: any; + /** + * Sets or retrieves whether the browser automatically performs wordwrap. + */ + noWrap: boolean; + /** + * Sets or retrieves abbreviated text for the object. + */ + abbr: string; + /** + * Sets or retrieves how many rows in a table the cell should span. + */ + rowSpan: number; + /** + * Sets or retrieves the group of cells in a table to which the object's information applies. + */ + scope: string; + /** + * Sets or retrieves the color for one of the two colors used to draw the 3-D border of the object. + */ + borderColorDark: any; +} +declare var HTMLTableCellElement: { + prototype: HTMLTableCellElement; + new (): HTMLTableCellElement; +} + +interface SVGElementInstance extends EventTarget { + previousSibling: SVGElementInstance; + parentNode: SVGElementInstance; + lastChild: SVGElementInstance; + nextSibling: SVGElementInstance; + childNodes: SVGElementInstanceList; + correspondingUseElement: SVGUseElement; + correspondingElement: SVGElement; + firstChild: SVGElementInstance; +} +declare var SVGElementInstance: { + prototype: SVGElementInstance; + new (): SVGElementInstance; +} + +interface MSNamespaceInfoCollection { + length: number; + add(namespace?: string, urn?: string, implementationUrl?: any): Object; + item(index: any): Object; + [index: string]: Object; +} +declare var MSNamespaceInfoCollection: { + prototype: MSNamespaceInfoCollection; + new (): MSNamespaceInfoCollection; +} + +interface SVGCircleElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + cx: SVGAnimatedLength; + r: SVGAnimatedLength; + cy: SVGAnimatedLength; +} +declare var SVGCircleElement: { + prototype: SVGCircleElement; + new (): SVGCircleElement; +} + +interface StyleSheetList { + length: number; + item(index?: number): StyleSheet; + [index: number]: StyleSheet; +} +declare var StyleSheetList: { + prototype: StyleSheetList; + new (): StyleSheetList; +} + +interface CSSImportRule extends CSSRule { + styleSheet: CSSStyleSheet; + href: string; + media: MediaList; +} +declare var CSSImportRule: { + prototype: CSSImportRule; + new (): CSSImportRule; +} + +interface CustomEvent extends Event { + detail: Object; + initCustomEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, detailArg: Object): void; +} +declare var CustomEvent: { + prototype: CustomEvent; + new (): CustomEvent; +} + +interface HTMLBaseFontElement extends HTMLElement, DOML2DeprecatedColorProperty { + /** + * Sets or retrieves the current typeface family. + */ + face: string; + /** + * Sets or retrieves the font size of the object. + */ + size: number; +} +declare var HTMLBaseFontElement: { + prototype: HTMLBaseFontElement; + new (): HTMLBaseFontElement; +} + +interface HTMLTextAreaElement extends HTMLElement, MSDataBindingExtensions { + /** + * Retrieves or sets the text in the entry field of the textArea element. + */ + value: string; + /** + * Sets or retrieves the value indicating whether the control is selected. + */ + status: any; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Gets or sets the starting position or offset of a text selection. + */ + selectionStart: number; + /** + * Sets or retrieves the number of horizontal rows contained in the object. + */ + rows: number; + /** + * Sets or retrieves the width of the object. + */ + cols: number; + /** + * Sets or retrieves the value indicated whether the content of the object is read-only. + */ + readOnly: boolean; + /** + * Sets or retrieves how to handle wordwrapping in the object. + */ + wrap: string; + /** + * Gets or sets the end position or offset of a text selection. + */ + selectionEnd: number; + /** + * Retrieves the type of control. + */ + type: string; + /** + * Sets or retrieves the initial contents of the object. + */ + defaultValue: string; + /** + * Creates a TextRange object for the element. + */ + createTextRange(): TextRange; + /** + * Sets the start and end positions of a selection in a text field. + * @param start The offset into the text field for the start of the selection. + * @param end The offset into the text field for the end of the selection. + */ + setSelectionRange(start: number, end: number): void; + /** + * Highlights the input area of a form element. + */ + select(): void; +} +declare var HTMLTextAreaElement: { + prototype: HTMLTextAreaElement; + new (): HTMLTextAreaElement; +} + +interface Geolocation { + clearWatch(watchId: number): void; + getCurrentPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): void; + watchPosition(successCallback: PositionCallback, errorCallback?: PositionErrorCallback, options?: PositionOptions): number; +} +declare var Geolocation: { + prototype: Geolocation; + new (): Geolocation; +} + +interface DOML2DeprecatedMarginStyle { + vspace: number; + hspace: number; +} + +interface MSWindowModeless { + dialogTop: any; + dialogLeft: any; + dialogWidth: any; + dialogHeight: any; + menuArguments: any; +} + +interface DOML2DeprecatedAlignmentStyle { + align: string; +} + +interface HTMLMarqueeElement extends HTMLElement, MSDataBindingExtensions, DOML2DeprecatedBackgroundColorStyle { + width: string; + onbounce: (ev: Event) => any; + addEventListener(type: "bounce", listener: (ev: Event) => any, useCapture?: boolean): void; + vspace: number; + trueSpeed: boolean; + scrollAmount: number; + scrollDelay: number; + behavior: string; + height: string; + loop: number; + direction: string; + hspace: number; + onstart: (ev: Event) => any; + addEventListener(type: "start", listener: (ev: Event) => any, useCapture?: boolean): void; + onfinish: (ev: Event) => any; + addEventListener(type: "finish", listener: (ev: Event) => any, useCapture?: boolean): void; + stop(): void; + start(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLMarqueeElement: { + prototype: HTMLMarqueeElement; + new (): HTMLMarqueeElement; +} + +interface SVGRect { + y: number; + width: number; + x: number; + height: number; +} +declare var SVGRect: { + prototype: SVGRect; + new (): SVGRect; +} + +interface MSNodeExtensions { + swapNode(otherNode: Node): Node; + removeNode(deep?: boolean): Node; + replaceNode(replacement: Node): Node; +} + +interface History { + length: number; + back(distance?: any): void; + forward(distance?: any): void; + go(delta?: any): void; +} +declare var History: { + prototype: History; + new (): History; +} + +interface SVGPathSegCurvetoCubicAbs extends SVGPathSeg { + y: number; + y1: number; + x2: number; + x: number; + x1: number; + y2: number; +} +declare var SVGPathSegCurvetoCubicAbs: { + prototype: SVGPathSegCurvetoCubicAbs; + new (): SVGPathSegCurvetoCubicAbs; +} + +interface SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg { + y: number; + y1: number; + x: number; + x1: number; +} +declare var SVGPathSegCurvetoQuadraticAbs: { + prototype: SVGPathSegCurvetoQuadraticAbs; + new (): SVGPathSegCurvetoQuadraticAbs; +} + +interface TimeRanges { + length: number; + start(index: number): number; + end(index: number): number; +} +declare var TimeRanges: { + prototype: TimeRanges; + new (): TimeRanges; +} + +interface CSSRule { + cssText: string; + parentStyleSheet: CSSStyleSheet; + parentRule: CSSRule; + type: number; + IMPORT_RULE: number; + MEDIA_RULE: number; + STYLE_RULE: number; + NAMESPACE_RULE: number; + PAGE_RULE: number; + UNKNOWN_RULE: number; + FONT_FACE_RULE: number; + CHARSET_RULE: number; +} +declare var CSSRule: { + prototype: CSSRule; + new (): CSSRule; + IMPORT_RULE: number; + MEDIA_RULE: number; + STYLE_RULE: number; + NAMESPACE_RULE: number; + PAGE_RULE: number; + UNKNOWN_RULE: number; + FONT_FACE_RULE: number; + CHARSET_RULE: number; +} + +interface SVGPathSegLinetoAbs extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegLinetoAbs: { + prototype: SVGPathSegLinetoAbs; + new (): SVGPathSegLinetoAbs; +} + +interface HTMLModElement extends HTMLElement { + /** + * Sets or retrieves the date and time of a modification to the object. + */ + dateTime: string; + /** + * Sets or retrieves reference information about the object. + */ + cite: string; +} +declare var HTMLModElement: { + prototype: HTMLModElement; + new (): HTMLModElement; +} + +interface SVGMatrix { + e: number; + c: number; + a: number; + b: number; + d: number; + f: number; + multiply(secondMatrix: SVGMatrix): SVGMatrix; + flipY(): SVGMatrix; + skewY(angle: number): SVGMatrix; + inverse(): SVGMatrix; + scaleNonUniform(scaleFactorX: number, scaleFactorY: number): SVGMatrix; + rotate(angle: number): SVGMatrix; + flipX(): SVGMatrix; + translate(x: number, y: number): SVGMatrix; + scale(scaleFactor: number): SVGMatrix; + rotateFromVector(x: number, y: number): SVGMatrix; + skewX(angle: number): SVGMatrix; +} +declare var SVGMatrix: { + prototype: SVGMatrix; + new (): SVGMatrix; +} + +interface MSPopupWindow { + document: Document; + isOpen: boolean; + show(x: number, y: number, w: number, h: number, element?: any): void; + hide(): void; +} +declare var MSPopupWindow: { + prototype: MSPopupWindow; + new (): MSPopupWindow; +} + +interface BeforeUnloadEvent extends Event { + returnValue: string; +} +declare var BeforeUnloadEvent: { + prototype: BeforeUnloadEvent; + new (): BeforeUnloadEvent; +} + +interface SVGUseElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired, SVGURIReference { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + animatedInstanceRoot: SVGElementInstance; + instanceRoot: SVGElementInstance; + x: SVGAnimatedLength; + height: SVGAnimatedLength; +} +declare var SVGUseElement: { + prototype: SVGUseElement; + new (): SVGUseElement; +} + +interface Event { + timeStamp: number; + defaultPrevented: boolean; + isTrusted: boolean; + currentTarget: EventTarget; + cancelBubble: boolean; + target: EventTarget; + eventPhase: number; + cancelable: boolean; + type: string; + srcElement: Element; + bubbles: boolean; + initEvent(eventTypeArg: string, canBubbleArg: boolean, cancelableArg: boolean): void; + stopPropagation(): void; + stopImmediatePropagation(): void; + preventDefault(): void; + CAPTURING_PHASE: number; + AT_TARGET: number; + BUBBLING_PHASE: number; +} +declare var Event: { + prototype: Event; + new (): Event; + CAPTURING_PHASE: number; + AT_TARGET: number; + BUBBLING_PHASE: number; +} + +interface ImageData { + width: number; + data: Uint8Array; + height: number; +} +declare var ImageData: { + prototype: ImageData; + new (): ImageData; +} + +interface HTMLTableColElement extends HTMLElement, HTMLTableAlignment { + /** + * Sets or retrieves the width of the object. + */ + width: any; + /** + * Sets or retrieves the alignment of the object relative to the display or table. + */ + align: string; + /** + * Sets or retrieves the number of columns in the group. + */ + span: number; +} +declare var HTMLTableColElement: { + prototype: HTMLTableColElement; + new (): HTMLTableColElement; +} + +interface SVGException { + code: number; + message: string; + toString(): string; + SVG_MATRIX_NOT_INVERTABLE: number; + SVG_WRONG_TYPE_ERR: number; + SVG_INVALID_VALUE_ERR: number; +} +declare var SVGException: { + prototype: SVGException; + new (): SVGException; + SVG_MATRIX_NOT_INVERTABLE: number; + SVG_WRONG_TYPE_ERR: number; + SVG_INVALID_VALUE_ERR: number; +} + +interface SVGLinearGradientElement extends SVGGradientElement { + y1: SVGAnimatedLength; + x2: SVGAnimatedLength; + x1: SVGAnimatedLength; + y2: SVGAnimatedLength; +} +declare var SVGLinearGradientElement: { + prototype: SVGLinearGradientElement; + new (): SVGLinearGradientElement; +} + +interface HTMLTableAlignment { + /** + * Sets or retrieves a value that you can use to implement your own ch functionality for the object. + */ + ch: string; + /** + * Sets or retrieves how text and other content are vertically aligned within the object that contains them. + */ + vAlign: string; + /** + * Sets or retrieves a value that you can use to implement your own chOff functionality for the object. + */ + chOff: string; +} + +interface SVGAnimatedEnumeration { + animVal: number; + baseVal: number; +} +declare var SVGAnimatedEnumeration: { + prototype: SVGAnimatedEnumeration; + new (): SVGAnimatedEnumeration; +} + +interface DOML2DeprecatedSizeProperty { + size: number; +} + +interface HTMLUListElement extends HTMLElement, DOML2DeprecatedListSpaceReduction, DOML2DeprecatedListNumberingAndBulletStyle { +} +declare var HTMLUListElement: { + prototype: HTMLUListElement; + new (): HTMLUListElement; +} + +interface SVGRectElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + ry: SVGAnimatedLength; + rx: SVGAnimatedLength; + x: SVGAnimatedLength; + height: SVGAnimatedLength; +} +declare var SVGRectElement: { + prototype: SVGRectElement; + new (): SVGRectElement; +} + +interface ErrorEventHandler { + (event: Event, source: string, fileno: number, columnNumber: number): void; + (message: any, uri: string, lineNumber: number, columnNumber?: number): boolean; +} + +interface HTMLDivElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Sets or retrieves whether the browser automatically performs wordwrap. + */ + noWrap: boolean; +} +declare var HTMLDivElement: { + prototype: HTMLDivElement; + new (): HTMLDivElement; +} + +interface DOML2DeprecatedBorderStyle { + border: string; +} + +interface NamedNodeMap { + length: number; + removeNamedItemNS(namespaceURI: string, localName: string): Attr; + item(index: number): Attr; + [index: number]: Attr; + removeNamedItem(name: string): Attr; + getNamedItem(name: string): Attr; + setNamedItem(arg: Attr): Attr; + getNamedItemNS(namespaceURI: string, localName: string): Attr; + setNamedItemNS(arg: Attr): Attr; +} +declare var NamedNodeMap: { + prototype: NamedNodeMap; + new (): NamedNodeMap; +} + +interface MediaList { + length: number; + mediaText: string; + deleteMedium(oldMedium: string): void; + appendMedium(newMedium: string): void; + item(index: number): string; + [index: number]: string; + toString(): string; +} +declare var MediaList: { + prototype: MediaList; + new (): MediaList; +} + +interface SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegCurvetoQuadraticSmoothAbs: { + prototype: SVGPathSegCurvetoQuadraticSmoothAbs; + new (): SVGPathSegCurvetoQuadraticSmoothAbs; +} + +interface SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg { + y: number; + x2: number; + x: number; + y2: number; +} +declare var SVGPathSegCurvetoCubicSmoothRel: { + prototype: SVGPathSegCurvetoCubicSmoothRel; + new (): SVGPathSegCurvetoCubicSmoothRel; +} + +interface SVGLengthList { + numberOfItems: number; + replaceItem(newItem: SVGLength, index: number): SVGLength; + getItem(index: number): SVGLength; + clear(): void; + appendItem(newItem: SVGLength): SVGLength; + initialize(newItem: SVGLength): SVGLength; + removeItem(index: number): SVGLength; + insertItemBefore(newItem: SVGLength, index: number): SVGLength; +} +declare var SVGLengthList: { + prototype: SVGLengthList; + new (): SVGLengthList; +} + +interface ProcessingInstruction extends Node { + target: string; + data: string; +} +declare var ProcessingInstruction: { + prototype: ProcessingInstruction; + new (): ProcessingInstruction; +} + +interface MSWindowExtensions { + status: string; + onmouseleave: (ev: MouseEvent) => any; + addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + screenLeft: number; + offscreenBuffering: any; + maxConnectionsPerServer: number; + onmouseenter: (ev: MouseEvent) => any; + addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + clipboardData: DataTransfer; + defaultStatus: string; + clientInformation: Navigator; + closed: boolean; + onhelp: (ev: Event) => any; + addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void; + external: External; + event: MSEventObj; + onfocusout: (ev: FocusEvent) => any; + addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + screenTop: number; + onfocusin: (ev: FocusEvent) => any; + addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + showModelessDialog(url?: string, argument?: any, options?: any): Window; + navigate(url: string): void; + resizeBy(x?: number, y?: number): void; + item(index: any): any; + resizeTo(x?: number, y?: number): void; + createPopup(arguments?: any): MSPopupWindow; + toStaticHTML(html: string): string; + execScript(code: string, language?: string): any; + msWriteProfilerMark(profilerMarkName: string): void; + moveTo(x?: number, y?: number): void; + moveBy(x?: number, y?: number): void; + showHelp(url: string, helpArg?: any, features?: string): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface MSBehaviorUrnsCollection { + length: number; + item(index: number): string; +} +declare var MSBehaviorUrnsCollection: { + prototype: MSBehaviorUrnsCollection; + new (): MSBehaviorUrnsCollection; +} + +interface CSSFontFaceRule extends CSSRule { + style: CSSStyleDeclaration; +} +declare var CSSFontFaceRule: { + prototype: CSSFontFaceRule; + new (): CSSFontFaceRule; +} + +interface DOML2DeprecatedBackgroundStyle { + background: string; +} + +interface TextEvent extends UIEvent { + inputMethod: number; + data: string; + locale: string; + initTextEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, dataArg: string, inputMethod: number, locale: string): void; + DOM_INPUT_METHOD_KEYBOARD: number; + DOM_INPUT_METHOD_DROP: number; + DOM_INPUT_METHOD_IME: number; + DOM_INPUT_METHOD_SCRIPT: number; + DOM_INPUT_METHOD_VOICE: number; + DOM_INPUT_METHOD_UNKNOWN: number; + DOM_INPUT_METHOD_PASTE: number; + DOM_INPUT_METHOD_HANDWRITING: number; + DOM_INPUT_METHOD_OPTION: number; + DOM_INPUT_METHOD_MULTIMODAL: number; +} +declare var TextEvent: { + prototype: TextEvent; + new (): TextEvent; + DOM_INPUT_METHOD_KEYBOARD: number; + DOM_INPUT_METHOD_DROP: number; + DOM_INPUT_METHOD_IME: number; + DOM_INPUT_METHOD_SCRIPT: number; + DOM_INPUT_METHOD_VOICE: number; + DOM_INPUT_METHOD_UNKNOWN: number; + DOM_INPUT_METHOD_PASTE: number; + DOM_INPUT_METHOD_HANDWRITING: number; + DOM_INPUT_METHOD_OPTION: number; + DOM_INPUT_METHOD_MULTIMODAL: number; +} + +interface DocumentFragment extends Node, NodeSelector, MSEventAttachmentTarget, MSNodeExtensions { +} +declare var DocumentFragment: { + prototype: DocumentFragment; + new (): DocumentFragment; +} + +interface SVGPolylineElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGAnimatedPoints, SVGTests, SVGExternalResourcesRequired { +} +declare var SVGPolylineElement: { + prototype: SVGPolylineElement; + new (): SVGPolylineElement; +} + +interface SVGAnimatedPathData { + pathSegList: SVGPathSegList; +} + +interface Position { + timestamp: number; + coords: Coordinates; +} +declare var Position: { + prototype: Position; + new (): Position; +} + +interface BookmarkCollection { + length: number; + item(index: number): any; + [index: number]: any; +} +declare var BookmarkCollection: { + prototype: BookmarkCollection; + new (): BookmarkCollection; +} + +interface PerformanceMark extends PerformanceEntry { +} +declare var PerformanceMark: { + prototype: PerformanceMark; + new (): PerformanceMark; +} + +interface CSSPageRule extends CSSRule { + pseudoClass: string; + selectorText: string; + selector: string; + style: CSSStyleDeclaration; +} +declare var CSSPageRule: { + prototype: CSSPageRule; + new (): CSSPageRule; +} + +interface HTMLBRElement extends HTMLElement { + /** + * Sets or retrieves the side on which floating objects are not to be positioned when any IHTMLBlockElement is inserted into the document. + */ + clear: string; +} +declare var HTMLBRElement: { + prototype: HTMLBRElement; + new (): HTMLBRElement; +} + +interface MSNavigatorExtensions { + userLanguage: string; + plugins: MSPluginsCollection; + cookieEnabled: boolean; + appCodeName: string; + cpuClass: string; + appMinorVersion: string; + connectionSpeed: number; + browserLanguage: string; + mimeTypes: MSMimeTypesCollection; + systemLanguage: string; + javaEnabled(): boolean; + taintEnabled(): boolean; +} + +interface HTMLSpanElement extends HTMLElement, MSDataBindingExtensions { +} +declare var HTMLSpanElement: { + prototype: HTMLSpanElement; + new (): HTMLSpanElement; +} + +interface HTMLHeadElement extends HTMLElement { + profile: string; +} +declare var HTMLHeadElement: { + prototype: HTMLHeadElement; + new (): HTMLHeadElement; +} + +interface HTMLHeadingElement extends HTMLElement, DOML2DeprecatedTextFlowControl { + /** + * Sets or retrieves a value that indicates the table alignment. + */ + align: string; +} +declare var HTMLHeadingElement: { + prototype: HTMLHeadingElement; + new (): HTMLHeadingElement; +} + +interface HTMLFormElement extends HTMLElement, MSHTMLCollectionExtensions { + /** + * Sets or retrieves the number of objects in a collection. + */ + length: number; + /** + * Sets or retrieves the window or frame at which to target content. + */ + target: string; + /** + * Sets or retrieves a list of character encodings for input data that must be accepted by the server processing the form. + */ + acceptCharset: string; + /** + * Sets or retrieves the encoding type for the form. + */ + enctype: string; + /** + * Retrieves a collection, in source order, of all controls in a given form. + */ + elements: HTMLCollection; + /** + * Sets or retrieves the URL to which the form content is sent for processing. + */ + action: string; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Sets or retrieves how to send the form data to the server. + */ + method: string; + /** + * Sets or retrieves the MIME encoding for the form. + */ + encoding: string; + /** + * Fires when the user resets a form. + */ + reset(): void; + /** + * Retrieves a form object or an object from an elements collection. + * @param name Variant of type Number or String that specifies the object or collection to retrieve. If this parameter is a Number, it is the zero-based index of the object. If this parameter is a string, all objects with matching name or id properties are retrieved, and a collection is returned if more than one match is made. + * @param index Variant of type Number that specifies the zero-based index of the object to retrieve when a collection is returned. + */ + item(name?: any, index?: any): any; + /** + * Fires when a FORM is about to be submitted. + */ + submit(): void; + /** + * Retrieves a form object or an object from an elements collection. + */ + namedItem(name: string): any; + [name: string]: any; +} +declare var HTMLFormElement: { + prototype: HTMLFormElement; + new (): HTMLFormElement; +} + +interface SVGZoomAndPan { + zoomAndPan: number; + SVG_ZOOMANDPAN_MAGNIFY: number; + SVG_ZOOMANDPAN_UNKNOWN: number; + SVG_ZOOMANDPAN_DISABLE: number; +} +declare var SVGZoomAndPan: { + prototype: SVGZoomAndPan; + new (): SVGZoomAndPan; + SVG_ZOOMANDPAN_MAGNIFY: number; + SVG_ZOOMANDPAN_UNKNOWN: number; + SVG_ZOOMANDPAN_DISABLE: number; +} + +interface HTMLMediaElement extends HTMLElement { + /** + * Gets the earliest possible position, in seconds, that the playback can begin. + */ + initialTime: number; + /** + * Gets TimeRanges for the current media resource that has been played. + */ + played: TimeRanges; + /** + * Gets the address or URL of the current media resource that is selected by IHTMLMediaElement. + */ + currentSrc: string; + readyState: any; + /** + * The autobuffer element is not supported by Internet Explorer 9. Use the preload element instead. + */ + autobuffer: boolean; + /** + * Gets or sets a flag to specify whether playback should restart after it completes. + */ + loop: boolean; + /** + * Gets information about whether the playback has ended or not. + */ + ended: boolean; + /** + * Gets a collection of buffered time ranges. + */ + buffered: TimeRanges; + /** + * Returns an object representing the current error state of the audio or video element. + */ + error: MediaError; + /** + * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked. + */ + seekable: TimeRanges; + /** + * Gets or sets a value that indicates whether to start playing the media automatically. + */ + autoplay: boolean; + /** + * Gets or sets a flag that indicates whether the client provides a set of controls for the media (in case the developer does not include controls for the player). + */ + controls: boolean; + /** + * Gets or sets the volume level for audio portions of the media element. + */ + volume: number; + /** + * The address or URL of the a media resource that is to be considered. + */ + src: string; + /** + * Gets or sets the current rate of speed for the media resource to play. This speed is expressed as a multiple of the normal speed of the media resource. + */ + playbackRate: number; + /** + * Returns the duration in seconds of the current media resource. A NaN value is returned if duration is not available, or Infinity if the media resource is streaming. + */ + duration: number; + /** + * Gets or sets a flag that indicates whether the audio (either audio or the audio track on video media) is muted. + */ + muted: boolean; + /** + * Gets or sets the default playback rate when the user is not using fast forward or reverse for a video or audio resource. + */ + defaultPlaybackRate: number; + /** + * Gets a flag that specifies whether playback is paused. + */ + paused: boolean; + /** + * Gets a flag that indicates whether the the client is currently moving to a new playback position in the media resource. + */ + seeking: boolean; + /** + * Gets or sets the current playback position, in seconds. + */ + currentTime: number; + /** + * Gets or sets the current playback position, in seconds. + */ + preload: string; + /** + * Gets the current network activity for the element. + */ + networkState: number; + /** + * Pauses the current playback and sets paused to TRUE. This can be used to test whether the media is playing or paused. You can also use the pause or play events to tell whether the media is playing or not. + */ + pause(): void; + /** + * Loads and starts playback of a media resource. + */ + play(): void; + /** + * Fires immediately after the client loads the object. + */ + load(): void; + /** + * Returns a string that specifies whether the client can play a given media resource type. + */ + canPlayType(type: string): string; + HAVE_METADATA: number; + HAVE_CURRENT_DATA: number; + HAVE_NOTHING: number; + NETWORK_NO_SOURCE: number; + HAVE_ENOUGH_DATA: number; + NETWORK_EMPTY: number; + NETWORK_LOADING: number; + NETWORK_IDLE: number; + HAVE_FUTURE_DATA: number; +} +declare var HTMLMediaElement: { + prototype: HTMLMediaElement; + new (): HTMLMediaElement; + HAVE_METADATA: number; + HAVE_CURRENT_DATA: number; + HAVE_NOTHING: number; + NETWORK_NO_SOURCE: number; + HAVE_ENOUGH_DATA: number; + NETWORK_EMPTY: number; + NETWORK_LOADING: number; + NETWORK_IDLE: number; + HAVE_FUTURE_DATA: number; +} + +interface ElementCSSInlineStyle { + runtimeStyle: MSStyleCSSProperties; + currentStyle: MSCurrentStyleCSSProperties; + doScroll(component?: any): void; + componentFromPoint(x: number, y: number): string; +} + +interface DOMParser { + parseFromString(source: string, mimeType: string): Document; +} +declare var DOMParser: { + prototype: DOMParser; + new (): DOMParser; +} + +interface MSMimeTypesCollection { + length: number; +} +declare var MSMimeTypesCollection: { + prototype: MSMimeTypesCollection; + new (): MSMimeTypesCollection; +} + +interface StyleSheet { + disabled: boolean; + ownerNode: Node; + parentStyleSheet: StyleSheet; + href: string; + media: MediaList; + type: string; + title: string; +} +declare var StyleSheet: { + prototype: StyleSheet; + new (): StyleSheet; +} + +interface SVGTextPathElement extends SVGTextContentElement, SVGURIReference { + startOffset: SVGAnimatedLength; + method: SVGAnimatedEnumeration; + spacing: SVGAnimatedEnumeration; + TEXTPATH_SPACINGTYPE_EXACT: number; + TEXTPATH_METHODTYPE_STRETCH: number; + TEXTPATH_SPACINGTYPE_AUTO: number; + TEXTPATH_SPACINGTYPE_UNKNOWN: number; + TEXTPATH_METHODTYPE_UNKNOWN: number; + TEXTPATH_METHODTYPE_ALIGN: number; +} +declare var SVGTextPathElement: { + prototype: SVGTextPathElement; + new (): SVGTextPathElement; + TEXTPATH_SPACINGTYPE_EXACT: number; + TEXTPATH_METHODTYPE_STRETCH: number; + TEXTPATH_SPACINGTYPE_AUTO: number; + TEXTPATH_SPACINGTYPE_UNKNOWN: number; + TEXTPATH_METHODTYPE_UNKNOWN: number; + TEXTPATH_METHODTYPE_ALIGN: number; +} + +interface HTMLDTElement extends HTMLElement { + /** + * Sets or retrieves whether the browser automatically performs wordwrap. + */ + noWrap: boolean; +} +declare var HTMLDTElement: { + prototype: HTMLDTElement; + new (): HTMLDTElement; +} + +interface NodeList { + length: number; + item(index: number): Node; + [index: number]: Node; +} +declare var NodeList: { + prototype: NodeList; + new (): NodeList; +} + +interface NodeListOf extends NodeList { + length: number; + item(index: number): TNode; + [index: number]: TNode; +} + +interface XMLSerializer { + serializeToString(target: Node): string; +} +declare var XMLSerializer: { + prototype: XMLSerializer; + new (): XMLSerializer; +} + +interface PerformanceMeasure extends PerformanceEntry { +} +declare var PerformanceMeasure: { + prototype: PerformanceMeasure; + new (): PerformanceMeasure; +} + +interface SVGGradientElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGExternalResourcesRequired, SVGURIReference { + spreadMethod: SVGAnimatedEnumeration; + gradientTransform: SVGAnimatedTransformList; + gradientUnits: SVGAnimatedEnumeration; + SVG_SPREADMETHOD_REFLECT: number; + SVG_SPREADMETHOD_PAD: number; + SVG_SPREADMETHOD_UNKNOWN: number; + SVG_SPREADMETHOD_REPEAT: number; +} +declare var SVGGradientElement: { + prototype: SVGGradientElement; + new (): SVGGradientElement; + SVG_SPREADMETHOD_REFLECT: number; + SVG_SPREADMETHOD_PAD: number; + SVG_SPREADMETHOD_UNKNOWN: number; + SVG_SPREADMETHOD_REPEAT: number; +} + +interface NodeFilter { + acceptNode(n: Node): number; + SHOW_ENTITY_REFERENCE: number; + SHOW_NOTATION: number; + SHOW_ENTITY: number; + SHOW_DOCUMENT: number; + SHOW_PROCESSING_INSTRUCTION: number; + FILTER_REJECT: number; + SHOW_CDATA_SECTION: number; + FILTER_ACCEPT: number; + SHOW_ALL: number; + SHOW_DOCUMENT_TYPE: number; + SHOW_TEXT: number; + SHOW_ELEMENT: number; + SHOW_COMMENT: number; + FILTER_SKIP: number; + SHOW_ATTRIBUTE: number; + SHOW_DOCUMENT_FRAGMENT: number; +} +declare var NodeFilter: { + prototype: NodeFilter; + new (): NodeFilter; + SHOW_ENTITY_REFERENCE: number; + SHOW_NOTATION: number; + SHOW_ENTITY: number; + SHOW_DOCUMENT: number; + SHOW_PROCESSING_INSTRUCTION: number; + FILTER_REJECT: number; + SHOW_CDATA_SECTION: number; + FILTER_ACCEPT: number; + SHOW_ALL: number; + SHOW_DOCUMENT_TYPE: number; + SHOW_TEXT: number; + SHOW_ELEMENT: number; + SHOW_COMMENT: number; + FILTER_SKIP: number; + SHOW_ATTRIBUTE: number; + SHOW_DOCUMENT_FRAGMENT: number; +} + +interface SVGNumberList { + numberOfItems: number; + replaceItem(newItem: SVGNumber, index: number): SVGNumber; + getItem(index: number): SVGNumber; + clear(): void; + appendItem(newItem: SVGNumber): SVGNumber; + initialize(newItem: SVGNumber): SVGNumber; + removeItem(index: number): SVGNumber; + insertItemBefore(newItem: SVGNumber, index: number): SVGNumber; +} +declare var SVGNumberList: { + prototype: SVGNumberList; + new (): SVGNumberList; +} + +interface MediaError { + code: number; + MEDIA_ERR_ABORTED: number; + MEDIA_ERR_NETWORK: number; + MEDIA_ERR_SRC_NOT_SUPPORTED: number; + MEDIA_ERR_DECODE: number; +} +declare var MediaError: { + prototype: MediaError; + new (): MediaError; + MEDIA_ERR_ABORTED: number; + MEDIA_ERR_NETWORK: number; + MEDIA_ERR_SRC_NOT_SUPPORTED: number; + MEDIA_ERR_DECODE: number; +} + +interface HTMLFieldSetElement extends HTMLElement { + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; +} +declare var HTMLFieldSetElement: { + prototype: HTMLFieldSetElement; + new (): HTMLFieldSetElement; +} + +interface HTMLBGSoundElement extends HTMLElement { + /** + * Sets or gets the value indicating how the volume of the background sound is divided between the left speaker and the right speaker. + */ + balance: any; + /** + * Sets or gets the volume setting for the sound. + */ + volume: any; + /** + * Sets or gets the URL of a sound to play. + */ + src: string; + /** + * Sets or retrieves the number of times a sound or video clip will loop when activated. + */ + loop: number; +} +declare var HTMLBGSoundElement: { + prototype: HTMLBGSoundElement; + new (): HTMLBGSoundElement; +} + +interface HTMLElement extends Element, ElementCSSInlineStyle, MSEventAttachmentTarget, MSNodeExtensions { + onmouseleave: (ev: MouseEvent) => any; + addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onbeforecut: (ev: DragEvent) => any; + addEventListener(type: "beforecut", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onkeydown: (ev: KeyboardEvent) => any; + addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + onmove: (ev: MSEventObj) => any; + addEventListener(type: "move", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onkeyup: (ev: KeyboardEvent) => any; + addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + onreset: (ev: Event) => any; + addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void; + onhelp: (ev: Event) => any; + addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void; + ondragleave: (ev: DragEvent) => any; + addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + className: string; + onfocusin: (ev: FocusEvent) => any; + addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onseeked: (ev: Event) => any; + addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void; + recordNumber: any; + title: string; + parentTextEdit: Element; + outerHTML: string; + ondurationchange: (ev: Event) => any; + addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void; + offsetHeight: number; + all: HTMLCollection; + onblur: (ev: FocusEvent) => any; + addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + dir: string; + onemptied: (ev: Event) => any; + addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void; + onseeking: (ev: Event) => any; + addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void; + oncanplay: (ev: Event) => any; + addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void; + ondeactivate: (ev: UIEvent) => any; + addEventListener(type: "deactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + ondatasetchanged: (ev: MSEventObj) => any; + addEventListener(type: "datasetchanged", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onrowsdelete: (ev: MSEventObj) => any; + addEventListener(type: "rowsdelete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + sourceIndex: number; + onloadstart: (ev: Event) => any; + addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void; + onlosecapture: (ev: MSEventObj) => any; + addEventListener(type: "losecapture", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + ondragenter: (ev: DragEvent) => any; + addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + oncontrolselect: (ev: MSEventObj) => any; + addEventListener(type: "controlselect", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onsubmit: (ev: Event) => any; + addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void; + behaviorUrns: MSBehaviorUrnsCollection; + scopeName: string; + onchange: (ev: Event) => any; + addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void; + id: string; + onlayoutcomplete: (ev: MSEventObj) => any; + addEventListener(type: "layoutcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + uniqueID: string; + onbeforeactivate: (ev: UIEvent) => any; + addEventListener(type: "beforeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + oncanplaythrough: (ev: Event) => any; + addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void; + onbeforeupdate: (ev: MSEventObj) => any; + addEventListener(type: "beforeupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onfilterchange: (ev: MSEventObj) => any; + addEventListener(type: "filterchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + offsetParent: Element; + ondatasetcomplete: (ev: MSEventObj) => any; + addEventListener(type: "datasetcomplete", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onsuspend: (ev: Event) => any; + addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void; + readyState: any; + onmouseenter: (ev: MouseEvent) => any; + addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + innerText: string; + onerrorupdate: (ev: MSEventObj) => any; + addEventListener(type: "errorupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onmouseout: (ev: MouseEvent) => any; + addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + parentElement: HTMLElement; + onmousewheel: (ev: MouseWheelEvent) => any; + addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void; + onvolumechange: (ev: Event) => any; + addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; + oncellchange: (ev: MSEventObj) => any; + addEventListener(type: "cellchange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onrowexit: (ev: MSEventObj) => any; + addEventListener(type: "rowexit", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onrowsinserted: (ev: MSEventObj) => any; + addEventListener(type: "rowsinserted", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onpropertychange: (ev: MSEventObj) => any; + addEventListener(type: "propertychange", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + filters: Object; + children: HTMLCollection; + ondragend: (ev: DragEvent) => any; + addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onbeforepaste: (ev: DragEvent) => any; + addEventListener(type: "beforepaste", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + ondragover: (ev: DragEvent) => any; + addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + offsetTop: number; + onmouseup: (ev: MouseEvent) => any; + addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + ondragstart: (ev: DragEvent) => any; + addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onbeforecopy: (ev: DragEvent) => any; + addEventListener(type: "beforecopy", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + ondrag: (ev: DragEvent) => any; + addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + innerHTML: string; + onmouseover: (ev: MouseEvent) => any; + addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + lang: string; + uniqueNumber: number; + onpause: (ev: Event) => any; + addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void; + tagUrn: string; + onmousedown: (ev: MouseEvent) => any; + addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onclick: (ev: MouseEvent) => any; + addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onwaiting: (ev: Event) => any; + addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; + onresizestart: (ev: MSEventObj) => any; + addEventListener(type: "resizestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + offsetLeft: number; + isTextEdit: boolean; + isDisabled: boolean; + onpaste: (ev: DragEvent) => any; + addEventListener(type: "paste", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + canHaveHTML: boolean; + onmoveend: (ev: MSEventObj) => any; + addEventListener(type: "moveend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + language: string; + onstalled: (ev: Event) => any; + addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void; + onmousemove: (ev: MouseEvent) => any; + addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + style: MSStyleCSSProperties; + isContentEditable: boolean; + onbeforeeditfocus: (ev: MSEventObj) => any; + addEventListener(type: "beforeeditfocus", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onratechange: (ev: Event) => any; + addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void; + contentEditable: string; + tabIndex: number; + document: Document; + onprogress: (ev: any) => any; + addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; + ondblclick: (ev: MouseEvent) => any; + addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + oncontextmenu: (ev: MouseEvent) => any; + addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; + onloadedmetadata: (ev: Event) => any; + addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void; + onafterupdate: (ev: MSEventObj) => any; + addEventListener(type: "afterupdate", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onerror: (ev: Event) => any; + addEventListener(type: "error", listener: (ev: Event) => any, useCapture?: boolean): void; + onplay: (ev: Event) => any; + addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void; + onresizeend: (ev: MSEventObj) => any; + addEventListener(type: "resizeend", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onplaying: (ev: Event) => any; + addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void; + isMultiLine: boolean; + onfocusout: (ev: FocusEvent) => any; + addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + onabort: (ev: UIEvent) => any; + addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + ondataavailable: (ev: MSEventObj) => any; + addEventListener(type: "dataavailable", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + hideFocus: boolean; + onreadystatechange: (ev: Event) => any; + addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; + onkeypress: (ev: KeyboardEvent) => any; + addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; + onloadeddata: (ev: Event) => any; + addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void; + onbeforedeactivate: (ev: UIEvent) => any; + addEventListener(type: "beforedeactivate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + outerText: string; + disabled: boolean; + onactivate: (ev: UIEvent) => any; + addEventListener(type: "activate", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + accessKey: string; + onmovestart: (ev: MSEventObj) => any; + addEventListener(type: "movestart", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onselectstart: (ev: Event) => any; + addEventListener(type: "selectstart", listener: (ev: Event) => any, useCapture?: boolean): void; + onfocus: (ev: FocusEvent) => any; + addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; + ontimeupdate: (ev: Event) => any; + addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void; + onresize: (ev: UIEvent) => any; + addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + oncut: (ev: DragEvent) => any; + addEventListener(type: "cut", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onselect: (ev: UIEvent) => any; + addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + ondrop: (ev: DragEvent) => any; + addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + offsetWidth: number; + oncopy: (ev: DragEvent) => any; + addEventListener(type: "copy", listener: (ev: DragEvent) => any, useCapture?: boolean): void; + onended: (ev: Event) => any; + addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void; + onscroll: (ev: UIEvent) => any; + addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void; + onrowenter: (ev: MSEventObj) => any; + addEventListener(type: "rowenter", listener: (ev: MSEventObj) => any, useCapture?: boolean): void; + onload: (ev: Event) => any; + addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; + canHaveChildren: boolean; + oninput: (ev: Event) => any; + addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void; + dragDrop(): boolean; + scrollIntoView(top?: boolean): void; + addFilter(filter: Object): void; + setCapture(containerCapture?: boolean): void; + focus(): void; + getAdjacentText(where: string): string; + insertAdjacentText(where: string, text: string): void; + getElementsByClassName(classNames: string): NodeList; + setActive(): void; + removeFilter(filter: Object): void; + blur(): void; + clearAttributes(): void; + releaseCapture(): void; + createControlRange(): ControlRangeCollection; + removeBehavior(cookie: number): boolean; + contains(child: HTMLElement): boolean; + click(): void; + insertAdjacentElement(position: string, insertedElement: Element): Element; + mergeAttributes(source: HTMLElement, preserveIdentity?: boolean): void; + replaceAdjacentText(where: string, newText: string): string; + applyElement(apply: Element, where?: string): Element; + addBehavior(bstrUrl: string, factory?: any): number; + insertAdjacentHTML(where: string, html: string): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var HTMLElement: { + prototype: HTMLElement; + new (): HTMLElement; +} + +interface Comment extends CharacterData { + text: string; +} +declare var Comment: { + prototype: Comment; + new (): Comment; +} + +interface PerformanceResourceTiming extends PerformanceEntry { + redirectStart: number; + redirectEnd: number; + domainLookupEnd: number; + responseStart: number; + domainLookupStart: number; + fetchStart: number; + requestStart: number; + connectEnd: number; + connectStart: number; + initiatorType: string; + responseEnd: number; +} +declare var PerformanceResourceTiming: { + prototype: PerformanceResourceTiming; + new (): PerformanceResourceTiming; +} + +interface CanvasPattern { +} +declare var CanvasPattern: { + prototype: CanvasPattern; + new (): CanvasPattern; +} + +interface HTMLHRElement extends HTMLElement, DOML2DeprecatedColorProperty, DOML2DeprecatedSizeProperty { + /** + * Sets or retrieves the width of the object. + */ + width: number; + /** + * Sets or retrieves how the object is aligned with adjacent text. + */ + align: string; + /** + * Sets or retrieves whether the horizontal rule is drawn with 3-D shading. + */ + noShade: boolean; +} +declare var HTMLHRElement: { + prototype: HTMLHRElement; + new (): HTMLHRElement; +} + +interface HTMLObjectElement extends HTMLElement, GetSVGDocument, DOML2DeprecatedMarginStyle, DOML2DeprecatedBorderStyle, DOML2DeprecatedAlignmentStyle, MSDataBindingExtensions, MSDataBindingRecordSetExtensions { + /** + * Sets or retrieves the width of the object. + */ + width: string; + /** + * Sets or retrieves the Internet media type for the code associated with the object. + */ + codeType: string; + /** + * Retrieves the contained object. + */ + object: Object; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves the URL of the file containing the compiled Java class. + */ + code: string; + /** + * Sets or retrieves a character string that can be used to implement your own archive functionality for the object. + */ + archive: string; + /** + * Sets or retrieves a message to be displayed while an object is loading. + */ + standby: string; + /** + * Sets or retrieves a text alternative to the graphic. + */ + alt: string; + /** + * Sets or retrieves the class identifier for the object. + */ + classid: string; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Sets or retrieves the URL, often with a bookmark extension (#name), to use as a client-side image map. + */ + useMap: string; + /** + * Sets or retrieves the URL that references the data of the object. + */ + data: string; + /** + * Sets or retrieves the height of the object. + */ + height: string; + /** + * Retrieves the document object of the page or frame. + */ + contentDocument: Document; + /** + * Gets or sets the optional alternative HTML script to execute if the object fails to load. + */ + altHtml: string; + /** + * Sets or retrieves the URL of the component. + */ + codeBase: string; + declare: boolean; + /** + * Sets or retrieves the MIME type of the object. + */ + type: string; + /** + * Retrieves a string of the URL where the object tag can be found. This is often the href of the document that the object is in, or the value set by a base element. + */ + BaseHref: string; +} +declare var HTMLObjectElement: { + prototype: HTMLObjectElement; + new (): HTMLObjectElement; +} + +interface HTMLEmbedElement extends HTMLElement, GetSVGDocument { + /** + * Sets or retrieves the width of the object. + */ + width: string; + /** + * Retrieves the palette used for the embedded document. + */ + palette: string; + /** + * Sets or retrieves a URL to be loaded by the object. + */ + src: string; + /** + * Sets or retrieves the name of the object. + */ + name: string; + /** + * Retrieves the URL of the plug-in used to view an embedded document. + */ + pluginspage: string; + /** + * Sets or retrieves the height of the object. + */ + height: string; + /** + * Sets or retrieves the height and width units of the embed object. + */ + units: string; +} +declare var HTMLEmbedElement: { + prototype: HTMLEmbedElement; + new (): HTMLEmbedElement; +} + +interface StorageEvent extends Event { + oldValue: any; + newValue: any; + url: string; + storageArea: Storage; + key: string; + initStorageEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, keyArg: string, oldValueArg: any, newValueArg: any, urlArg: string, storageAreaArg: Storage): void; +} +declare var StorageEvent: { + prototype: StorageEvent; + new (): StorageEvent; +} + +interface CharacterData extends Node { + length: number; + data: string; + deleteData(offset: number, count: number): void; + replaceData(offset: number, count: number, arg: string): void; + appendData(arg: string): void; + insertData(offset: number, arg: string): void; + substringData(offset: number, count: number): string; +} +declare var CharacterData: { + prototype: CharacterData; + new (): CharacterData; +} + +interface HTMLOptGroupElement extends HTMLElement, MSDataBindingExtensions { + /** + * Sets or retrieves the ordinal position of an option in a list box. + */ + index: number; + /** + * Sets or retrieves the status of an option. + */ + defaultSelected: boolean; + /** + * Sets or retrieves the text string specified by the option tag. + */ + text: string; + /** + * Sets or retrieves the value which is returned to the server when the form control is submitted. + */ + value: string; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves a value that you can use to implement your own label functionality for the object. + */ + label: string; + /** + * Sets or retrieves whether the option in the list box is the default item. + */ + selected: boolean; +} +declare var HTMLOptGroupElement: { + prototype: HTMLOptGroupElement; + new (): HTMLOptGroupElement; +} + +interface HTMLIsIndexElement extends HTMLElement { + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; + /** + * Sets or retrieves the URL to which the form content is sent for processing. + */ + action: string; + prompt: string; +} +declare var HTMLIsIndexElement: { + prototype: HTMLIsIndexElement; + new (): HTMLIsIndexElement; +} + +interface SVGPathSegLinetoRel extends SVGPathSeg { + y: number; + x: number; +} +declare var SVGPathSegLinetoRel: { + prototype: SVGPathSegLinetoRel; + new (): SVGPathSegLinetoRel; +} + +interface DOMException { + code: number; + message: string; + toString(): string; + HIERARCHY_REQUEST_ERR: number; + NO_MODIFICATION_ALLOWED_ERR: number; + INVALID_MODIFICATION_ERR: number; + NAMESPACE_ERR: number; + INVALID_CHARACTER_ERR: number; + TYPE_MISMATCH_ERR: number; + ABORT_ERR: number; + INVALID_STATE_ERR: number; + SECURITY_ERR: number; + NETWORK_ERR: number; + WRONG_DOCUMENT_ERR: number; + QUOTA_EXCEEDED_ERR: number; + INDEX_SIZE_ERR: number; + DOMSTRING_SIZE_ERR: number; + SYNTAX_ERR: number; + SERIALIZE_ERR: number; + VALIDATION_ERR: number; + NOT_FOUND_ERR: number; + URL_MISMATCH_ERR: number; + PARSE_ERR: number; + NO_DATA_ALLOWED_ERR: number; + NOT_SUPPORTED_ERR: number; + INVALID_ACCESS_ERR: number; + INUSE_ATTRIBUTE_ERR: number; +} +declare var DOMException: { + prototype: DOMException; + new (): DOMException; + HIERARCHY_REQUEST_ERR: number; + NO_MODIFICATION_ALLOWED_ERR: number; + INVALID_MODIFICATION_ERR: number; + NAMESPACE_ERR: number; + INVALID_CHARACTER_ERR: number; + TYPE_MISMATCH_ERR: number; + ABORT_ERR: number; + INVALID_STATE_ERR: number; + SECURITY_ERR: number; + NETWORK_ERR: number; + WRONG_DOCUMENT_ERR: number; + QUOTA_EXCEEDED_ERR: number; + INDEX_SIZE_ERR: number; + DOMSTRING_SIZE_ERR: number; + SYNTAX_ERR: number; + SERIALIZE_ERR: number; + VALIDATION_ERR: number; + NOT_FOUND_ERR: number; + URL_MISMATCH_ERR: number; + PARSE_ERR: number; + NO_DATA_ALLOWED_ERR: number; + NOT_SUPPORTED_ERR: number; + INVALID_ACCESS_ERR: number; + INUSE_ATTRIBUTE_ERR: number; +} + +interface SVGAnimatedBoolean { + animVal: boolean; + baseVal: boolean; +} +declare var SVGAnimatedBoolean: { + prototype: SVGAnimatedBoolean; + new (): SVGAnimatedBoolean; +} + +interface MSCompatibleInfoCollection { + length: number; + item(index: number): MSCompatibleInfo; +} +declare var MSCompatibleInfoCollection: { + prototype: MSCompatibleInfoCollection; + new (): MSCompatibleInfoCollection; +} + +interface SVGSwitchElement extends SVGElement, SVGStylable, SVGTransformable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { +} +declare var SVGSwitchElement: { + prototype: SVGSwitchElement; + new (): SVGSwitchElement; +} + +interface SVGPreserveAspectRatio { + align: number; + meetOrSlice: number; + SVG_PRESERVEASPECTRATIO_NONE: number; + SVG_PRESERVEASPECTRATIO_XMINYMID: number; + SVG_PRESERVEASPECTRATIO_XMAXYMIN: number; + SVG_PRESERVEASPECTRATIO_XMINYMAX: number; + SVG_PRESERVEASPECTRATIO_XMAXYMAX: number; + SVG_MEETORSLICE_UNKNOWN: number; + SVG_PRESERVEASPECTRATIO_XMAXYMID: number; + SVG_PRESERVEASPECTRATIO_XMIDYMAX: number; + SVG_PRESERVEASPECTRATIO_XMINYMIN: number; + SVG_MEETORSLICE_MEET: number; + SVG_PRESERVEASPECTRATIO_XMIDYMID: number; + SVG_PRESERVEASPECTRATIO_XMIDYMIN: number; + SVG_MEETORSLICE_SLICE: number; + SVG_PRESERVEASPECTRATIO_UNKNOWN: number; +} +declare var SVGPreserveAspectRatio: { + prototype: SVGPreserveAspectRatio; + new (): SVGPreserveAspectRatio; + SVG_PRESERVEASPECTRATIO_NONE: number; + SVG_PRESERVEASPECTRATIO_XMINYMID: number; + SVG_PRESERVEASPECTRATIO_XMAXYMIN: number; + SVG_PRESERVEASPECTRATIO_XMINYMAX: number; + SVG_PRESERVEASPECTRATIO_XMAXYMAX: number; + SVG_MEETORSLICE_UNKNOWN: number; + SVG_PRESERVEASPECTRATIO_XMAXYMID: number; + SVG_PRESERVEASPECTRATIO_XMIDYMAX: number; + SVG_PRESERVEASPECTRATIO_XMINYMIN: number; + SVG_MEETORSLICE_MEET: number; + SVG_PRESERVEASPECTRATIO_XMIDYMID: number; + SVG_PRESERVEASPECTRATIO_XMIDYMIN: number; + SVG_MEETORSLICE_SLICE: number; + SVG_PRESERVEASPECTRATIO_UNKNOWN: number; +} + +interface Attr extends Node { + expando: boolean; + specified: boolean; + ownerElement: Element; + value: string; + name: string; +} +declare var Attr: { + prototype: Attr; + new (): Attr; +} + +interface PerformanceNavigation { + redirectCount: number; + type: number; + toJSON(): any; + TYPE_RELOAD: number; + TYPE_RESERVED: number; + TYPE_BACK_FORWARD: number; + TYPE_NAVIGATE: number; +} +declare var PerformanceNavigation: { + prototype: PerformanceNavigation; + new (): PerformanceNavigation; + TYPE_RELOAD: number; + TYPE_RESERVED: number; + TYPE_BACK_FORWARD: number; + TYPE_NAVIGATE: number; +} + +interface SVGStopElement extends SVGElement, SVGStylable { + offset: SVGAnimatedNumber; +} +declare var SVGStopElement: { + prototype: SVGStopElement; + new (): SVGStopElement; +} + +interface PositionCallback { + (position: Position): void; +} + +interface SVGSymbolElement extends SVGElement, SVGStylable, SVGLangSpace, SVGFitToViewBox, SVGExternalResourcesRequired { +} +declare var SVGSymbolElement: { + prototype: SVGSymbolElement; + new (): SVGSymbolElement; +} + +interface SVGElementInstanceList { + length: number; + item(index: number): SVGElementInstance; +} +declare var SVGElementInstanceList: { + prototype: SVGElementInstanceList; + new (): SVGElementInstanceList; +} + +interface CSSRuleList { + length: number; + item(index: number): CSSRule; + [index: number]: CSSRule; +} +declare var CSSRuleList: { + prototype: CSSRuleList; + new (): CSSRuleList; +} + +interface MSDataBindingRecordSetExtensions { + recordset: Object; + namedRecordset(dataMember: string, hierarchy?: any): Object; +} + +interface LinkStyle { + styleSheet: StyleSheet; + sheet: StyleSheet; +} + +interface HTMLVideoElement extends HTMLMediaElement { + /** + * Gets or sets the width of the video element. + */ + width: number; + /** + * Gets the intrinsic width of a video in CSS pixels, or zero if the dimensions are not known. + */ + videoWidth: number; + /** + * Gets the intrinsic height of a video in CSS pixels, or zero if the dimensions are not known. + */ + videoHeight: number; + /** + * Gets or sets the height of the video element. + */ + height: number; + /** + * Gets or sets a URL of an image to display, for example, like a movie poster. This can be a still frame from the video, or another image if no video data is available. + */ + poster: string; +} +declare var HTMLVideoElement: { + prototype: HTMLVideoElement; + new (): HTMLVideoElement; +} + +interface ClientRectList { + length: number; + item(index: number): ClientRect; + [index: number]: ClientRect; +} +declare var ClientRectList: { + prototype: ClientRectList; + new (): ClientRectList; +} + +interface SVGMaskElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGTests, SVGExternalResourcesRequired { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + maskUnits: SVGAnimatedEnumeration; + maskContentUnits: SVGAnimatedEnumeration; + x: SVGAnimatedLength; + height: SVGAnimatedLength; +} +declare var SVGMaskElement: { + prototype: SVGMaskElement; + new (): SVGMaskElement; +} + +interface External { +} +declare var External: { + prototype: External; + new (): External; +} + +declare var Audio: { new (src?: string): HTMLAudioElement; }; +declare var Option: { new (text?: string, value?: string, defaultSelected?: boolean, selected?: boolean): HTMLOptionElement; }; +declare var Image: { new (width?: number, height?: number): HTMLImageElement; }; + +declare var ondragend: (ev: DragEvent) => any; +declare function addEventListener(type: "dragend", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var onkeydown: (ev: KeyboardEvent) => any; +declare function addEventListener(type: "keydown", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; +declare var ondragover: (ev: DragEvent) => any; +declare function addEventListener(type: "dragover", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var onkeyup: (ev: KeyboardEvent) => any; +declare function addEventListener(type: "keyup", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; +declare var onreset: (ev: Event) => any; +declare function addEventListener(type: "reset", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onmouseup: (ev: MouseEvent) => any; +declare function addEventListener(type: "mouseup", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var ondragstart: (ev: DragEvent) => any; +declare function addEventListener(type: "dragstart", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var ondrag: (ev: DragEvent) => any; +declare function addEventListener(type: "drag", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var screenX: number; +declare var onmouseover: (ev: MouseEvent) => any; +declare function addEventListener(type: "mouseover", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var ondragleave: (ev: DragEvent) => any; +declare function addEventListener(type: "dragleave", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var history: History; +declare var pageXOffset: number; +declare var name: string; +declare var onafterprint: (ev: Event) => any; +declare function addEventListener(type: "afterprint", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onpause: (ev: Event) => any; +declare function addEventListener(type: "pause", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onbeforeprint: (ev: Event) => any; +declare function addEventListener(type: "beforeprint", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var top: Window; +declare var onmousedown: (ev: MouseEvent) => any; +declare function addEventListener(type: "mousedown", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var onseeked: (ev: Event) => any; +declare function addEventListener(type: "seeked", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var opener: Window; +declare var onclick: (ev: MouseEvent) => any; +declare function addEventListener(type: "click", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var innerHeight: number; +declare var onwaiting: (ev: Event) => any; +declare function addEventListener(type: "waiting", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var ononline: (ev: Event) => any; +declare function addEventListener(type: "online", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var ondurationchange: (ev: Event) => any; +declare function addEventListener(type: "durationchange", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var frames: Window; +declare var onblur: (ev: FocusEvent) => any; +declare function addEventListener(type: "blur", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; +declare var onemptied: (ev: Event) => any; +declare function addEventListener(type: "emptied", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onseeking: (ev: Event) => any; +declare function addEventListener(type: "seeking", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var oncanplay: (ev: Event) => any; +declare function addEventListener(type: "canplay", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var outerWidth: number; +declare var onstalled: (ev: Event) => any; +declare function addEventListener(type: "stalled", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onmousemove: (ev: MouseEvent) => any; +declare function addEventListener(type: "mousemove", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var innerWidth: number; +declare var onoffline: (ev: Event) => any; +declare function addEventListener(type: "offline", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var length: number; +declare var screen: Screen; +declare var onbeforeunload: (ev: BeforeUnloadEvent) => any; +declare function addEventListener(type: "beforeunload", listener: (ev: BeforeUnloadEvent) => any, useCapture?: boolean): void; +declare var onratechange: (ev: Event) => any; +declare function addEventListener(type: "ratechange", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onstorage: (ev: StorageEvent) => any; +declare function addEventListener(type: "storage", listener: (ev: StorageEvent) => any, useCapture?: boolean): void; +declare var onloadstart: (ev: Event) => any; +declare function addEventListener(type: "loadstart", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var ondragenter: (ev: DragEvent) => any; +declare function addEventListener(type: "dragenter", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var onsubmit: (ev: Event) => any; +declare function addEventListener(type: "submit", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var self: Window; +declare var document: Document; +declare var onprogress: (ev: any) => any; +declare function addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; +declare var ondblclick: (ev: MouseEvent) => any; +declare function addEventListener(type: "dblclick", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var pageYOffset: number; +declare var oncontextmenu: (ev: MouseEvent) => any; +declare function addEventListener(type: "contextmenu", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var onchange: (ev: Event) => any; +declare function addEventListener(type: "change", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onloadedmetadata: (ev: Event) => any; +declare function addEventListener(type: "loadedmetadata", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onplay: (ev: Event) => any; +declare function addEventListener(type: "play", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onerror: ErrorEventHandler; +declare var onplaying: (ev: Event) => any; +declare function addEventListener(type: "playing", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var parent: Window; +declare var location: Location; +declare var oncanplaythrough: (ev: Event) => any; +declare function addEventListener(type: "canplaythrough", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onabort: (ev: UIEvent) => any; +declare function addEventListener(type: "abort", listener: (ev: UIEvent) => any, useCapture?: boolean): void; +declare var onreadystatechange: (ev: Event) => any; +declare function addEventListener(type: "readystatechange", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var outerHeight: number; +declare var onkeypress: (ev: KeyboardEvent) => any; +declare function addEventListener(type: "keypress", listener: (ev: KeyboardEvent) => any, useCapture?: boolean): void; +declare var frameElement: Element; +declare var onloadeddata: (ev: Event) => any; +declare function addEventListener(type: "loadeddata", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onsuspend: (ev: Event) => any; +declare function addEventListener(type: "suspend", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var window: Window; +declare var onfocus: (ev: FocusEvent) => any; +declare function addEventListener(type: "focus", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; +declare var onmessage: (ev: MessageEvent) => any; +declare function addEventListener(type: "message", listener: (ev: MessageEvent) => any, useCapture?: boolean): void; +declare var ontimeupdate: (ev: Event) => any; +declare function addEventListener(type: "timeupdate", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onresize: (ev: UIEvent) => any; +declare function addEventListener(type: "resize", listener: (ev: UIEvent) => any, useCapture?: boolean): void; +declare var onselect: (ev: UIEvent) => any; +declare function addEventListener(type: "select", listener: (ev: UIEvent) => any, useCapture?: boolean): void; +declare var navigator: Navigator; +declare var styleMedia: StyleMedia; +declare var ondrop: (ev: DragEvent) => any; +declare function addEventListener(type: "drop", listener: (ev: DragEvent) => any, useCapture?: boolean): void; +declare var onmouseout: (ev: MouseEvent) => any; +declare function addEventListener(type: "mouseout", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var onended: (ev: Event) => any; +declare function addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onhashchange: (ev: Event) => any; +declare function addEventListener(type: "hashchange", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onunload: (ev: Event) => any; +declare function addEventListener(type: "unload", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onscroll: (ev: UIEvent) => any; +declare function addEventListener(type: "scroll", listener: (ev: UIEvent) => any, useCapture?: boolean): void; +declare var screenY: number; +declare var onmousewheel: (ev: MouseWheelEvent) => any; +declare function addEventListener(type: "mousewheel", listener: (ev: MouseWheelEvent) => any, useCapture?: boolean): void; +declare var onload: (ev: Event) => any; +declare function addEventListener(type: "load", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var onvolumechange: (ev: Event) => any; +declare function addEventListener(type: "volumechange", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var oninput: (ev: Event) => any; +declare function addEventListener(type: "input", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var performance: Performance; +declare function alert(message?: any): void; +declare function scroll(x?: number, y?: number): void; +declare function focus(): void; +declare function scrollTo(x?: number, y?: number): void; +declare function print(): void; +declare function prompt(message?: string, defaul?: string): string; +declare function toString(): string; +declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window; +declare function scrollBy(x?: number, y?: number): void; +declare function confirm(message?: string): boolean; +declare function close(): void; +declare function postMessage(message: any, targetOrigin: string, ports?: any): void; +declare function showModalDialog(url?: string, argument?: any, options?: any): any; +declare function blur(): void; +declare function getSelection(): Selection; +declare function getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration; +declare function addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +declare function removeEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +declare function dispatchEvent(evt: Event): boolean; +declare function attachEvent(event: string, listener: EventListener): boolean; +declare function detachEvent(event: string, listener: EventListener): void; +declare var localStorage: Storage; +declare var status: string; +declare var onmouseleave: (ev: MouseEvent) => any; +declare function addEventListener(type: "mouseleave", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var screenLeft: number; +declare var offscreenBuffering: any; +declare var maxConnectionsPerServer: number; +declare var onmouseenter: (ev: MouseEvent) => any; +declare function addEventListener(type: "mouseenter", listener: (ev: MouseEvent) => any, useCapture?: boolean): void; +declare var clipboardData: DataTransfer; +declare var defaultStatus: string; +declare var clientInformation: Navigator; +declare var closed: boolean; +declare var onhelp: (ev: Event) => any; +declare function addEventListener(type: "help", listener: (ev: Event) => any, useCapture?: boolean): void; +declare var external: External; +declare var event: MSEventObj; +declare var onfocusout: (ev: FocusEvent) => any; +declare function addEventListener(type: "focusout", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; +declare var screenTop: number; +declare var onfocusin: (ev: FocusEvent) => any; +declare function addEventListener(type: "focusin", listener: (ev: FocusEvent) => any, useCapture?: boolean): void; +declare function showModelessDialog(url?: string, argument?: any, options?: any): Window; +declare function navigate(url: string): void; +declare function resizeBy(x?: number, y?: number): void; +declare function item(index: any): any; +declare function resizeTo(x?: number, y?: number): void; +declare function createPopup(arguments?: any): MSPopupWindow; +declare function toStaticHTML(html: string): string; +declare function execScript(code: string, language?: string): any; +declare function msWriteProfilerMark(profilerMarkName: string): void; +declare function moveTo(x?: number, y?: number): void; +declare function moveBy(x?: number, y?: number): void; +declare function showHelp(url: string, helpArg?: any, features?: string): void; +declare var sessionStorage: Storage; +declare function clearTimeout(handle: number): void; +declare function setTimeout(handler: any, timeout?: any, ...args: any[]): number; +declare function clearInterval(handle: number): void; +declare function setInterval(handler: any, timeout?: any, ...args: any[]): number; + + +///////////////////////////// +/// IE10 DOM APIs +///////////////////////////// + + + +interface ObjectURLOptions { + oneTimeOnly?: boolean; +} + +interface HTMLBodyElement { + onpopstate: (ev: PopStateEvent) => any; + addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void; +} + +interface MSGestureEvent extends UIEvent { + offsetY: number; + translationY: number; + velocityExpansion: number; + velocityY: number; + velocityAngular: number; + translationX: number; + velocityX: number; + hwTimestamp: number; + offsetX: number; + screenX: number; + rotation: number; + expansion: number; + clientY: number; + screenY: number; + scale: number; + gestureObject: any; + clientX: number; + initGestureEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, offsetXArg: number, offsetYArg: number, translationXArg: number, translationYArg: number, scaleArg: number, expansionArg: number, rotationArg: number, velocityXArg: number, velocityYArg: number, velocityExpansionArg: number, velocityAngularArg: number, hwTimestampArg: number): void; + MSGESTURE_FLAG_BEGIN: number; + MSGESTURE_FLAG_END: number; + MSGESTURE_FLAG_CANCEL: number; + MSGESTURE_FLAG_INERTIA: number; + MSGESTURE_FLAG_NONE: number; +} +declare var MSGestureEvent: { + prototype: MSGestureEvent; + new (): MSGestureEvent; + MSGESTURE_FLAG_BEGIN: number; + MSGESTURE_FLAG_END: number; + MSGESTURE_FLAG_CANCEL: number; + MSGESTURE_FLAG_INERTIA: number; + MSGESTURE_FLAG_NONE: number; +} + +interface HTMLAnchorElement { + /** + * Retrieves or sets the text of the object as a string. + */ + text: string; +} + +interface HTMLInputElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Returns a FileList object on a file type input object. + */ + files: FileList; + /** + * Defines the maximum acceptable value for an input element with type="number".When used with the min and step attributes, lets you control the range and increment (such as only even numbers) that the user can enter into an input field. + */ + max: string; + /** + * Overrides the target attribute on a form element. + */ + formTarget: string; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Defines an increment or jump between values that you want to allow the user to enter. When used with the max and min attributes, lets you control the range and increment (for example, allow only even numbers) that the user can enter into an input field. + */ + step: string; + /** + * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing. + */ + autofocus: boolean; + /** + * When present, marks an element that can't be submitted without a value. + */ + required: boolean; + /** + * Used to override the encoding (formEnctype attribute) specified on the form element. + */ + formEnctype: string; + /** + * Returns the input field value as a number. + */ + valueAsNumber: number; + /** + * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. + */ + placeholder: string; + /** + * Overrides the submit method attribute previously specified on a form element. + */ + formMethod: string; + /** + * Specifies the ID of a pre-defined datalist of options for an input element. + */ + list: HTMLElement; + /** + * Specifies whether autocomplete is applied to an editable text field. + */ + autocomplete: string; + /** + * Defines the minimum acceptable value for an input element with type="number". When used with the max and step attributes, lets you control the range and increment (such as even numbers only) that the user can enter into an input field. + */ + min: string; + /** + * Overrides the action attribute (where the data on a form is sent) on the parent form element. + */ + formAction: string; + /** + * Gets or sets a string containing a regular expression that the user's input must match. + */ + pattern: string; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option. + */ + formNoValidate: string; + /** + * Sets or retrieves the Boolean value indicating whether multiple items can be selected from a list. + */ + multiple: boolean; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Decrements a range input control's value by the value given by the Step attribute. If the optional parameter is used, it will decrement the input control's step value multiplied by the parameter's value. + * @param n Value to decrement the value by. + */ + stepDown(n?: number): void; + /** + * Increments a range input control's value by the value given by the Step attribute. If the optional parameter is used, will increment the input control's value by that value. + * @param n Value to increment the value by. + */ + stepUp(n?: number): void; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface ErrorEvent extends Event { + colno: number; + filename: string; + lineno: number; + message: string; + initErrorEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, messageArg: string, filenameArg: string, linenoArg: number): void; +} +declare var ErrorEvent: { + prototype: ErrorEvent; + new (): ErrorEvent; +} + +interface SVGFilterElement extends SVGElement, SVGUnitTypes, SVGStylable, SVGLangSpace, SVGURIReference, SVGExternalResourcesRequired { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + filterResX: SVGAnimatedInteger; + filterUnits: SVGAnimatedEnumeration; + primitiveUnits: SVGAnimatedEnumeration; + x: SVGAnimatedLength; + height: SVGAnimatedLength; + filterResY: SVGAnimatedInteger; + setFilterRes(filterResX: number, filterResY: number): void; +} +declare var SVGFilterElement: { + prototype: SVGFilterElement; + new (): SVGFilterElement; +} + +interface TrackEvent extends Event { + track: any; +} +declare var TrackEvent: { + prototype: TrackEvent; + new (): TrackEvent; +} + +interface SVGFEMergeNodeElement extends SVGElement { + in1: SVGAnimatedString; +} +declare var SVGFEMergeNodeElement: { + prototype: SVGFEMergeNodeElement; + new (): SVGFEMergeNodeElement; +} + +interface SVGFEFloodElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { +} +declare var SVGFEFloodElement: { + prototype: SVGFEFloodElement; + new (): SVGFEFloodElement; +} + +interface MSGesture { + target: Element; + addPointer(pointerId: number): void; + stop(): void; +} +declare var MSGesture: { + prototype: MSGesture; + new (): MSGesture; +} + +interface TextTrackCue extends EventTarget { + onenter: (ev: Event) => any; + addEventListener(type: "enter", listener: (ev: Event) => any, useCapture?: boolean): void; + track: TextTrack; + endTime: number; + text: string; + pauseOnExit: boolean; + id: string; + startTime: number; + onexit: (ev: Event) => any; + addEventListener(type: "exit", listener: (ev: Event) => any, useCapture?: boolean): void; + getCueAsHTML(): DocumentFragment; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var TextTrackCue: { + prototype: TextTrackCue; + new (): TextTrackCue; +} + +interface MSStreamReader extends MSBaseReader { + error: DOMError; + readAsArrayBuffer(stream: MSStream, size?: number): void; + readAsBlob(stream: MSStream, size?: number): void; + readAsDataURL(stream: MSStream, size?: number): void; + readAsText(stream: MSStream, encoding?: string, size?: number): void; +} +declare var MSStreamReader: { + prototype: MSStreamReader; + new (): MSStreamReader; +} + +interface DOMTokenList { + length: number; + contains(token: string): boolean; + remove(token: string): void; + toggle(token: string): boolean; + add(token: string): void; + item(index: number): string; + [index: number]: string; + toString(): string; +} +declare var DOMTokenList: { + prototype: DOMTokenList; + new (): DOMTokenList; +} + +interface EventException { + name: string; +} + +interface Performance { + now(): number; +} + +interface SVGFEFuncAElement extends SVGComponentTransferFunctionElement { +} +declare var SVGFEFuncAElement: { + prototype: SVGFEFuncAElement; + new (): SVGFEFuncAElement; +} + +interface SVGFETileElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + in1: SVGAnimatedString; +} +declare var SVGFETileElement: { + prototype: SVGFETileElement; + new (): SVGFETileElement; +} + +interface SVGFEBlendElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + in2: SVGAnimatedString; + mode: SVGAnimatedEnumeration; + in1: SVGAnimatedString; + SVG_FEBLEND_MODE_DARKEN: number; + SVG_FEBLEND_MODE_UNKNOWN: number; + SVG_FEBLEND_MODE_MULTIPLY: number; + SVG_FEBLEND_MODE_NORMAL: number; + SVG_FEBLEND_MODE_SCREEN: number; + SVG_FEBLEND_MODE_LIGHTEN: number; +} +declare var SVGFEBlendElement: { + prototype: SVGFEBlendElement; + new (): SVGFEBlendElement; + SVG_FEBLEND_MODE_DARKEN: number; + SVG_FEBLEND_MODE_UNKNOWN: number; + SVG_FEBLEND_MODE_MULTIPLY: number; + SVG_FEBLEND_MODE_NORMAL: number; + SVG_FEBLEND_MODE_SCREEN: number; + SVG_FEBLEND_MODE_LIGHTEN: number; +} + +interface WindowTimers extends WindowTimersExtension { +} +declare var WindowTimers: { + prototype: WindowTimers; + new (): WindowTimers; +} + +interface CSSStyleDeclaration { + animationFillMode: string; + floodColor: string; + animationIterationCount: string; + textShadow: string; + backfaceVisibility: string; + msAnimationIterationCount: string; + animationDelay: string; + animationTimingFunction: string; + columnWidth: any; + msScrollSnapX: string; + columnRuleColor: any; + columnRuleWidth: any; + transitionDelay: string; + transition: string; + msFlowFrom: string; + msScrollSnapType: string; + msContentZoomSnapType: string; + msGridColumns: string; + msAnimationName: string; + msGridRowAlign: string; + msContentZoomChaining: string; + msGridColumn: any; + msHyphenateLimitZone: any; + msScrollRails: string; + msAnimationDelay: string; + enableBackground: string; + msWrapThrough: string; + columnRuleStyle: string; + msAnimation: string; + msFlexFlow: string; + msScrollSnapY: string; + msHyphenateLimitLines: any; + msTouchAction: string; + msScrollLimit: string; + animation: string; + transform: string; + filter: string; + colorInterpolationFilters: string; + transitionTimingFunction: string; + msBackfaceVisibility: string; + animationPlayState: string; + transformOrigin: string; + msScrollLimitYMin: any; + msFontFeatureSettings: string; + msContentZoomLimitMin: any; + columnGap: any; + transitionProperty: string; + msAnimationDuration: string; + msAnimationFillMode: string; + msFlexDirection: string; + msTransitionDuration: string; + fontFeatureSettings: string; + breakBefore: string; + msFlexWrap: string; + perspective: string; + msFlowInto: string; + msTransformStyle: string; + msScrollTranslation: string; + msTransitionProperty: string; + msUserSelect: string; + msOverflowStyle: string; + msScrollSnapPointsY: string; + animationDirection: string; + animationDuration: string; + msFlex: string; + msTransitionTimingFunction: string; + animationName: string; + columnRule: string; + msGridColumnSpan: any; + msFlexNegative: string; + columnFill: string; + msGridRow: any; + msFlexOrder: string; + msFlexItemAlign: string; + msFlexPositive: string; + msContentZoomLimitMax: any; + msScrollLimitYMax: any; + msGridColumnAlign: string; + perspectiveOrigin: string; + lightingColor: string; + columns: string; + msScrollChaining: string; + msHyphenateLimitChars: string; + msTouchSelect: string; + floodOpacity: string; + msAnimationDirection: string; + msAnimationPlayState: string; + columnSpan: string; + msContentZooming: string; + msPerspective: string; + msFlexPack: string; + msScrollSnapPointsX: string; + msContentZoomSnapPoints: string; + msGridRowSpan: any; + msContentZoomSnap: string; + msScrollLimitXMin: any; + breakInside: string; + msHighContrastAdjust: string; + msFlexLinePack: string; + msGridRows: string; + transitionDuration: string; + msHyphens: string; + breakAfter: string; + msTransition: string; + msPerspectiveOrigin: string; + msContentZoomLimit: string; + msScrollLimitXMax: any; + msFlexAlign: string; + msWrapMargin: any; + columnCount: any; + msAnimationTimingFunction: string; + msTransitionDelay: string; + transformStyle: string; + msWrapFlow: string; + msFlexPreferredSize: string; +} + +interface MessageChannel { + port2: MessagePort; + port1: MessagePort; +} +declare var MessageChannel: { + prototype: MessageChannel; + new (): MessageChannel; +} + +interface SVGFEMergeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { +} +declare var SVGFEMergeElement: { + prototype: SVGFEMergeElement; + new (): SVGFEMergeElement; +} + +interface Navigator extends MSFileSaver { + msMaxTouchPoints: number; + msPointerEnabled: boolean; + msManipulationViewsEnabled: boolean; + msLaunchUri(uri: string, successCallback?: MSLaunchUriCallback, noHandlerCallback?: MSLaunchUriCallback): void; +} + +interface TransitionEvent extends Event { + propertyName: string; + elapsedTime: number; + initTransitionEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, propertyNameArg: string, elapsedTimeArg: number): void; +} +declare var TransitionEvent: { + prototype: TransitionEvent; + new (): TransitionEvent; +} + +interface MediaQueryList { + matches: boolean; + media: string; + addListener(listener: MediaQueryListListener): void; + removeListener(listener: MediaQueryListListener): void; +} +declare var MediaQueryList: { + prototype: MediaQueryList; + new (): MediaQueryList; +} + +interface DOMError { + name: string; + toString(): string; +} +declare var DOMError: { + prototype: DOMError; + new (): DOMError; +} + +interface CloseEvent extends Event { + wasClean: boolean; + reason: string; + code: number; + initCloseEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, wasCleanArg: boolean, codeArg: number, reasonArg: string): void; +} +declare var CloseEvent: { + prototype: CloseEvent; + new (): CloseEvent; +} + +interface WebSocket extends EventTarget { + protocol: string; + readyState: number; + bufferedAmount: number; + onopen: (ev: Event) => any; + addEventListener(type: "open", listener: (ev: Event) => any, useCapture?: boolean): void; + extensions: string; + onmessage: (ev: any) => any; + addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void; + onclose: (ev: CloseEvent) => any; + addEventListener(type: "close", listener: (ev: CloseEvent) => any, useCapture?: boolean): void; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + binaryType: string; + url: string; + close(code?: number, reason?: string): void; + send(data: any): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + OPEN: number; + CLOSING: number; + CONNECTING: number; + CLOSED: number; +} +declare var WebSocket: { + prototype: WebSocket; + new (url: string): WebSocket; + new (url: string, prototcol: string): WebSocket; + new (url: string, prototcol: string[]): WebSocket; + OPEN: number; + CLOSING: number; + CONNECTING: number; + CLOSED: number; +} + +interface SVGFEPointLightElement extends SVGElement { + y: SVGAnimatedNumber; + x: SVGAnimatedNumber; + z: SVGAnimatedNumber; +} +declare var SVGFEPointLightElement: { + prototype: SVGFEPointLightElement; + new (): SVGFEPointLightElement; +} + +interface ProgressEvent extends Event { + loaded: number; + lengthComputable: boolean; + total: number; + initProgressEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, lengthComputableArg: boolean, loadedArg: number, totalArg: number): void; +} +declare var ProgressEvent: { + prototype: ProgressEvent; + new (): ProgressEvent; +} + +interface IDBObjectStore { + indexNames: DOMStringList; + name: string; + transaction: IDBTransaction; + keyPath: string; + count(key?: any): IDBRequest; + add(value: any, key?: any): IDBRequest; + clear(): IDBRequest; + createIndex(name: string, keyPath: string, optionalParameters?: any): IDBIndex; + put(value: any, key?: any): IDBRequest; + openCursor(range?: any, direction?: string): IDBRequest; + deleteIndex(indexName: string): void; + index(name: string): IDBIndex; + get(key: any): IDBRequest; + delete(key: any): IDBRequest; +} +declare var IDBObjectStore: { + prototype: IDBObjectStore; + new (): IDBObjectStore; +} + +interface HTMLCanvasElement { + /** + * Returns a blob object encoded as a Portable Network Graphics (PNG) format from a canvas image or drawing. + */ + msToBlob(): Blob; +} + +interface SVGFEGaussianBlurElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + stdDeviationX: SVGAnimatedNumber; + in1: SVGAnimatedString; + stdDeviationY: SVGAnimatedNumber; + setStdDeviation(stdDeviationX: number, stdDeviationY: number): void; +} +declare var SVGFEGaussianBlurElement: { + prototype: SVGFEGaussianBlurElement; + new (): SVGFEGaussianBlurElement; +} + +interface SVGFilterPrimitiveStandardAttributes extends SVGStylable { + y: SVGAnimatedLength; + width: SVGAnimatedLength; + x: SVGAnimatedLength; + height: SVGAnimatedLength; + result: SVGAnimatedString; +} + +interface Element { + msRegionOverflow: string; + onmspointerdown: (ev: any) => any; + addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgotpointercapture: (ev: any) => any; + addEventListener(type: "msgotpointercapture", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturedoubletap: (ev: any) => any; + addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerhover: (ev: any) => any; + addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturehold: (ev: any) => any; + addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointermove: (ev: any) => any; + addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturechange: (ev: any) => any; + addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturestart: (ev: any) => any; + addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointercancel: (ev: any) => any; + addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgestureend: (ev: any) => any; + addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturetap: (ev: any) => any; + addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerout: (ev: any) => any; + addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void; + onmsinertiastart: (ev: any) => any; + addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void; + onmslostpointercapture: (ev: any) => any; + addEventListener(type: "mslostpointercapture", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerover: (ev: any) => any; + addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void; + msContentZoomFactor: number; + onmspointerup: (ev: any) => any; + addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void; + msGetRegionContent(): MSRangeCollection; + msReleasePointerCapture(pointerId: number): void; + msSetPointerCapture(pointerId: number): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface IDBVersionChangeEvent extends Event { + newVersion: number; + oldVersion: number; +} +declare var IDBVersionChangeEvent: { + prototype: IDBVersionChangeEvent; + new (): IDBVersionChangeEvent; +} + +interface IDBIndex { + unique: boolean; + name: string; + keyPath: string; + objectStore: IDBObjectStore; + count(key?: any): IDBRequest; + getKey(key: any): IDBRequest; + openKeyCursor(range?: IDBKeyRange, direction?: string): IDBRequest; + get(key: any): IDBRequest; + openCursor(range?: IDBKeyRange, direction?: string): IDBRequest; +} +declare var IDBIndex: { + prototype: IDBIndex; + new (): IDBIndex; +} + +interface WheelEvent { + getCurrentPoint(element: Element): void; +} + +interface FileList { + length: number; + item(index: number): File; + [index: number]: File; +} +declare var FileList: { + prototype: FileList; + new (): FileList; +} + +interface IDBCursor { + source: any; + direction: string; + key: any; + primaryKey: any; + advance(count: number): void; + delete(): IDBRequest; + continue(key?: any): void; + update(value: any): IDBRequest; + PREV: string; + PREV_NO_DUPLICATE: string; + NEXT: string; + NEXT_NO_DUPLICATE: string; +} +declare var IDBCursor: { + prototype: IDBCursor; + new (): IDBCursor; + PREV: string; + PREV_NO_DUPLICATE: string; + NEXT: string; + NEXT_NO_DUPLICATE: string; +} + +interface SVGFESpecularLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + kernelUnitLengthY: SVGAnimatedNumber; + surfaceScale: SVGAnimatedNumber; + specularExponent: SVGAnimatedNumber; + in1: SVGAnimatedString; + kernelUnitLengthX: SVGAnimatedNumber; + specularConstant: SVGAnimatedNumber; +} +declare var SVGFESpecularLightingElement: { + prototype: SVGFESpecularLightingElement; + new (): SVGFESpecularLightingElement; +} + +interface File extends Blob { + lastModifiedDate: any; + name: string; +} +declare var File: { + prototype: File; + new (): File; +} + +interface URL { + revokeObjectURL(url: string): void; + createObjectURL(object: any, options?: ObjectURLOptions): string; +} +declare var URL: URL; + +interface RangeException { + name: string; +} + +interface IDBCursorWithValue extends IDBCursor { + value: any; +} +declare var IDBCursorWithValue: { + prototype: IDBCursorWithValue; + new (): IDBCursorWithValue; +} + +interface HTMLTextAreaElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing. + */ + autofocus: boolean; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * When present, marks an element that can't be submitted without a value. + */ + required: boolean; + /** + * Sets or retrieves the maximum number of characters that the user can enter in a text control. + */ + maxLength: number; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Gets or sets a text string that is displayed in an input field as a hint or prompt to users as the format or type of information they need to enter.The text appears in an input field until the user puts focus on the field. + */ + placeholder: string; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface XMLHttpRequestEventTarget extends EventTarget { + onprogress: (ev: ProgressEvent) => any; + addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onload: (ev: any) => any; + addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void; + ontimeout: (ev: any) => any; + addEventListener(type: "timeout", listener: (ev: any) => any, useCapture?: boolean): void; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + onloadstart: (ev: any) => any; + addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void; + onloadend: (ev: ProgressEvent) => any; + addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var XMLHttpRequestEventTarget: { + prototype: XMLHttpRequestEventTarget; + new (): XMLHttpRequestEventTarget; +} + +interface IDBEnvironment { + msIndexedDB: IDBFactory; + indexedDB: IDBFactory; +} + +interface AudioTrackList extends EventTarget { + length: number; + onchange: (ev: any) => any; + addEventListener(type: "change", listener: (ev: any) => any, useCapture?: boolean): void; + onaddtrack: (ev: TrackEvent) => any; + addEventListener(type: "addtrack", listener: (ev: TrackEvent) => any, useCapture?: boolean): void; + getTrackById(id: string): AudioTrack; + item(index: number): AudioTrack; + [index: number]: AudioTrack; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var AudioTrackList: { + prototype: AudioTrackList; + new (): AudioTrackList; +} + +interface MSBaseReader extends EventTarget { + onprogress: (ev: ProgressEvent) => any; + addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + readyState: number; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + onloadend: (ev: ProgressEvent) => any; + addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onload: (ev: any) => any; + addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void; + onloadstart: (ev: any) => any; + addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void; + result: any; + abort(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + LOADING: number; + EMPTY: number; + DONE: number; +} + +interface History { + state: any; + replaceState(statedata: any, title: string, url?: string): void; + pushState(statedata: any, title: string, url?: string): void; +} + +interface SVGFEMorphologyElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + operator: SVGAnimatedEnumeration; + radiusX: SVGAnimatedNumber; + radiusY: SVGAnimatedNumber; + in1: SVGAnimatedString; + SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number; + SVG_MORPHOLOGY_OPERATOR_ERODE: number; + SVG_MORPHOLOGY_OPERATOR_DILATE: number; +} +declare var SVGFEMorphologyElement: { + prototype: SVGFEMorphologyElement; + new (): SVGFEMorphologyElement; + SVG_MORPHOLOGY_OPERATOR_UNKNOWN: number; + SVG_MORPHOLOGY_OPERATOR_ERODE: number; + SVG_MORPHOLOGY_OPERATOR_DILATE: number; +} + +interface HTMLSelectElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing. + */ + autofocus: boolean; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * When present, marks an element that can't be submitted without a value. + */ + required: boolean; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface CSSRule { + KEYFRAMES_RULE: number; + KEYFRAME_RULE: number; + VIEWPORT_RULE: number; +} +//declare var CSSRule: { +// prototype: CSSRule; +// KEYFRAMES_RULE: number; +// KEYFRAME_RULE: number; +// VIEWPORT_RULE: number; +//} + +interface SVGFEFuncRElement extends SVGComponentTransferFunctionElement { +} +declare var SVGFEFuncRElement: { + prototype: SVGFEFuncRElement; + new (): SVGFEFuncRElement; +} + +interface WindowTimersExtension { + msSetImmediate(expression: any, ...args: any[]): number; + clearImmediate(handle: number): void; + msClearImmediate(handle: number): void; + setImmediate(expression: any, ...args: any[]): number; +} + +interface SVGFEDisplacementMapElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + in2: SVGAnimatedString; + xChannelSelector: SVGAnimatedEnumeration; + yChannelSelector: SVGAnimatedEnumeration; + scale: SVGAnimatedNumber; + in1: SVGAnimatedString; + SVG_CHANNEL_B: number; + SVG_CHANNEL_R: number; + SVG_CHANNEL_G: number; + SVG_CHANNEL_UNKNOWN: number; + SVG_CHANNEL_A: number; +} +declare var SVGFEDisplacementMapElement: { + prototype: SVGFEDisplacementMapElement; + new (): SVGFEDisplacementMapElement; + SVG_CHANNEL_B: number; + SVG_CHANNEL_R: number; + SVG_CHANNEL_G: number; + SVG_CHANNEL_UNKNOWN: number; + SVG_CHANNEL_A: number; +} + +interface AnimationEvent extends Event { + animationName: string; + elapsedTime: number; + initAnimationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, animationNameArg: string, elapsedTimeArg: number): void; +} +declare var AnimationEvent: { + prototype: AnimationEvent; + new (): AnimationEvent; +} + +interface SVGComponentTransferFunctionElement extends SVGElement { + tableValues: SVGAnimatedNumberList; + slope: SVGAnimatedNumber; + type: SVGAnimatedEnumeration; + exponent: SVGAnimatedNumber; + amplitude: SVGAnimatedNumber; + intercept: SVGAnimatedNumber; + offset: SVGAnimatedNumber; + SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number; + SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number; + SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number; + SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number; + SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number; + SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number; +} +declare var SVGComponentTransferFunctionElement: { + prototype: SVGComponentTransferFunctionElement; + new (): SVGComponentTransferFunctionElement; + SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN: number; + SVG_FECOMPONENTTRANSFER_TYPE_TABLE: number; + SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY: number; + SVG_FECOMPONENTTRANSFER_TYPE_GAMMA: number; + SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE: number; + SVG_FECOMPONENTTRANSFER_TYPE_LINEAR: number; +} + +interface MSRangeCollection { + length: number; + item(index: number): Range; + [index: number]: Range; +} +declare var MSRangeCollection: { + prototype: MSRangeCollection; + new (): MSRangeCollection; +} + +interface SVGFEDistantLightElement extends SVGElement { + azimuth: SVGAnimatedNumber; + elevation: SVGAnimatedNumber; +} +declare var SVGFEDistantLightElement: { + prototype: SVGFEDistantLightElement; + new (): SVGFEDistantLightElement; +} + +interface SVGException { + name: string; +} + +interface SVGFEFuncBElement extends SVGComponentTransferFunctionElement { +} +declare var SVGFEFuncBElement: { + prototype: SVGFEFuncBElement; + new (): SVGFEFuncBElement; +} + +interface IDBKeyRange { + upper: any; + upperOpen: boolean; + lower: any; + lowerOpen: boolean; + bound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange; + only(value: any): IDBKeyRange; + lowerBound(bound: any, open?: boolean): IDBKeyRange; + upperBound(bound: any, open?: boolean): IDBKeyRange; +} +declare var IDBKeyRange: { + prototype: IDBKeyRange; + new (): IDBKeyRange; +} + +interface WindowConsole { + console: Console; +} + +interface IDBTransaction extends EventTarget { + oncomplete: (ev: Event) => any; + addEventListener(type: "complete", listener: (ev: Event) => any, useCapture?: boolean): void; + db: IDBDatabase; + mode: string; + error: DOMError; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + abort(): void; + objectStore(name: string): IDBObjectStore; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + READ_ONLY: string; + VERSION_CHANGE: string; + READ_WRITE: string; +} +declare var IDBTransaction: { + prototype: IDBTransaction; + new (): IDBTransaction; + READ_ONLY: string; + VERSION_CHANGE: string; + READ_WRITE: string; +} + +interface AudioTrack { + kind: string; + language: string; + id: string; + label: string; + enabled: boolean; +} +declare var AudioTrack: { + prototype: AudioTrack; + new (): AudioTrack; +} + +interface SVGFEConvolveMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + orderY: SVGAnimatedInteger; + kernelUnitLengthY: SVGAnimatedNumber; + orderX: SVGAnimatedInteger; + preserveAlpha: SVGAnimatedBoolean; + kernelMatrix: SVGAnimatedNumberList; + edgeMode: SVGAnimatedEnumeration; + kernelUnitLengthX: SVGAnimatedNumber; + bias: SVGAnimatedNumber; + targetX: SVGAnimatedInteger; + targetY: SVGAnimatedInteger; + divisor: SVGAnimatedNumber; + in1: SVGAnimatedString; + SVG_EDGEMODE_WRAP: number; + SVG_EDGEMODE_DUPLICATE: number; + SVG_EDGEMODE_UNKNOWN: number; + SVG_EDGEMODE_NONE: number; +} +declare var SVGFEConvolveMatrixElement: { + prototype: SVGFEConvolveMatrixElement; + new (): SVGFEConvolveMatrixElement; + SVG_EDGEMODE_WRAP: number; + SVG_EDGEMODE_DUPLICATE: number; + SVG_EDGEMODE_UNKNOWN: number; + SVG_EDGEMODE_NONE: number; +} + +interface TextTrackCueList { + length: number; + item(index: number): TextTrackCue; + [index: number]: TextTrackCue; + getCueById(id: string): TextTrackCue; +} +declare var TextTrackCueList: { + prototype: TextTrackCueList; + new (): TextTrackCueList; +} + +interface CSSKeyframesRule extends CSSRule { + name: string; + cssRules: CSSRuleList; + findRule(rule: string): CSSKeyframeRule; + deleteRule(rule: string): void; + appendRule(rule: string): void; +} +declare var CSSKeyframesRule: { + prototype: CSSKeyframesRule; + new (): CSSKeyframesRule; +} + +interface Window extends WindowBase64, IDBEnvironment, WindowConsole { + onmspointerdown: (ev: any) => any; + addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void; + animationStartTime: number; + onmsgesturedoubletap: (ev: any) => any; + addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerhover: (ev: any) => any; + addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturehold: (ev: any) => any; + addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointermove: (ev: any) => any; + addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturechange: (ev: any) => any; + addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturestart: (ev: any) => any; + addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointercancel: (ev: any) => any; + addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgestureend: (ev: any) => any; + addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturetap: (ev: any) => any; + addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerout: (ev: any) => any; + addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void; + msAnimationStartTime: number; + applicationCache: ApplicationCache; + onmsinertiastart: (ev: any) => any; + addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerover: (ev: any) => any; + addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void; + onpopstate: (ev: PopStateEvent) => any; + addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void; + onmspointerup: (ev: any) => any; + addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void; + msCancelRequestAnimationFrame(handle: number): void; + matchMedia(mediaQuery: string): MediaQueryList; + cancelAnimationFrame(handle: number): void; + msIsStaticHTML(html: string): boolean; + msMatchMedia(mediaQuery: string): MediaQueryList; + requestAnimationFrame(callback: FrameRequestCallback): number; + msRequestAnimationFrame(callback: FrameRequestCallback): number; +} + +interface SVGFETurbulenceElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + baseFrequencyX: SVGAnimatedNumber; + numOctaves: SVGAnimatedInteger; + type: SVGAnimatedEnumeration; + baseFrequencyY: SVGAnimatedNumber; + stitchTiles: SVGAnimatedEnumeration; + seed: SVGAnimatedNumber; + SVG_STITCHTYPE_UNKNOWN: number; + SVG_STITCHTYPE_NOSTITCH: number; + SVG_TURBULENCE_TYPE_UNKNOWN: number; + SVG_TURBULENCE_TYPE_TURBULENCE: number; + SVG_TURBULENCE_TYPE_FRACTALNOISE: number; + SVG_STITCHTYPE_STITCH: number; +} +declare var SVGFETurbulenceElement: { + prototype: SVGFETurbulenceElement; + new (): SVGFETurbulenceElement; + SVG_STITCHTYPE_UNKNOWN: number; + SVG_STITCHTYPE_NOSTITCH: number; + SVG_TURBULENCE_TYPE_UNKNOWN: number; + SVG_TURBULENCE_TYPE_TURBULENCE: number; + SVG_TURBULENCE_TYPE_FRACTALNOISE: number; + SVG_STITCHTYPE_STITCH: number; +} + +interface TextTrackList { + length: number; + item(index: number): TextTrack; + [index: number]: TextTrack; +} +declare var TextTrackList: { + prototype: TextTrackList; + new (): TextTrackList; +} + +interface SVGFEFuncGElement extends SVGComponentTransferFunctionElement { +} +declare var SVGFEFuncGElement: { + prototype: SVGFEFuncGElement; + new (): SVGFEFuncGElement; +} + +interface SVGFEColorMatrixElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + in1: SVGAnimatedString; + type: SVGAnimatedEnumeration; + values: SVGAnimatedNumberList; + SVG_FECOLORMATRIX_TYPE_SATURATE: number; + SVG_FECOLORMATRIX_TYPE_UNKNOWN: number; + SVG_FECOLORMATRIX_TYPE_MATRIX: number; + SVG_FECOLORMATRIX_TYPE_HUEROTATE: number; + SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number; +} +declare var SVGFEColorMatrixElement: { + prototype: SVGFEColorMatrixElement; + new (): SVGFEColorMatrixElement; + SVG_FECOLORMATRIX_TYPE_SATURATE: number; + SVG_FECOLORMATRIX_TYPE_UNKNOWN: number; + SVG_FECOLORMATRIX_TYPE_MATRIX: number; + SVG_FECOLORMATRIX_TYPE_HUEROTATE: number; + SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA: number; +} + +interface Console { + info(message?: any, ...optionalParams: any[]): void; + profile(reportName?: string): void; + assert(test?: boolean, message?: string, ...optionalParams: any[]): void; + msIsIndependentlyComposed(element: Element): boolean; + clear(): void; + dir(value?: any, ...optionalParams: any[]): void; + warn(message?: any, ...optionalParams: any[]): void; + error(message?: any, ...optionalParams: any[]): void; + log(message?: any, ...optionalParams: any[]): void; + profileEnd(): void; +} +declare var Console: { + prototype: Console; + new (): Console; +} + +interface SVGFESpotLightElement extends SVGElement { + pointsAtY: SVGAnimatedNumber; + y: SVGAnimatedNumber; + limitingConeAngle: SVGAnimatedNumber; + specularExponent: SVGAnimatedNumber; + x: SVGAnimatedNumber; + pointsAtZ: SVGAnimatedNumber; + z: SVGAnimatedNumber; + pointsAtX: SVGAnimatedNumber; +} +declare var SVGFESpotLightElement: { + prototype: SVGFESpotLightElement; + new (): SVGFESpotLightElement; +} + +interface HTMLImageElement { + /** + * Gets or sets the primary DLNA PlayTo device. + */ + msPlayToPrimary: boolean; + /** + * Gets or sets whether the DLNA PlayTo device is available. + */ + msPlayToDisabled: boolean; + /** + * Gets the source associated with the media element for use by the PlayToManager. + */ + msPlayToSource: any; +} + +interface WindowBase64 { + btoa(rawString: string): string; + atob(encodedString: string): string; +} + +interface IDBDatabase extends EventTarget { + version: string; + name: string; + objectStoreNames: DOMStringList; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + createObjectStore(name: string, optionalParameters?: any): IDBObjectStore; + close(): void; + transaction(storeNames: any, mode?: string): IDBTransaction; + deleteObjectStore(name: string): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var IDBDatabase: { + prototype: IDBDatabase; + new (): IDBDatabase; +} + +interface DOMStringList { + length: number; + contains(str: string): boolean; + item(index: number): string; + [index: number]: string; +} +declare var DOMStringList: { + prototype: DOMStringList; + new (): DOMStringList; +} + +interface HTMLButtonElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Overrides the target attribute on a form element. + */ + formTarget: string; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Overrides the action attribute (where the data on a form is sent) on the parent form element. + */ + formAction: string; + /** + * Provides a way to direct a user to a specific field when a document loads. This can provide both direction and convenience for a user, reducing the need to click or tab to a field when a page opens. This attribute is true when present on an element, and false when missing. + */ + autofocus: boolean; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * Overrides any validation or required attributes on a form or form elements to allow it to be submitted without validation. This can be used to create a "save draft"-type submit option. + */ + formNoValidate: string; + /** + * Used to override the encoding (formEnctype attribute) specified on the form element. + */ + formEnctype: string; + /** + * Overrides the submit method attribute previously specified on a form element. + */ + formMethod: string; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface IDBOpenDBRequest extends IDBRequest { + onupgradeneeded: (ev: IDBVersionChangeEvent) => any; + addEventListener(type: "upgradeneeded", listener: (ev: IDBVersionChangeEvent) => any, useCapture?: boolean): void; + onblocked: (ev: Event) => any; + addEventListener(type: "blocked", listener: (ev: Event) => any, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var IDBOpenDBRequest: { + prototype: IDBOpenDBRequest; + new (): IDBOpenDBRequest; +} + +interface HTMLProgressElement extends HTMLElement { + /** + * Sets or gets the current value of a progress element. The value must be a non-negative number between 0 and the max value. + */ + value: number; + /** + * Defines the maximum, or "done" value for a progress element. + */ + max: number; + /** + * Returns the quotient of value/max when the value attribute is set (determinate progress bar), or -1 when the value attribute is missing (indeterminate progress bar). + */ + position: number; + /** + * Retrieves a reference to the form that the object is embedded in. + */ + form: HTMLFormElement; +} +declare var HTMLProgressElement: { + prototype: HTMLProgressElement; + new (): HTMLProgressElement; +} + +interface MSLaunchUriCallback { + (): void; +} + +interface SVGFEOffsetElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + dy: SVGAnimatedNumber; + in1: SVGAnimatedString; + dx: SVGAnimatedNumber; +} +declare var SVGFEOffsetElement: { + prototype: SVGFEOffsetElement; + new (): SVGFEOffsetElement; +} + +interface HTMLFormElement { + /** + * Specifies whether autocomplete is applied to an editable text field. + */ + autocomplete: string; + /** + * Designates a form that is not validated when submitted. + */ + noValidate: boolean; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; +} + +interface MSUnsafeFunctionCallback { + (): any; +} + +interface Document { + onmspointerdown: (ev: any) => any; + addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void; + msHidden: boolean; + msVisibilityState: string; + onmsgesturedoubletap: (ev: any) => any; + addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void; + visibilityState: string; + onmsmanipulationstatechanged: (ev: any) => any; + addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerhover: (ev: any) => any; + addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void; + onmscontentzoom: (ev: any) => any; + addEventListener(type: "mscontentzoom", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointermove: (ev: any) => any; + addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturehold: (ev: any) => any; + addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturechange: (ev: any) => any; + addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturestart: (ev: any) => any; + addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointercancel: (ev: any) => any; + addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgestureend: (ev: any) => any; + addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void; + onmsgesturetap: (ev: any) => any; + addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerout: (ev: any) => any; + addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void; + onmsinertiastart: (ev: any) => any; + addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void; + msCSSOMElementFloatMetrics: boolean; + onmspointerover: (ev: any) => any; + addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void; + hidden: boolean; + onmspointerup: (ev: any) => any; + addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void; + msElementsFromPoint(x: number, y: number): NodeList; + msElementsFromRect(left: number, top: number, width: number, height: number): NodeList; + clear(): void; +} + +interface MessageEvent extends Event { + ports: any; +} + +interface HTMLScriptElement { + async: boolean; +} + +interface HTMLMediaElement { + /** + * Specifies the purpose of the audio or video media, such as background audio or alerts. + */ + msAudioCategory: string; + /** + * Specifies whether or not to enable low-latency playback on the media element. + */ + msRealTime: boolean; + /** + * Gets or sets the primary DLNA PlayTo device. + */ + msPlayToPrimary: boolean; + textTracks: TextTrackList; + /** + * Gets or sets whether the DLNA PlayTo device is available. + */ + msPlayToDisabled: boolean; + /** + * Returns an AudioTrackList object with the audio tracks for a given video element. + */ + audioTracks: AudioTrackList; + /** + * Gets the source associated with the media element for use by the PlayToManager. + */ + msPlayToSource: any; + /** + * Specifies the output device id that the audio will be sent to. + */ + msAudioDeviceType: string; + /** + * Clears all effects from the media pipeline. + */ + msClearEffects(): void; + /** + * Specifies the media protection manager for a given media pipeline. + */ + msSetMediaProtectionManager(mediaProtectionManager?: any): void; + /** + * Inserts the specified audio effect into media pipeline. + */ + msInsertAudioEffect(activatableClassId: string, effectRequired: boolean, config?: any): void; +} + +interface TextTrack extends EventTarget { + language: string; + mode: any; + readyState: number; + activeCues: TextTrackCueList; + cues: TextTrackCueList; + oncuechange: (ev: Event) => any; + addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void; + kind: string; + onload: (ev: any) => any; + addEventListener(type: "load", listener: (ev: any) => any, useCapture?: boolean): void; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + label: string; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + ERROR: number; + SHOWING: number; + LOADING: number; + LOADED: number; + NONE: number; + HIDDEN: number; + DISABLED: number; +} +declare var TextTrack: { + prototype: TextTrack; + new (): TextTrack; + ERROR: number; + SHOWING: number; + LOADING: number; + LOADED: number; + NONE: number; + HIDDEN: number; + DISABLED: number; +} + +interface MediaQueryListListener { + (mql: MediaQueryList): void; +} + +interface IDBRequest extends EventTarget { + source: any; + onsuccess: (ev: Event) => any; + addEventListener(type: "success", listener: (ev: Event) => any, useCapture?: boolean): void; + error: DOMError; + transaction: IDBTransaction; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + readyState: string; + result: any; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var IDBRequest: { + prototype: IDBRequest; + new (): IDBRequest; +} + +interface MessagePort extends EventTarget { + onmessage: (ev: any) => any; + addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void; + close(): void; + postMessage(message: any, ports?: any): void; + start(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var MessagePort: { + prototype: MessagePort; + new (): MessagePort; +} + +interface FileReader extends MSBaseReader { + error: DOMError; + readAsArrayBuffer(blob: Blob): void; + readAsDataURL(blob: Blob): void; + readAsText(blob: Blob, encoding?: string): void; +} +declare var FileReader: { + prototype: FileReader; + new (): FileReader; +} + +interface BlobPropertyBag { + type?: string; + endings?: string; +} + +interface Blob { + type: string; + size: number; + msDetachStream(): any; + slice(start?: number, end?: number, contentType?: string): Blob; + close(): void; + msClose(): void; +} +declare var Blob: { + prototype: Blob; + new (blobParts?: any[], options?: BlobPropertyBag): Blob; +} + +interface ApplicationCache extends EventTarget { + status: number; + ondownloading: (ev: Event) => any; + addEventListener(type: "downloading", listener: (ev: Event) => any, useCapture?: boolean): void; + onprogress: (ev: ProgressEvent) => any; + addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + onupdateready: (ev: Event) => any; + addEventListener(type: "updateready", listener: (ev: Event) => any, useCapture?: boolean): void; + oncached: (ev: Event) => any; + addEventListener(type: "cached", listener: (ev: Event) => any, useCapture?: boolean): void; + onobsolete: (ev: Event) => any; + addEventListener(type: "obsolete", listener: (ev: Event) => any, useCapture?: boolean): void; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onchecking: (ev: Event) => any; + addEventListener(type: "checking", listener: (ev: Event) => any, useCapture?: boolean): void; + onnoupdate: (ev: Event) => any; + addEventListener(type: "noupdate", listener: (ev: Event) => any, useCapture?: boolean): void; + swapCache(): void; + abort(): void; + update(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + CHECKING: number; + UNCACHED: number; + UPDATEREADY: number; + DOWNLOADING: number; + IDLE: number; + OBSOLETE: number; +} +declare var ApplicationCache: { + prototype: ApplicationCache; + new (): ApplicationCache; + CHECKING: number; + UNCACHED: number; + UPDATEREADY: number; + DOWNLOADING: number; + IDLE: number; + OBSOLETE: number; +} + +interface FrameRequestCallback { + (time: number): void; +} + +interface XMLHttpRequest { + response: any; + withCredentials: boolean; + onprogress: (ev: ProgressEvent) => any; + addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + responseType: string; + onloadend: (ev: ProgressEvent) => any; + addEventListener(type: "loadend", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void; + upload: XMLHttpRequestEventTarget; + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + onloadstart: (ev: any) => any; + addEventListener(type: "loadstart", listener: (ev: any) => any, useCapture?: boolean): void; +} + +interface PopStateEvent extends Event { + state: any; + initPopStateEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, stateArg: any): void; +} +declare var PopStateEvent: { + prototype: PopStateEvent; + new (): PopStateEvent; +} + +interface CSSKeyframeRule extends CSSRule { + keyText: string; + style: CSSStyleDeclaration; +} +declare var CSSKeyframeRule: { + prototype: CSSKeyframeRule; + new (): CSSKeyframeRule; +} + +interface MSFileSaver { + msSaveBlob(blob: any, defaultName?: string): boolean; + msSaveOrOpenBlob(blob: any, defaultName?: string): boolean; +} + +interface MSStream { + type: string; + msDetachStream(): any; + msClose(): void; +} +declare var MSStream: { + prototype: MSStream; + new (): MSStream; +} + +interface MediaError { + msExtendedCode: number; +} + +interface HTMLFieldSetElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface MSBlobBuilder { + append(data: any, endings?: string): void; + getBlob(contentType?: string): Blob; +} +declare var MSBlobBuilder: { + prototype: MSBlobBuilder; + new (): MSBlobBuilder; +} + +interface HTMLElement { + onmscontentzoom: (ev: any) => any; + addEventListener(type: "mscontentzoom", listener: (ev: any) => any, useCapture?: boolean): void; + oncuechange: (ev: Event) => any; + addEventListener(type: "cuechange", listener: (ev: Event) => any, useCapture?: boolean): void; + spellcheck: boolean; + classList: DOMTokenList; + onmsmanipulationstatechanged: (ev: any) => any; + addEventListener(type: "msmanipulationstatechanged", listener: (ev: any) => any, useCapture?: boolean): void; + draggable: boolean; +} + +interface DataTransfer { + types: DOMStringList; + files: FileList; +} + +interface DOMSettableTokenList extends DOMTokenList { + value: string; +} +declare var DOMSettableTokenList: { + prototype: DOMSettableTokenList; + new (): DOMSettableTokenList; +} + +interface IDBFactory { + open(name: string, version?: number): IDBOpenDBRequest; + cmp(first: any, second: any): number; + deleteDatabase(name: string): IDBOpenDBRequest; +} +declare var IDBFactory: { + prototype: IDBFactory; + new (): IDBFactory; +} + +interface Range { + createContextualFragment(fragment: string): DocumentFragment; +} + +interface HTMLObjectElement { + /** + * Returns the error message that would be displayed if the user submits the form, or an empty string if no error message. It also triggers the standard error message, such as "this is a required field". The result is that the user sees validation messages without actually submitting. + */ + validationMessage: string; + /** + * Returns a ValidityState object that represents the validity states of an element. + */ + validity: ValidityState; + /** + * Returns whether an element will successfully validate based on forms validation rules and constraints. + */ + willValidate: boolean; + /** + * Returns whether a form will validate when it is submitted, without having to submit it. + */ + checkValidity(): boolean; + /** + * Sets a custom error message that is displayed when a form is submitted. + * @param error Sets a custom error message that is displayed when a form is submitted. + */ + setCustomValidity(error: string): void; +} + +interface MSPointerEvent extends MouseEvent { + width: number; + rotation: number; + pressure: number; + pointerType: any; + isPrimary: boolean; + tiltY: number; + height: number; + intermediatePoints: any; + currentPoint: any; + tiltX: number; + hwTimestamp: number; + pointerId: number; + initPointerEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, screenXArg: number, screenYArg: number, clientXArg: number, clientYArg: number, ctrlKeyArg: boolean, altKeyArg: boolean, shiftKeyArg: boolean, metaKeyArg: boolean, buttonArg: number, relatedTargetArg: EventTarget, offsetXArg: number, offsetYArg: number, widthArg: number, heightArg: number, pressure: number, rotation: number, tiltX: number, tiltY: number, pointerIdArg: number, pointerType: any, hwTimestampArg: number, isPrimary: boolean): void; + getCurrentPoint(element: Element): void; + getIntermediatePoints(element: Element): void; + MSPOINTER_TYPE_PEN: number; + MSPOINTER_TYPE_MOUSE: number; + MSPOINTER_TYPE_TOUCH: number; +} +declare var MSPointerEvent: { + prototype: MSPointerEvent; + new (): MSPointerEvent; + MSPOINTER_TYPE_PEN: number; + MSPOINTER_TYPE_MOUSE: number; + MSPOINTER_TYPE_TOUCH: number; +} + +interface DOMException { + name: string; + INVALID_NODE_TYPE_ERR: number; + DATA_CLONE_ERR: number; + TIMEOUT_ERR: number; +} +//declare var DOMException: { +// prototype: DOMException; +// INVALID_NODE_TYPE_ERR: number; +// DATA_CLONE_ERR: number; +// TIMEOUT_ERR: number; +//} + +interface MSManipulationEvent extends UIEvent { + lastState: number; + currentState: number; + initMSManipulationEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, detailArg: number, lastState: number, currentState: number): void; + MS_MANIPULATION_STATE_STOPPED: number; + MS_MANIPULATION_STATE_ACTIVE: number; + MS_MANIPULATION_STATE_INERTIA: number; +} +declare var MSManipulationEvent: { + prototype: MSManipulationEvent; + new (): MSManipulationEvent; + MS_MANIPULATION_STATE_STOPPED: number; + MS_MANIPULATION_STATE_ACTIVE: number; + MS_MANIPULATION_STATE_INERTIA: number; +} + +interface FormData { + append(name: any, value: any, blobName?: string): void; +} +declare var FormData: { + prototype: FormData; + new (form?: HTMLFormElement): FormData; +} + +interface HTMLDataListElement extends HTMLElement { + options: HTMLCollection; +} +declare var HTMLDataListElement: { + prototype: HTMLDataListElement; + new (): HTMLDataListElement; +} + +interface SVGFEImageElement extends SVGElement, SVGLangSpace, SVGFilterPrimitiveStandardAttributes, SVGURIReference, SVGExternalResourcesRequired { + preserveAspectRatio: SVGAnimatedPreserveAspectRatio; +} +declare var SVGFEImageElement: { + prototype: SVGFEImageElement; + new (): SVGFEImageElement; +} + +interface AbstractWorker extends EventTarget { + onerror: (ev: ErrorEvent) => any; + addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface SVGFECompositeElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + operator: SVGAnimatedEnumeration; + in2: SVGAnimatedString; + k2: SVGAnimatedNumber; + k1: SVGAnimatedNumber; + k3: SVGAnimatedNumber; + in1: SVGAnimatedString; + k4: SVGAnimatedNumber; + SVG_FECOMPOSITE_OPERATOR_OUT: number; + SVG_FECOMPOSITE_OPERATOR_OVER: number; + SVG_FECOMPOSITE_OPERATOR_XOR: number; + SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number; + SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number; + SVG_FECOMPOSITE_OPERATOR_IN: number; + SVG_FECOMPOSITE_OPERATOR_ATOP: number; +} +declare var SVGFECompositeElement: { + prototype: SVGFECompositeElement; + new (): SVGFECompositeElement; + SVG_FECOMPOSITE_OPERATOR_OUT: number; + SVG_FECOMPOSITE_OPERATOR_OVER: number; + SVG_FECOMPOSITE_OPERATOR_XOR: number; + SVG_FECOMPOSITE_OPERATOR_ARITHMETIC: number; + SVG_FECOMPOSITE_OPERATOR_UNKNOWN: number; + SVG_FECOMPOSITE_OPERATOR_IN: number; + SVG_FECOMPOSITE_OPERATOR_ATOP: number; +} + +interface ValidityState { + customError: boolean; + valueMissing: boolean; + stepMismatch: boolean; + rangeUnderflow: boolean; + rangeOverflow: boolean; + typeMismatch: boolean; + patternMismatch: boolean; + tooLong: boolean; + valid: boolean; +} +declare var ValidityState: { + prototype: ValidityState; + new (): ValidityState; +} + +interface HTMLTrackElement extends HTMLElement { + kind: string; + src: string; + srclang: string; + track: TextTrack; + label: string; + default: boolean; +} +declare var HTMLTrackElement: { + prototype: HTMLTrackElement; + new (): HTMLTrackElement; +} + +interface MSApp { + createFileFromStorageFile(storageFile: any): File; + createBlobFromRandomAccessStream(type: string, seeker: any): Blob; + createStreamFromInputStream(type: string, inputStream: any): MSStream; + terminateApp(exceptionObject: any): void; + createDataPackage(object: any): any; + execUnsafeLocalFunction(unsafeFunction: MSUnsafeFunctionCallback): any; + getHtmlPrintDocumentSource(htmlDoc: any): any; + addPublicLocalApplicationUri(uri: string): void; + createDataPackageFromSelection(): any; +} +declare var MSApp: MSApp; + +interface HTMLVideoElement { + msIsStereo3D: boolean; + msStereo3DPackingMode: string; + onMSVideoOptimalLayoutChanged: (ev: any) => any; + addEventListener(type: "MSVideoOptimalLayoutChanged", listener: (ev: any) => any, useCapture?: boolean): void; + onMSVideoFrameStepCompleted: (ev: any) => any; + addEventListener(type: "MSVideoFrameStepCompleted", listener: (ev: any) => any, useCapture?: boolean): void; + msStereo3DRenderMode: string; + msIsLayoutOptimalForPlayback: boolean; + msHorizontalMirror: boolean; + onMSVideoFormatChanged: (ev: any) => any; + addEventListener(type: "MSVideoFormatChanged", listener: (ev: any) => any, useCapture?: boolean): void; + msZoom: boolean; + msInsertVideoEffect(activatableClassId: string, effectRequired: boolean, config?: any): void; + msSetVideoRectangle(left: number, top: number, right: number, bottom: number): void; + msFrameStep(forward: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface SVGFEComponentTransferElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + in1: SVGAnimatedString; +} +declare var SVGFEComponentTransferElement: { + prototype: SVGFEComponentTransferElement; + new (): SVGFEComponentTransferElement; +} + +interface SVGFEDiffuseLightingElement extends SVGElement, SVGFilterPrimitiveStandardAttributes { + kernelUnitLengthY: SVGAnimatedNumber; + surfaceScale: SVGAnimatedNumber; + in1: SVGAnimatedString; + kernelUnitLengthX: SVGAnimatedNumber; + diffuseConstant: SVGAnimatedNumber; +} +declare var SVGFEDiffuseLightingElement: { + prototype: SVGFEDiffuseLightingElement; + new (): SVGFEDiffuseLightingElement; +} + +interface MSCSSMatrix { + m24: number; + m34: number; + a: number; + d: number; + m32: number; + m41: number; + m11: number; + f: number; + e: number; + m23: number; + m14: number; + m33: number; + m22: number; + m21: number; + c: number; + m12: number; + b: number; + m42: number; + m31: number; + m43: number; + m13: number; + m44: number; + multiply(secondMatrix: MSCSSMatrix): MSCSSMatrix; + skewY(angle: number): MSCSSMatrix; + setMatrixValue(value: string): void; + inverse(): MSCSSMatrix; + rotateAxisAngle(x: number, y: number, z: number, angle: number): MSCSSMatrix; + toString(): string; + rotate(angleX: number, angleY?: number, angleZ?: number): MSCSSMatrix; + translate(x: number, y: number, z?: number): MSCSSMatrix; + scale(scaleX: number, scaleY?: number, scaleZ?: number): MSCSSMatrix; + skewX(angle: number): MSCSSMatrix; +} +declare var MSCSSMatrix: { + prototype: MSCSSMatrix; + new (text?: string): MSCSSMatrix; +} + +interface Worker extends AbstractWorker { + onmessage: (ev: any) => any; + addEventListener(type: "message", listener: (ev: any) => any, useCapture?: boolean): void; + postMessage(message: any, ports?: any): void; + terminate(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var Worker: { + prototype: Worker; + new (stringUrl: string): Worker; +} + +interface HTMLIFrameElement { + sandbox: DOMSettableTokenList; +} + +declare var onmspointerdown: (ev: any) => any; +declare function addEventListener(type: "mspointerdown", listener: (ev: any) => any, useCapture?: boolean): void; +declare var animationStartTime: number; +declare var onmsgesturedoubletap: (ev: any) => any; +declare function addEventListener(type: "msgesturedoubletap", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmspointerhover: (ev: any) => any; +declare function addEventListener(type: "mspointerhover", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmsgesturehold: (ev: any) => any; +declare function addEventListener(type: "msgesturehold", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmspointermove: (ev: any) => any; +declare function addEventListener(type: "mspointermove", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmsgesturechange: (ev: any) => any; +declare function addEventListener(type: "msgesturechange", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmsgesturestart: (ev: any) => any; +declare function addEventListener(type: "msgesturestart", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmspointercancel: (ev: any) => any; +declare function addEventListener(type: "mspointercancel", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmsgestureend: (ev: any) => any; +declare function addEventListener(type: "msgestureend", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmsgesturetap: (ev: any) => any; +declare function addEventListener(type: "msgesturetap", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmspointerout: (ev: any) => any; +declare function addEventListener(type: "mspointerout", listener: (ev: any) => any, useCapture?: boolean): void; +declare var msAnimationStartTime: number; +declare var applicationCache: ApplicationCache; +declare var onmsinertiastart: (ev: any) => any; +declare function addEventListener(type: "msinertiastart", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onmspointerover: (ev: any) => any; +declare function addEventListener(type: "mspointerover", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onpopstate: (ev: PopStateEvent) => any; +declare function addEventListener(type: "popstate", listener: (ev: PopStateEvent) => any, useCapture?: boolean): void; +declare var onmspointerup: (ev: any) => any; +declare function addEventListener(type: "mspointerup", listener: (ev: any) => any, useCapture?: boolean): void; +declare function msCancelRequestAnimationFrame(handle: number): void; +declare function matchMedia(mediaQuery: string): MediaQueryList; +declare function cancelAnimationFrame(handle: number): void; +declare function msIsStaticHTML(html: string): boolean; +declare function msMatchMedia(mediaQuery: string): MediaQueryList; +declare function requestAnimationFrame(callback: FrameRequestCallback): number; +declare function msRequestAnimationFrame(callback: FrameRequestCallback): number; +declare function btoa(rawString: string): string; +declare function atob(encodedString: string): string; +declare var msIndexedDB: IDBFactory; +declare var indexedDB: IDBFactory; +declare var console: Console; + +///////////////////////////// +/// IE11 APIs +///////////////////////////// + + + +interface StoreExceptionsInformation extends ExceptionInformation { + siteName?: string; + explanationString?: string; + detailURI?: string; +} + +interface StoreSiteSpecificExceptionsInformation extends StoreExceptionsInformation { + arrayOfDomainStrings?: Array; +} + +interface ConfirmSiteSpecificExceptionsInformation extends ExceptionInformation { + arrayOfDomainStrings?: Array; +} + +interface AlgorithmParameters { +} + +interface MutationObserverInit { + childList?: boolean; + attributes?: boolean; + characterData?: boolean; + subtree?: boolean; + attributeOldValue?: boolean; + characterDataOldValue?: boolean; + attributeFilter?: Array; +} + +interface ExceptionInformation { + domain?: string; +} + +interface MsZoomToOptions { + contentX?: number; + contentY?: number; + viewportX?: string; + viewportY?: string; + scaleFactor?: number; + animate?: string; +} + +interface DeviceAccelerationDict { + x?: number; + y?: number; + z?: number; +} + +interface DeviceRotationRateDict { + alpha?: number; + beta?: number; + gamma?: number; +} + +interface Algorithm { + name?: string; + params?: AlgorithmParameters; +} + +interface NavigatorID { + product: string; + vendor: string; +} +declare var NavigatorID: { + prototype: NavigatorID; + new (): NavigatorID; +} + +interface HTMLBodyElement { + onpageshow: (ev: PageTransitionEvent) => any; + addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; + onpagehide: (ev: PageTransitionEvent) => any; + addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; +} + +interface MSExecAtPriorityFunctionCallback { + (...args: any[]): any; +} + +interface MSWindowExtensions { + captureEvents(): void; + releaseEvents(): void; +} +declare var MSWindowExtensions: { + prototype: MSWindowExtensions; + new (): MSWindowExtensions; +} + +interface MSGraphicsTrust { + status: string; + constrictionActive: boolean; +} +declare var MSGraphicsTrust: { + prototype: MSGraphicsTrust; + new (): MSGraphicsTrust; +} + +interface AudioTrack { + sourceBuffer: SourceBuffer; +} + +interface DragEvent { + msConvertURL(file: File, targetType: string, targetURL?: string): boolean; +} + +interface SubtleCrypto { + unwrapKey(wrappedKey: ArrayBufferView, keyAlgorithm: any, keyEncryptionKey: Key, extractable?: boolean, keyUsages?: string[]): KeyOperation; + encrypt(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation; + importKey(format: string, keyData: ArrayBufferView, algorithm: any, extractable?: boolean, keyUsages?: string[]): KeyOperation; + wrapKey(key: Key, keyEncryptionKey: Key, keyWrappingAlgorithm: any): KeyOperation; + verify(algorithm: any, key: Key, signature: ArrayBufferView, buffer?: ArrayBufferView): CryptoOperation; + deriveKey(algorithm: any, baseKey: Key, derivedKeyType: any, extractable?: boolean, keyUsages?: string[]): KeyOperation; + digest(algorithm: any, buffer?: ArrayBufferView): CryptoOperation; + exportKey(format: string, key: Key): KeyOperation; + generateKey(algorithm: any, extractable?: boolean, keyUsages?: string[]): KeyOperation; + sign(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation; + decrypt(algorithm: any, key: Key, buffer?: ArrayBufferView): CryptoOperation; +} +declare var SubtleCrypto: { + prototype: SubtleCrypto; + new (): SubtleCrypto; +} + +interface Crypto extends RandomSource { + subtle: SubtleCrypto; +} +declare var Crypto: { + prototype: Crypto; + new (): Crypto; +} + +interface VideoPlaybackQuality { + creationTime: number; + totalVideoFrames: number; + droppedVideoFrames: number; +} +declare var VideoPlaybackQuality: { + prototype: VideoPlaybackQuality; + new (): VideoPlaybackQuality; +} + +interface Window { + onpageshow: (ev: PageTransitionEvent) => any; + addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; + ondevicemotion: (ev: DeviceMotionEvent) => any; + addEventListener(type: "devicemotion", listener: (ev: DeviceMotionEvent) => any, useCapture?: boolean): void; + devicePixelRatio: number; + msCrypto: Crypto; + ondeviceorientation: (ev: DeviceOrientationEvent) => any; + addEventListener(type: "deviceorientation", listener: (ev: DeviceOrientationEvent) => any, useCapture?: boolean): void; + onmspointerenter: (ev: any) => any; + addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void; + onpagehide: (ev: PageTransitionEvent) => any; + addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; + onmspointerleave: (ev: any) => any; + addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void; +} + +interface Key { + algorithm: Algorithm; + type: string; + extractable: boolean; + keyUsage: string[]; +} +declare var Key: { + prototype: Key; + new (): Key; +} + +interface TextTrackList extends EventTarget { + onaddtrack: (ev: any) => any; + addEventListener(type: "addtrack", listener: (ev: any) => any, useCapture?: boolean): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface DeviceAcceleration { + y: number; + x: number; + z: number; +} +declare var DeviceAcceleration: { + prototype: DeviceAcceleration; + new (): DeviceAcceleration; +} + +interface Console { + count(countTitle?: string): void; + groupEnd(): void; + time(timerName?: string): void; + timeEnd(timerName?: string): void; + trace(): void; + group(groupTitle?: string): void; + dirxml(value: any): void; + debug(message?: string, ...optionalParams: any[]): void; + groupCollapsed(groupTitle?: string): void; + select(element: Element): void; +} + +interface MSNavigatorDoNotTrack { + removeSiteSpecificTrackingException(args: ExceptionInformation): boolean; + removeWebWideTrackingException(args: ExceptionInformation): boolean; + storeWebWideTrackingException(args: StoreExceptionsInformation): void; + storeSiteSpecificTrackingException(args: StoreSiteSpecificExceptionsInformation): void; + confirmSiteSpecificTrackingException(args: ConfirmSiteSpecificExceptionsInformation): boolean; + confirmWebWideTrackingException(args: ExceptionInformation): boolean; +} +declare var MSNavigatorDoNotTrack: { + prototype: MSNavigatorDoNotTrack; + new (): MSNavigatorDoNotTrack; +} + +interface HTMLImageElement { + crossOrigin: string; +} + +interface HTMLAllCollection extends HTMLCollection { + namedItem(name: string): Element; +} +declare var HTMLAllCollection: { + prototype: HTMLAllCollection; + new (): HTMLAllCollection; +} + +interface MSNavigatorExtensions { + language: string; +} +declare var MSNavigatorExtensions: { + prototype: MSNavigatorExtensions; + new (): MSNavigatorExtensions; +} + +interface AesGcmEncryptResult { + ciphertext: ArrayBuffer; + tag: ArrayBuffer; +} +declare var AesGcmEncryptResult: { + prototype: AesGcmEncryptResult; + new (): AesGcmEncryptResult; +} + +interface CSSStyleDeclaration { + alignItems: string; + borderImageSource: string; + flexBasis: string; + borderImageWidth: string; + borderImageRepeat: string; + order: string; + flex: string; + alignContent: string; + msImeAlign: string; + flexShrink: string; + flexGrow: string; + borderImageSlice: string; + flexWrap: string; + borderImageOutset: string; + flexDirection: string; + flexFlow: string; + borderImage: string; + justifyContent: string; + alignSelf: string; + msTextCombineHorizontal: string; +} + +interface HTMLSourceElement { + msKeySystem: string; +} + +interface NavigationCompletedEvent extends NavigationEvent { + webErrorStatus: number; + isSuccess: boolean; +} +declare var NavigationCompletedEvent: { + prototype: NavigationCompletedEvent; + new (): NavigationCompletedEvent; +} + +interface MutationRecord { + oldValue: string; + previousSibling: Node; + addedNodes: NodeList; + attributeName: string; + removedNodes: NodeList; + target: Node; + nextSibling: Node; + attributeNamespace: string; + type: string; +} +declare var MutationRecord: { + prototype: MutationRecord; + new (): MutationRecord; +} + +interface Document extends MSDocumentExtensions { + msFullscreenEnabled: boolean; + onmsfullscreenerror: (ev: any) => any; + addEventListener(type: "msfullscreenerror", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerenter: (ev: any) => any; + addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void; + msFullscreenElement: Element; + onmsfullscreenchange: (ev: any) => any; + addEventListener(type: "msfullscreenchange", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerleave: (ev: any) => any; + addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void; + msExitFullscreen(): void; +} + +interface MimeTypeArray { + length: number; + item(index: number): Plugin; + [index: number]: Plugin; + namedItem(type: string): Plugin; +} +declare var MimeTypeArray: { + prototype: MimeTypeArray; + new (): MimeTypeArray; +} + +interface HTMLMediaElement { + /** + * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server. + */ + msPlayToPreferredSourceUri: string; + onmsneedkey: (ev: MSMediaKeyNeededEvent) => any; + addEventListener(type: "msneedkey", listener: (ev: MSMediaKeyNeededEvent) => any, useCapture?: boolean): void; + /** + * Gets the MSMediaKeys object, which is used for decrypting media data, that is associated with this media element. + */ + msKeys: MSMediaKeys; + msGraphicsTrustStatus: MSGraphicsTrust; + msSetMediaKeys(mediaKeys: MSMediaKeys): void; + addTextTrack(kind: string, label?: string, language?: string): TextTrack; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface TextTrack { + addCue(cue: TextTrackCue): void; + removeCue(cue: TextTrackCue): void; +} + +interface KeyOperation extends EventTarget { + oncomplete: (ev: any) => any; + addEventListener(type: "complete", listener: (ev: any) => any, useCapture?: boolean): void; + onerror: (ev: any) => any; + addEventListener(type: "error", listener: (ev: any) => any, useCapture?: boolean): void; + result: any; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var KeyOperation: { + prototype: KeyOperation; + new (): KeyOperation; +} + +interface DOMStringMap { +} +declare var DOMStringMap: { + prototype: DOMStringMap; + new (): DOMStringMap; +} + +interface DeviceOrientationEvent extends Event { + gamma: number; + alpha: number; + absolute: boolean; + beta: number; + initDeviceOrientationEvent(type: string, bubbles: boolean, cancelable: boolean, alpha: number, beta: number, gamma: number, absolute: boolean): void; +} +declare var DeviceOrientationEvent: { + prototype: DeviceOrientationEvent; + new (): DeviceOrientationEvent; +} + +interface MSMediaKeyMessageEvent extends Event { + destinationURL: string; + message: Uint8Array; +} +declare var MSMediaKeyMessageEvent: { + prototype: MSMediaKeyMessageEvent; + new (): MSMediaKeyMessageEvent; +} + +interface MSMediaKeys { + keySystem: string; + createSession(type: string, initData: Uint8Array, cdmData?: Uint8Array): MSMediaKeySession; + isTypeSupported(keySystem: string, type?: string): boolean; +} +declare var MSMediaKeys: { + prototype: MSMediaKeys; + new (): MSMediaKeys; +} + +interface MSHTMLWebViewElement extends HTMLElement { + documentTitle: string; + width: number; + src: string; + canGoForward: boolean; + height: number; + canGoBack: boolean; + navigateWithHttpRequestMessage(requestMessage: any): void; + goBack(): void; + navigate(uri: string): void; + stop(): void; + navigateToString(contents: string): void; + captureSelectedContentToDataPackageAsync(): MSWebViewAsyncOperation; + capturePreviewToBlobAsync(): MSWebViewAsyncOperation; + refresh(): void; + goForward(): void; + navigateToLocalStreamUri(source: string, streamResolver: any): void; + invokeScriptAsync(scriptName: string, ...args: any[]): MSWebViewAsyncOperation; + buildLocalStreamUri(contentIdentifier: string, relativePath: string): string; +} +declare var MSHTMLWebViewElement: { + prototype: MSHTMLWebViewElement; + new (): MSHTMLWebViewElement; +} + +interface NavigationEvent extends Event { + uri: string; +} +declare var NavigationEvent: { + prototype: NavigationEvent; + new (): NavigationEvent; +} + +interface Element { + onmspointerenter: (ev: any) => any; + addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void; + onmspointerleave: (ev: any) => any; + addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void; + msZoomTo(args: MsZoomToOptions): void; + msGetUntransformedBounds(): ClientRect; + msRequestFullscreen(): void; +} + +interface RandomSource { + getRandomValues(array: ArrayBufferView): ArrayBufferView; +} + +interface XMLHttpRequest { + msCaching: string; + msCachingEnabled(): boolean; + overrideMimeType(mime: string): void; +} + +interface SourceBuffer extends EventTarget { + updating: boolean; + appendWindowStart: number; + appendWindowEnd: number; + buffered: TimeRanges; + timestampOffset: number; + audioTracks: AudioTrackList; + appendBuffer(data: ArrayBuffer): void; + remove(start: number, end: number): void; + abort(): void; + appendStream(stream: MSStream, maxSize?: number): void; +} +declare var SourceBuffer: { + prototype: SourceBuffer; + new (): SourceBuffer; +} + +interface MSInputMethodContext extends EventTarget { + oncandidatewindowshow: (ev: any) => any; + addEventListener(type: "candidatewindowshow", listener: (ev: any) => any, useCapture?: boolean): void; + target: HTMLElement; + compositionStartOffset: number; + oncandidatewindowhide: (ev: any) => any; + addEventListener(type: "candidatewindowhide", listener: (ev: any) => any, useCapture?: boolean): void; + oncandidatewindowupdate: (ev: any) => any; + addEventListener(type: "candidatewindowupdate", listener: (ev: any) => any, useCapture?: boolean): void; + compositionEndOffset: number; + getCompositionAlternatives(): string[]; + getCandidateWindowClientRect(): ClientRect; + hasComposition(): boolean; + isCandidateWindowVisible(): boolean; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var MSInputMethodContext: { + prototype: MSInputMethodContext; + new (): MSInputMethodContext; +} + +interface DeviceRotationRate { + gamma: number; + alpha: number; + beta: number; +} +declare var DeviceRotationRate: { + prototype: DeviceRotationRate; + new (): DeviceRotationRate; +} + +interface PluginArray { + length: number; + refresh(reload?: boolean): void; + item(index: number): Plugin; + [index: number]: Plugin; + namedItem(name: string): Plugin; +} +declare var PluginArray: { + prototype: PluginArray; + new (): PluginArray; +} + +interface MSMediaKeyError { + systemCode: number; + code: number; + MS_MEDIA_KEYERR_SERVICE: number; + MS_MEDIA_KEYERR_HARDWARECHANGE: number; + MS_MEDIA_KEYERR_OUTPUT: number; + MS_MEDIA_KEYERR_DOMAIN: number; + MS_MEDIA_KEYERR_UNKNOWN: number; + MS_MEDIA_KEYERR_CLIENT: number; +} +declare var MSMediaKeyError: { + prototype: MSMediaKeyError; + new (): MSMediaKeyError; + MS_MEDIA_KEYERR_SERVICE: number; + MS_MEDIA_KEYERR_HARDWARECHANGE: number; + MS_MEDIA_KEYERR_OUTPUT: number; + MS_MEDIA_KEYERR_DOMAIN: number; + MS_MEDIA_KEYERR_UNKNOWN: number; + MS_MEDIA_KEYERR_CLIENT: number; +} + +interface Plugin { + length: number; + filename: string; + version: string; + name: string; + description: string; + item(index: number): MimeType; + [index: number]: MimeType; + namedItem(type: string): MimeType; +} +declare var Plugin: { + prototype: Plugin; + new (): Plugin; +} + +interface HTMLFrameSetElement { + onpageshow: (ev: PageTransitionEvent) => any; + addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; + onpagehide: (ev: PageTransitionEvent) => any; + addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; +} + +interface Screen extends EventTarget { + msOrientation: string; + onmsorientationchange: (ev: any) => any; + addEventListener(type: "msorientationchange", listener: (ev: any) => any, useCapture?: boolean): void; + msLockOrientation(orientations: string[]): boolean; + msUnlockOrientation(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} + +interface MediaSource extends EventTarget { + sourceBuffers: SourceBufferList; + duration: string; + readyState: any; + activeSourceBuffers: SourceBufferList; + addSourceBuffer(type: string): SourceBuffer; + endOfStream(error?: string): void; + isTypeSupported(type: string): boolean; + removeSourceBuffer(sourceBuffer: SourceBuffer): void; +} +declare var MediaSource: { + prototype: MediaSource; + new (): MediaSource; +} + +interface MediaError { + MS_MEDIA_ERR_ENCRYPTED: number; +} +//declare var MediaError: { +// prototype: MediaError; +// MS_MEDIA_ERR_ENCRYPTED: number; +//} + +interface SourceBufferList extends EventTarget { + length: number; + item(index: number): SourceBuffer; + [index: number]: SourceBuffer; +} +declare var SourceBufferList: { + prototype: SourceBufferList; + new (): SourceBufferList; +} + +interface XMLDocument extends Document { +} +declare var XMLDocument: { + prototype: XMLDocument; + new (): XMLDocument; +} + +interface DeviceMotionEvent extends Event { + rotationRate: DeviceRotationRate; + acceleration: DeviceAcceleration; + interval: number; + accelerationIncludingGravity: DeviceAcceleration; + initDeviceMotionEvent(type: string, bubbles: boolean, cancelable: boolean, acceleration: DeviceAccelerationDict, accelerationIncludingGravity: DeviceAccelerationDict, rotationRate: DeviceRotationRateDict, interval: number): void; +} +declare var DeviceMotionEvent: { + prototype: DeviceMotionEvent; + new (): DeviceMotionEvent; +} + +interface MimeType { + enabledPlugin: Plugin; + suffixes: string; + type: string; + description: string; +} +declare var MimeType: { + prototype: MimeType; + new (): MimeType; +} + +interface MSDocumentExtensions { + captureEvents(): void; + releaseEvents(): void; +} + +interface HTMLElement { + dataset: DOMStringMap; + hidden: boolean; + msGetInputContext(): MSInputMethodContext; +} + +interface MutationObserver { + observe(target: Node, options: MutationObserverInit): void; + takeRecords(): MutationRecord[]; + disconnect(): void; +} +declare var MutationObserver: { + prototype: MutationObserver; + new (callback: (arr: MutationRecord[], observer: MutationObserver)=>any): MutationObserver; +} + +interface AudioTrackList { + onremovetrack: (ev: PluginArray) => any; + //addEventListener(type: "removetrack", listener: (ev: PluginArray) => any, useCapture?: boolean): void; +} + +interface HTMLObjectElement { + /** + * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server. + */ + msPlayToPreferredSourceUri: string; + /** + * Gets or sets the primary DLNA PlayTo device. + */ + msPlayToPrimary: boolean; + /** + * Gets or sets whether the DLNA PlayTo device is available. + */ + msPlayToDisabled: boolean; + /** + * Gets the source associated with the media element for use by the PlayToManager. + */ + msPlayToSource: any; +} + +interface HTMLEmbedElement { + /** + * Gets or sets the path to the preferred media source. This enables the Play To target device to stream the media content, which can be DRM protected, from a different location, such as a cloud media server. + */ + msPlayToPreferredSourceUri: string; + /** + * Gets or sets the primary DLNA PlayTo device. + */ + msPlayToPrimary: boolean; + /** + * Gets or sets whether the DLNA PlayTo device is available. + */ + msPlayToDisabled: boolean; + /** + * Gets the source associated with the media element for use by the PlayToManager. + */ + msPlayToSource: any; +} + +interface MSWebViewAsyncOperation extends EventTarget { + target: MSHTMLWebViewElement; + oncomplete: (ev: any) => any; + addEventListener(type: "complete", listener: (ev: any) => any, useCapture?: boolean): void; + error: DOMError; + onerror: (ev: any) => any; + addEventListener(type: "error", listener: (ev: any) => any, useCapture?: boolean): void; + readyState: number; + type: number; + result: any; + start(): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; + ERROR: number; + TYPE_CREATE_DATA_PACKAGE_FROM_SELECTION: number; + TYPE_INVOKE_SCRIPT: number; + COMPLETED: number; + TYPE_CAPTURE_PREVIEW_TO_RANDOM_ACCESS_STREAM: number; + STARTED: number; +} +declare var MSWebViewAsyncOperation: { + prototype: MSWebViewAsyncOperation; + new (): MSWebViewAsyncOperation; + ERROR: number; + TYPE_CREATE_DATA_PACKAGE_FROM_SELECTION: number; + TYPE_INVOKE_SCRIPT: number; + COMPLETED: number; + TYPE_CAPTURE_PREVIEW_TO_RANDOM_ACCESS_STREAM: number; + STARTED: number; +} + +interface ScriptNotifyEvent extends Event { + value: string; + callingUri: string; +} +declare var ScriptNotifyEvent: { + prototype: ScriptNotifyEvent; + new (): ScriptNotifyEvent; +} + +interface PerformanceNavigationTiming extends PerformanceEntry { + redirectStart: number; + domainLookupEnd: number; + responseStart: number; + domComplete: number; + domainLookupStart: number; + loadEventStart: number; + unloadEventEnd: number; + fetchStart: number; + requestStart: number; + domInteractive: number; + navigationStart: number; + connectEnd: number; + loadEventEnd: number; + connectStart: number; + responseEnd: number; + domLoading: number; + redirectEnd: number; + redirectCount: number; + unloadEventStart: number; + domContentLoadedEventStart: number; + domContentLoadedEventEnd: number; + type: string; +} +declare var PerformanceNavigationTiming: { + prototype: PerformanceNavigationTiming; + new (): PerformanceNavigationTiming; +} + +interface MSMediaKeyNeededEvent extends Event { + initData: Uint8Array; +} +declare var MSMediaKeyNeededEvent: { + prototype: MSMediaKeyNeededEvent; + new (): MSMediaKeyNeededEvent; +} + +interface MSManipulationEvent { + MS_MANIPULATION_STATE_SELECTING: number; + MS_MANIPULATION_STATE_COMMITTED: number; + MS_MANIPULATION_STATE_PRESELECT: number; + MS_MANIPULATION_STATE_DRAGGING: number; + MS_MANIPULATION_STATE_CANCELLED: number; +} +//declare var MSManipulationEvent: { +// prototype: MSManipulationEvent; +// MS_MANIPULATION_STATE_SELECTING: number; +// MS_MANIPULATION_STATE_COMMITTED: number; +// MS_MANIPULATION_STATE_PRESELECT: number; +// MS_MANIPULATION_STATE_DRAGGING: number; +// MS_MANIPULATION_STATE_CANCELLED: number; +//} + +interface LongRunningScriptDetectedEvent extends Event { + stopPageScriptExecution: boolean; + executionTime: number; +} +declare var LongRunningScriptDetectedEvent: { + prototype: LongRunningScriptDetectedEvent; + new (): LongRunningScriptDetectedEvent; +} + +interface MSAppView { + viewId: number; + close(): void; + postMessage(message: any, targetOrigin: string, ports?: any): void; +} +declare var MSAppView: { + prototype: MSAppView; + new (): MSAppView; +} + +interface PerfWidgetExternal { + maxCpuSpeed: number; + performanceCounterFrequency: number; + performanceCounter: number; + averagePaintTime: number; + activeNetworkRequestCount: number; + paintRequestsPerSecond: number; + repositionWindow(x: number, y: number): void; + getRecentMemoryUsage(last: number): any; + getMemoryUsage(): number; + resizeWindow(width: number, height: number): void; + getProcessCpuUsage(): number; + removeEventListener(eventType: string, callback: (ev: any) => any): void; + getRecentCpuUsage(last: number): any; + addEventListener(eventType: string, callback: (ev: any) => any): void; + getRecentPaintRequests(last: number): any; +} +declare var PerfWidgetExternal: { + prototype: PerfWidgetExternal; + new (): PerfWidgetExternal; +} + +interface PageTransitionEvent extends Event { + persisted: boolean; +} +declare var PageTransitionEvent: { + prototype: PageTransitionEvent; + new (): PageTransitionEvent; +} + +interface MutationCallback { + (mutations: MutationRecord[], observer: MutationObserver): void; +} + +interface HTMLDocument extends Document { +} +declare var HTMLDocument: { + prototype: HTMLDocument; + new (): HTMLDocument; +} + +interface KeyPair { + privateKey: Key; + publicKey: Key; +} +declare var KeyPair: { + prototype: KeyPair; + new (): KeyPair; +} + +interface MSApp { + getViewOpener(): MSAppView; + suppressSubdownloadCredentialPrompts(suppress: boolean): void; + execAsyncAtPriority(asynchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): void; + isTaskScheduledAtPriorityOrHigher(priority: string): boolean; + execAtPriority(synchronousCallback: MSExecAtPriorityFunctionCallback, priority: string, ...args: any[]): any; + createNewView(uri: string): MSAppView; + getCurrentPriority(): string; + NORMAL: string; + HIGH: string; + IDLE: string; + CURRENT: string; +} +//declare var MSApp: { +// prototype: MSApp; +// NORMAL: string; +// HIGH: string; +// IDLE: string; +// CURRENT: string; +//} + +interface HTMLTrackElement { + readyState: number; + ERROR: number; + LOADING: number; + LOADED: number; + NONE: number; +} +//declare var HTMLTrackElement: { +// prototype: HTMLTrackElement; +// ERROR: number; +// LOADING: number; +// LOADED: number; +// NONE: number; +//} + +interface MSMediaKeySession extends EventTarget { + sessionId: string; + error: MSMediaKeyError; + keySystem: string; + close(): void; + update(key: Uint8Array): void; +} +declare var MSMediaKeySession: { + prototype: MSMediaKeySession; + new (): MSMediaKeySession; +} + +interface HTMLVideoElement { + videoPlaybackQuality: VideoPlaybackQuality; +} + +interface UnviewableContentIdentifiedEvent extends NavigationEvent { + referrer: string; +} +declare var UnviewableContentIdentifiedEvent: { + prototype: UnviewableContentIdentifiedEvent; + new (): UnviewableContentIdentifiedEvent; +} + +interface CryptoOperation extends EventTarget { + algorithm: Algorithm; + oncomplete: (ev: any) => any; + addEventListener(type: "complete", listener: (ev: any) => any, useCapture?: boolean): void; + onerror: (ev: any) => any; + addEventListener(type: "error", listener: (ev: any) => any, useCapture?: boolean): void; + onprogress: (ev: any) => any; + addEventListener(type: "progress", listener: (ev: any) => any, useCapture?: boolean): void; + onabort: (ev: any) => any; + addEventListener(type: "abort", listener: (ev: any) => any, useCapture?: boolean): void; + key: Key; + result: any; + abort(): void; + finish(): void; + process(buffer: ArrayBufferView): void; + addEventListener(type: string, listener: EventListener, useCapture?: boolean): void; +} +declare var CryptoOperation: { + prototype: CryptoOperation; + new (): CryptoOperation; +} + +declare var onpageshow: (ev: PageTransitionEvent) => any; +declare function addEventListener(type: "pageshow", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; +declare var ondevicemotion: (ev: DeviceMotionEvent) => any; +declare function addEventListener(type: "devicemotion", listener: (ev: DeviceMotionEvent) => any, useCapture?: boolean): void; +declare var devicePixelRatio: number; +declare var msCrypto: Crypto; +declare var ondeviceorientation: (ev: DeviceOrientationEvent) => any; +declare function addEventListener(type: "deviceorientation", listener: (ev: DeviceOrientationEvent) => any, useCapture?: boolean): void; +declare var onmspointerenter: (ev: any) => any; +declare function addEventListener(type: "mspointerenter", listener: (ev: any) => any, useCapture?: boolean): void; +declare var onpagehide: (ev: PageTransitionEvent) => any; +declare function addEventListener(type: "pagehide", listener: (ev: PageTransitionEvent) => any, useCapture?: boolean): void; +declare var onmspointerleave: (ev: any) => any; +declare function addEventListener(type: "mspointerleave", listener: (ev: any) => any, useCapture?: boolean): void; + + +///////////////////////////// +/// WorkerGlobalScope APIs +///////////////////////////// +// TODO: These are only available in a Web Worker - should be in a separate lib file +declare function importScripts(...urls: string[]): void; + + +///////////////////////////// +/// Windows Script Host APIS +///////////////////////////// +declare var ActiveXObject: { new (s: string): any; }; + +interface ITextWriter { + Write(s: string): void; + WriteLine(s: string): void; + Close(): void; +} + +declare var WScript: { + Echo(s: any): void; + StdErr: ITextWriter; + StdOut: ITextWriter; + Arguments: { length: number; Item(n: number): string; }; + ScriptFullName: string; + Quit(exitCode?: number): number; +} diff --git a/_infrastructure/tests/typescript/0.9.5/tsc b/_infrastructure/tests/typescript/0.9.5/tsc new file mode 100644 index 000000000..3c0dab574 --- /dev/null +++ b/_infrastructure/tests/typescript/0.9.5/tsc @@ -0,0 +1,2 @@ +#!/usr/bin/env node +require('./tsc.js') diff --git a/_infrastructure/tests/typescript/0.9.5/tsc.js b/_infrastructure/tests/typescript/0.9.5/tsc.js new file mode 100644 index 000000000..5c216746e --- /dev/null +++ b/_infrastructure/tests/typescript/0.9.5/tsc.js @@ -0,0 +1,60898 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +var TypeScript; +(function (TypeScript) { + TypeScript.DiagnosticCode = { + error_TS_0_1: "error TS{0}: {1}", + warning_TS_0_1: "warning TS{0}: {1}", + Unrecognized_escape_sequence: "Unrecognized escape sequence.", + Unexpected_character_0: "Unexpected character {0}.", + Missing_close_quote_character: "Missing close quote character.", + Identifier_expected: "Identifier expected.", + _0_keyword_expected: "'{0}' keyword expected.", + _0_expected: "'{0}' expected.", + Identifier_expected_0_is_a_keyword: "Identifier expected; '{0}' is a keyword.", + Automatic_semicolon_insertion_not_allowed: "Automatic semicolon insertion not allowed.", + Unexpected_token_0_expected: "Unexpected token; '{0}' expected.", + Trailing_separator_not_allowed: "Trailing separator not allowed.", + AsteriskSlash_expected: "'*/' expected.", + public_or_private_modifier_must_precede_static: "'public' or 'private' modifier must precede 'static'.", + Unexpected_token: "Unexpected token.", + Catch_clause_parameter_cannot_have_a_type_annotation: "Catch clause parameter cannot have a type annotation.", + Rest_parameter_must_be_last_in_list: "Rest parameter must be last in list.", + Parameter_cannot_have_question_mark_and_initializer: "Parameter cannot have question mark and initializer.", + Required_parameter_cannot_follow_optional_parameter: "Required parameter cannot follow optional parameter.", + Index_signatures_cannot_have_rest_parameters: "Index signatures cannot have rest parameters.", + Index_signature_parameter_cannot_have_accessibility_modifiers: "Index signature parameter cannot have accessibility modifiers.", + Index_signature_parameter_cannot_have_a_question_mark: "Index signature parameter cannot have a question mark.", + Index_signature_parameter_cannot_have_an_initializer: "Index signature parameter cannot have an initializer.", + Index_signature_must_have_a_type_annotation: "Index signature must have a type annotation.", + Index_signature_parameter_must_have_a_type_annotation: "Index signature parameter must have a type annotation.", + Index_signature_parameter_type_must_be_string_or_number: "Index signature parameter type must be 'string' or 'number'.", + extends_clause_already_seen: "'extends' clause already seen.", + extends_clause_must_precede_implements_clause: "'extends' clause must precede 'implements' clause.", + Classes_can_only_extend_a_single_class: "Classes can only extend a single class.", + implements_clause_already_seen: "'implements' clause already seen.", + Accessibility_modifier_already_seen: "Accessibility modifier already seen.", + _0_modifier_must_precede_1_modifier: "'{0}' modifier must precede '{1}' modifier.", + _0_modifier_already_seen: "'{0}' modifier already seen.", + _0_modifier_cannot_appear_on_a_class_element: "'{0}' modifier cannot appear on a class element.", + Interface_declaration_cannot_have_implements_clause: "Interface declaration cannot have 'implements' clause.", + super_invocation_cannot_have_type_arguments: "'super' invocation cannot have type arguments.", + Only_ambient_modules_can_use_quoted_names: "Only ambient modules can use quoted names.", + Statements_are_not_allowed_in_ambient_contexts: "Statements are not allowed in ambient contexts.", + Implementations_are_not_allowed_in_ambient_contexts: "Implementations are not allowed in ambient contexts.", + declare_modifier_not_allowed_for_code_already_in_an_ambient_context: "'declare' modifier not allowed for code already in an ambient context.", + Initializers_are_not_allowed_in_ambient_contexts: "Initializers are not allowed in ambient contexts.", + Parameter_property_declarations_can_only_be_used_in_constructors: "Parameter property declarations can only be used in constructors.", + Function_implementation_expected: "Function implementation expected.", + Constructor_implementation_expected: "Constructor implementation expected.", + Function_overload_name_must_be_0: "Function overload name must be '{0}'.", + _0_modifier_cannot_appear_on_a_module_element: "'{0}' modifier cannot appear on a module element.", + declare_modifier_cannot_appear_on_an_interface_declaration: "'declare' modifier cannot appear on an interface declaration.", + declare_modifier_required_for_top_level_element: "'declare' modifier required for top level element.", + Rest_parameter_cannot_be_optional: "Rest parameter cannot be optional.", + Rest_parameter_cannot_have_an_initializer: "Rest parameter cannot have an initializer.", + set_accessor_must_have_one_and_only_one_parameter: "'set' accessor must have one and only one parameter.", + set_accessor_parameter_cannot_be_optional: "'set' accessor parameter cannot be optional.", + set_accessor_parameter_cannot_have_an_initializer: "'set' accessor parameter cannot have an initializer.", + set_accessor_cannot_have_rest_parameter: "'set' accessor cannot have rest parameter.", + get_accessor_cannot_have_parameters: "'get' accessor cannot have parameters.", + Modifiers_cannot_appear_here: "Modifiers cannot appear here.", + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: "Accessors are only available when targeting ECMAScript 5 and higher.", + Class_name_cannot_be_0: "Class name cannot be '{0}'.", + Interface_name_cannot_be_0: "Interface name cannot be '{0}'.", + Enum_name_cannot_be_0: "Enum name cannot be '{0}'.", + Module_name_cannot_be_0: "Module name cannot be '{0}'.", + Enum_member_must_have_initializer: "Enum member must have initializer.", + Export_assignment_cannot_be_used_in_internal_modules: "Export assignment cannot be used in internal modules.", + Export_assignment_not_allowed_in_module_with_exported_element: "Export assignment not allowed in module with exported element.", + Module_cannot_have_multiple_export_assignments: "Module cannot have multiple export assignments.", + Ambient_enum_elements_can_only_have_integer_literal_initializers: "Ambient enum elements can only have integer literal initializers.", + module_class_interface_enum_import_or_statement: "module, class, interface, enum, import or statement", + constructor_function_accessor_or_variable: "constructor, function, accessor or variable", + statement: "statement", + case_or_default_clause: "case or default clause", + identifier: "identifier", + call_construct_index_property_or_function_signature: "call, construct, index, property or function signature", + expression: "expression", + type_name: "type name", + property_or_accessor: "property or accessor", + parameter: "parameter", + type: "type", + type_parameter: "type parameter", + declare_modifier_not_allowed_on_import_declaration: "'declare' modifier not allowed on import declaration.", + Function_overload_must_be_static: "Function overload must be static.", + Function_overload_must_not_be_static: "Function overload must not be static.", + Parameter_property_declarations_cannot_be_used_in_an_ambient_context: "Parameter property declarations cannot be used in an ambient context.", + Parameter_property_declarations_cannot_be_used_in_a_constructor_overload: "Parameter property declarations cannot be used in a constructor overload.", + Invalid_reference_directive_syntax: "Invalid 'reference' directive syntax.", + Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: "Octal literals are not available when targeting ECMAScript 5 and higher.", + Accessors_are_not_allowed_in_ambient_contexts: "Accessors are not allowed in ambient contexts.", + _0_modifier_cannot_appear_on_a_constructor_declaration: "'{0}' modifier cannot appear on a constructor declaration.", + _0_modifier_cannot_appear_on_a_parameter: "'{0}' modifier cannot appear on a parameter.", + Duplicate_identifier_0: "Duplicate identifier '{0}'.", + The_name_0_does_not_exist_in_the_current_scope: "The name '{0}' does not exist in the current scope.", + The_name_0_does_not_refer_to_a_value: "The name '{0}' does not refer to a value.", + super_can_only_be_used_inside_a_class_instance_method: "'super' can only be used inside a class instance method.", + The_left_hand_side_of_an_assignment_expression_must_be_a_variable_property_or_indexer: "The left-hand side of an assignment expression must be a variable, property or indexer.", + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: "Value of type '{0}' is not callable. Did you mean to include 'new'?", + Value_of_type_0_is_not_callable: "Value of type '{0}' is not callable.", + Value_of_type_0_is_not_newable: "Value of type '{0}' is not newable.", + Value_of_type_0_is_not_indexable_by_type_1: "Value of type '{0}' is not indexable by type '{1}'.", + Operator_0_cannot_be_applied_to_types_1_and_2: "Operator '{0}' cannot be applied to types '{1}' and '{2}'.", + Operator_0_cannot_be_applied_to_types_1_and_2_3: "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}", + Cannot_convert_0_to_1: "Cannot convert '{0}' to '{1}'.", + Cannot_convert_0_to_1_NL_2: "Cannot convert '{0}' to '{1}':{NL}{2}", + Expected_var_class_interface_or_module: "Expected var, class, interface, or module.", + Operator_0_cannot_be_applied_to_type_1: "Operator '{0}' cannot be applied to type '{1}'.", + Getter_0_already_declared: "Getter '{0}' already declared.", + Setter_0_already_declared: "Setter '{0}' already declared.", + Exported_class_0_extends_private_class_1: "Exported class '{0}' extends private class '{1}'.", + Exported_class_0_implements_private_interface_1: "Exported class '{0}' implements private interface '{1}'.", + Exported_interface_0_extends_private_interface_1: "Exported interface '{0}' extends private interface '{1}'.", + Exported_class_0_extends_class_from_inaccessible_module_1: "Exported class '{0}' extends class from inaccessible module {1}.", + Exported_class_0_implements_interface_from_inaccessible_module_1: "Exported class '{0}' implements interface from inaccessible module {1}.", + Exported_interface_0_extends_interface_from_inaccessible_module_1: "Exported interface '{0}' extends interface from inaccessible module {1}.", + Public_static_property_0_of_exported_class_has_or_is_using_private_type_1: "Public static property '{0}' of exported class has or is using private type '{1}'.", + Public_property_0_of_exported_class_has_or_is_using_private_type_1: "Public property '{0}' of exported class has or is using private type '{1}'.", + Property_0_of_exported_interface_has_or_is_using_private_type_1: "Property '{0}' of exported interface has or is using private type '{1}'.", + Exported_variable_0_has_or_is_using_private_type_1: "Exported variable '{0}' has or is using private type '{1}'.", + Public_static_property_0_of_exported_class_is_using_inaccessible_module_1: "Public static property '{0}' of exported class is using inaccessible module {1}.", + Public_property_0_of_exported_class_is_using_inaccessible_module_1: "Public property '{0}' of exported class is using inaccessible module {1}.", + Property_0_of_exported_interface_is_using_inaccessible_module_1: "Property '{0}' of exported interface is using inaccessible module {1}.", + Exported_variable_0_is_using_inaccessible_module_1: "Exported variable '{0}' is using inaccessible module {1}.", + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.", + Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.", + Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.", + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.", + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.", + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.", + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public method from exported class has or is using private type '{1}'.", + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of method from exported interface has or is using private type '{1}'.", + Parameter_0_of_exported_function_has_or_is_using_private_type_1: "Parameter '{0}' of exported function has or is using private type '{1}'.", + Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.", + Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.", + Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.", + Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.", + Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}", + Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.", + Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public method from exported class is using inaccessible module {1}.", + Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of method from exported interface is using inaccessible module {1}.", + Parameter_0_of_exported_function_is_using_inaccessible_module_1: "Parameter '{0}' of exported function is using inaccessible module {1}.", + Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public static property getter from exported class has or is using private type '{0}'.", + Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public property getter from exported class has or is using private type '{0}'.", + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of constructor signature from exported interface has or is using private type '{0}'.", + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of call signature from exported interface has or is using private type '{0}'.", + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of index signature from exported interface has or is using private type '{0}'.", + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public static method from exported class has or is using private type '{0}'.", + Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public method from exported class has or is using private type '{0}'.", + Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0: "Return type of method from exported interface has or is using private type '{0}'.", + Return_type_of_exported_function_has_or_is_using_private_type_0: "Return type of exported function has or is using private type '{0}'.", + Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public static property getter from exported class is using inaccessible module {0}.", + Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public property getter from exported class is using inaccessible module {0}.", + Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of constructor signature from exported interface is using inaccessible module {0}.", + Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of call signature from exported interface is using inaccessible module {0}.", + Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of index signature from exported interface is using inaccessible module {0}.", + Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public static method from exported class is using inaccessible module {0}.", + Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public method from exported class is using inaccessible module {0}.", + Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0: "Return type of method from exported interface is using inaccessible module {0}.", + Return_type_of_exported_function_is_using_inaccessible_module_0: "Return type of exported function is using inaccessible module {0}.", + new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: "'new T[]' cannot be used to create an array. Use 'new Array()' instead.", + A_parameter_list_must_follow_a_generic_type_argument_list_expected: "A parameter list must follow a generic type argument list. '(' expected.", + Multiple_constructor_implementations_are_not_allowed: "Multiple constructor implementations are not allowed.", + Unable_to_resolve_external_module_0: "Unable to resolve external module '{0}'.", + Module_cannot_be_aliased_to_a_non_module_type: "Module cannot be aliased to a non-module type.", + A_class_may_only_extend_another_class: "A class may only extend another class.", + A_class_may_only_implement_another_class_or_interface: "A class may only implement another class or interface.", + An_interface_may_only_extend_another_class_or_interface: "An interface may only extend another class or interface.", + Unable_to_resolve_type: "Unable to resolve type.", + Unable_to_resolve_type_of_0: "Unable to resolve type of '{0}'.", + Unable_to_resolve_type_parameter_constraint: "Unable to resolve type parameter constraint.", + Type_parameter_constraint_cannot_be_a_primitive_type: "Type parameter constraint cannot be a primitive type.", + Supplied_parameters_do_not_match_any_signature_of_call_target: "Supplied parameters do not match any signature of call target.", + Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0: "Supplied parameters do not match any signature of call target:{NL}{0}", + Invalid_new_expression: "Invalid 'new' expression.", + Call_signatures_used_in_a_new_expression_must_have_a_void_return_type: "Call signatures used in a 'new' expression must have a 'void' return type.", + Could_not_select_overload_for_new_expression: "Could not select overload for 'new' expression.", + Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2: "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.", + Could_not_select_overload_for_call_expression: "Could not select overload for 'call' expression.", + Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: "Cannot invoke an expression whose type lacks a call signature.", + Calls_to_super_are_only_valid_inside_a_class: "Calls to 'super' are only valid inside a class.", + Generic_type_0_requires_1_type_argument_s: "Generic type '{0}' requires {1} type argument(s).", + Type_of_array_literal_cannot_be_determined_Best_common_type_could_not_be_found_for_array_elements: "Type of array literal cannot be determined. Best common type could not be found for array elements.", + Could_not_find_enclosing_symbol_for_dotted_name_0: "Could not find enclosing symbol for dotted name '{0}'.", + The_property_0_does_not_exist_on_value_of_type_1: "The property '{0}' does not exist on value of type '{1}'.", + Could_not_find_symbol_0: "Could not find symbol '{0}'.", + get_and_set_accessor_must_have_the_same_type: "'get' and 'set' accessor must have the same type.", + this_cannot_be_referenced_in_current_location: "'this' cannot be referenced in current location.", + Static_methods_cannot_reference_class_type_parameters: "Static methods cannot reference class type parameters.", + Class_0_is_recursively_referenced_as_a_base_type_of_itself: "Class '{0}' is recursively referenced as a base type of itself.", + Interface_0_is_recursively_referenced_as_a_base_type_of_itself: "Interface '{0}' is recursively referenced as a base type of itself.", + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.", + super_cannot_be_referenced_in_non_derived_classes: "'super' cannot be referenced in non-derived classes.", + A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.", + Constructors_for_derived_classes_must_contain_a_super_call: "Constructors for derived classes must contain a 'super' call.", + Super_calls_are_not_permitted_outside_constructors_or_in_local_functions_inside_constructors: "Super calls are not permitted outside constructors or in local functions inside constructors.", + _0_1_is_inaccessible: "'{0}.{1}' is inaccessible.", + this_cannot_be_referenced_within_module_bodies: "'this' cannot be referenced within module bodies.", + Invalid_expression_types_not_known_to_support_the_addition_operator: "Invalid '+' expression - types not known to support the addition operator.", + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.", + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.", + The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type: "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.", + Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation: "Variable declarations of a 'for' statement cannot use a type annotation.", + Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any: "Variable declarations of a 'for' statement must be of types 'string' or 'any'.", + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.", + The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number: "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.", + The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.", + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.", + The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_a_subtype_of_the_Function_interface_type: "The right-hand side of an 'instanceof' expression must be of type 'any' or a subtype of the 'Function' interface type.", + Setters_cannot_return_a_value: "Setters cannot return a value.", + Tried_to_query_type_of_uninitialized_module_0: "Tried to query type of uninitialized module '{0}'.", + Tried_to_set_variable_type_to_uninitialized_module_type_0: "Tried to set variable type to uninitialized module type '{0}'.", + Function_0_declared_a_non_void_return_type_but_has_no_return_expression: "Function '{0}' declared a non-void return type, but has no return expression.", + Getters_must_return_a_value: "Getters must return a value.", + Getter_and_setter_accessors_do_not_agree_in_visibility: "Getter and setter accessors do not agree in visibility.", + Invalid_left_hand_side_of_assignment_expression: "Invalid left-hand side of assignment expression.", + Function_declared_a_non_void_return_type_but_has_no_return_expression: "Function declared a non-void return type, but has no return expression.", + Cannot_resolve_return_type_reference: "Cannot resolve return type reference.", + Constructors_cannot_have_a_return_type_of_void: "Constructors cannot have a return type of 'void'.", + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'.", + All_symbols_within_a_with_block_will_be_resolved_to_any: "All symbols within a with block will be resolved to 'any'.", + Import_declarations_in_an_internal_module_cannot_reference_an_external_module: "Import declarations in an internal module cannot reference an external module.", + Class_0_declares_interface_1_but_does_not_implement_it_NL_2: "Class {0} declares interface {1} but does not implement it:{NL}{2}", + Class_0_declares_class_1_as_an_interface_but_does_not_implement_it_NL_2: "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}", + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: "The operand of an increment or decrement operator must be a variable, property or indexer.", + this_cannot_be_referenced_in_static_initializers_in_a_class_body: "'this' cannot be referenced in static initializers in a class body.", + Class_0_cannot_extend_class_1_NL_2: "Class '{0}' cannot extend class '{1}':{NL}{2}", + Interface_0_cannot_extend_class_1_NL_2: "Interface '{0}' cannot extend class '{1}':{NL}{2}", + Interface_0_cannot_extend_interface_1_NL_2: "Interface '{0}' cannot extend interface '{1}':{NL}{2}", + Duplicate_overload_signature_for_0: "Duplicate overload signature for '{0}'.", + Duplicate_constructor_overload_signature: "Duplicate constructor overload signature.", + Duplicate_overload_call_signature: "Duplicate overload call signature.", + Duplicate_overload_construct_signature: "Duplicate overload construct signature.", + Overload_signature_is_not_compatible_with_function_definition: "Overload signature is not compatible with function definition.", + Overload_signature_is_not_compatible_with_function_definition_NL_0: "Overload signature is not compatible with function definition:{NL}{0}", + Overload_signatures_must_all_be_public_or_private: "Overload signatures must all be public or private.", + Overload_signatures_must_all_be_exported_or_not_exported: "Overload signatures must all be exported or not exported.", + Overload_signatures_must_all_be_ambient_or_non_ambient: "Overload signatures must all be ambient or non-ambient.", + Overload_signatures_must_all_be_optional_or_required: "Overload signatures must all be optional or required.", + Specialized_overload_signature_is_not_subtype_of_any_non_specialized_signature: "Specialized overload signature is not subtype of any non-specialized signature.", + this_cannot_be_referenced_in_constructor_arguments: "'this' cannot be referenced in constructor arguments.", + Instance_member_cannot_be_accessed_off_a_class: "Instance member cannot be accessed off a class.", + Untyped_function_calls_may_not_accept_type_arguments: "Untyped function calls may not accept type arguments.", + Non_generic_functions_may_not_accept_type_arguments: "Non-generic functions may not accept type arguments.", + A_generic_type_may_not_reference_itself_with_a_wrapped_form_of_its_own_type_parameters: "A generic type may not reference itself with a wrapped form of its own type parameters.", + Rest_parameters_must_be_array_types: "Rest parameters must be array types.", + Overload_signature_implementation_cannot_use_specialized_type: "Overload signature implementation cannot use specialized type.", + Export_assignments_may_only_be_used_at_the_top_level_of_external_modules: "Export assignments may only be used at the top-level of external modules.", + Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.", + Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword: "Only public methods of the base class are accessible via the 'super' keyword.", + Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1: "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}'.", + Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1_NL_2: "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}':{NL}{2}", + All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0: "All numerically named properties must be subtypes of numeric indexer type '{0}'.", + All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0_NL_1: "All numerically named properties must be subtypes of numeric indexer type '{0}':{NL}{1}", + All_named_properties_must_be_subtypes_of_string_indexer_type_0: "All named properties must be subtypes of string indexer type '{0}'.", + All_named_properties_must_be_subtypes_of_string_indexer_type_0_NL_1: "All named properties must be subtypes of string indexer type '{0}':{NL}{1}", + Generic_type_references_must_include_all_type_arguments: "Generic type references must include all type arguments.", + Default_arguments_are_not_allowed_in_an_overload_parameter: "Default arguments are not allowed in an overload parameter.", + Overloads_cannot_differ_only_by_return_type: "Overloads cannot differ only by return type.", + Function_expression_declared_a_non_void_return_type_but_has_no_return_expression: "Function expression declared a non-void return type, but has no return expression.", + Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.", + Could_not_find_symbol_0_in_module_1: "Could not find symbol '{0}' in module '{1}'.", + Unable_to_resolve_module_reference_0: "Unable to resolve module reference '{0}'.", + Could_not_find_module_0_in_module_1: "Could not find module '{0}' in module '{1}'.", + Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.", + Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.", + Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.", + Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.", + Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.", + Type_reference_0_in_extends_clause_does_not_reference_constructor_function_for_1: "Type reference '{0}' in extends clause does not reference constructor function for '{1}'.", + Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1: "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.", + Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2: "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.", + Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}", + Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.", + Ambient_external_module_declaration_cannot_be_reopened: "Ambient external module declaration cannot be reopened.", + All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported: "All declarations of merged declaration '{0}' must be exported or not exported.", + super_cannot_be_referenced_in_constructor_arguments: "'super' cannot be referenced in constructor arguments.", + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: "Return type of constructor signature must be assignable to the instance type of the class.", + Ambient_external_module_declaration_must_be_defined_in_global_context: "Ambient external module declaration must be defined in global context.", + Ambient_external_module_declaration_cannot_specify_relative_module_name: "Ambient external module declaration cannot specify relative module name.", + Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.", + Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions: "Could not find the best common type of types of all return statement expressions.", + Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set: "Import declaration cannot refer to external module reference when --noResolve option is set.", + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.", + continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: "'continue' statement can only be used within an enclosing iteration statement.", + break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: "'break' statement can only be used within an enclosing iteration or switch statement.", + Jump_target_not_found: "Jump target not found.", + Jump_target_cannot_cross_function_boundary: "Jump target cannot cross function boundary.", + Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.", + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.", + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: "Expression resolves to '_super' that compiler uses to capture base class reference.", + TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.", + TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.", + TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_exported_function_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported function has or is using private type '{1}'.", + TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.", + TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}", + TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.", + TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.", + TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.", + TypeParameter_0_of_exported_function_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported function is using inaccessible module {1}.", + TypeParameter_0_of_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported class has or is using private type '{1}'.", + TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported interface has or is using private type '{1}'.", + TypeParameter_0_of_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported class is using inaccessible module {1}.", + TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported interface is using inaccessible module {1}.", + Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter: "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.", + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.", + Type_of_conditional_0_must_be_identical_to_1_or_2: "Type of conditional '{0}' must be identical to '{1}' or '{2}'.", + Type_of_conditional_0_must_be_identical_to_1_2_or_3: "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.", + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.", + Type_0_is_missing_property_1_from_type_2: "Type '{0}' is missing property '{1}' from type '{2}'.", + Types_of_property_0_of_types_1_and_2_are_incompatible: "Types of property '{0}' of types '{1}' and '{2}' are incompatible.", + Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3: "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}", + Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.", + Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.", + Types_0_and_1_define_property_2_as_private: "Types '{0}' and '{1}' define property '{2}' as private.", + Call_signatures_of_types_0_and_1_are_incompatible: "Call signatures of types '{0}' and '{1}' are incompatible.", + Call_signatures_of_types_0_and_1_are_incompatible_NL_2: "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Type_0_requires_a_call_signature_but_type_1_lacks_one: "Type '{0}' requires a call signature, but type '{1}' lacks one.", + Construct_signatures_of_types_0_and_1_are_incompatible: "Construct signatures of types '{0}' and '{1}' are incompatible.", + Construct_signatures_of_types_0_and_1_are_incompatible_NL_2: "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Type_0_requires_a_construct_signature_but_type_1_lacks_one: "Type '{0}' requires a construct signature, but type '{1}' lacks one.", + Index_signatures_of_types_0_and_1_are_incompatible: "Index signatures of types '{0}' and '{1}' are incompatible.", + Index_signatures_of_types_0_and_1_are_incompatible_NL_2: "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Call_signature_expects_0_or_fewer_parameters: "Call signature expects {0} or fewer parameters.", + Could_not_apply_type_0_to_argument_1_which_is_of_type_2: "Could not apply type '{0}' to argument {1} which is of type '{2}'.", + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.", + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.", + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.", + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.", + Types_of_static_property_0_of_class_1_and_class_2_are_incompatible: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.", + Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}", + Type_reference_cannot_refer_to_container_0: "Type reference cannot refer to container '{0}'.", + Type_reference_must_refer_to_type: "Type reference must refer to type.", + Enums_with_multiple_declarations_must_provide_an_initializer_for_the_first_enum_element: "Enums with multiple declarations must provide an initializer for the first enum element.", + _0_overload_s: " (+ {0} overload(s))", + Variable_declaration_cannot_have_the_same_name_as_an_import_declaration: "Variable declaration cannot have the same name as an import declaration.", + Signature_expected_0_type_arguments_got_1_instead: "Signature expected {0} type arguments, got {1} instead.", + Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2: "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_do_not_refer_to_same_named_type: "Types '{0}' and '{1}' originating in inifinitely expanding type reference do not refer to same named type.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments: "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2: "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments:{NL}{2}", + Types_of_property_0_of_types_1_and_2_are_not_identical: "Types of property '{0}' of types '{1}' and '{2}' are not identical.", + Types_of_string_indexer_of_types_0_and_1_are_not_identical: "Types of string indexer of types '{0}' and '{1}' are not identical.", + Types_of_number_indexer_of_types_0_and_1_are_not_identical: "Types of number indexer of types '{0}' and '{1}' are not identical.", + Type_of_number_indexer_in_type_0_is_not_a_subtype_of_string_indexer_type_in_type_1_NL_2: "Type of number indexer in type '{0}' is not a subtype of string indexer type in type '{1}'.{NL}{2}", + Type_of_property_0_in_type_1_is_not_a_subtype_of_string_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not a subtype of string indexer type in type '{2}'.{NL}{3}", + Type_of_property_0_in_type_1_is_not_a_subtype_of_number_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not a subtype of number indexer type in type '{2}'.{NL}{3}", + Current_host_does_not_support_0_option: "Current host does not support '{0}' option.", + ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2: "ECMAScript target version '{0}' not supported. Specify a valid target version: '{1}' (default), or '{2}'", + Module_code_generation_0_not_supported: "Module code generation '{0}' not supported.", + Could_not_find_file_0: "Could not find file: '{0}'.", + A_file_cannot_have_a_reference_to_itself: "A file cannot have a reference to itself.", + Cannot_resolve_referenced_file_0: "Cannot resolve referenced file: '{0}'.", + Cannot_find_the_common_subdirectory_path_for_the_input_files: "Cannot find the common subdirectory path for the input files.", + Emit_Error_0: "Emit Error: {0}.", + Cannot_read_file_0_1: "Cannot read file '{0}': {1}", + Unsupported_file_encoding: "Unsupported file encoding.", + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: "Locale must be of the form or -. For example '{0}' or '{1}'.", + Unsupported_locale_0: "Unsupported locale: '{0}'.", + Execution_Failed_NL: "Execution Failed.{NL}", + Invalid_call_to_up: "Invalid call to 'up'", + Invalid_call_to_down: "Invalid call to 'down'", + Base64_value_0_finished_with_a_continuation_bit: "Base64 value '{0}' finished with a continuation bit.", + Unknown_option_0: "Unknown option '{0}'", + Expected_0_arguments_to_message_got_1_instead: "Expected {0} arguments to message, got {1} instead.", + Expected_the_message_0_to_have_1_arguments_but_it_had_2: "Expected the message '{0}' to have {1} arguments, but it had {2}", + Could_not_delete_file_0: "Could not delete file '{0}'", + Could_not_create_directory_0: "Could not create directory '{0}'", + Error_while_executing_file_0: "Error while executing file '{0}': ", + Cannot_compile_external_modules_unless_the_module_flag_is_provided: "Cannot compile external modules unless the '--module' flag is provided.", + Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option mapRoot cannot be specified without specifying sourcemap option.", + Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option sourceRoot cannot be specified without specifying sourcemap option.", + Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.", + Option_0_specified_without_1: "Option '{0}' specified without '{1}'", + codepage_option_not_supported_on_current_platform: "'codepage' option not supported on current platform.", + Concatenate_and_emit_output_to_single_file: "Concatenate and emit output to single file.", + Generates_corresponding_0_file: "Generates corresponding {0} file.", + Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: "Specifies the location where debugger should locate map files instead of generated locations.", + Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: "Specifies the location where debugger should locate TypeScript files instead of source locations.", + Watch_input_files: "Watch input files.", + Redirect_output_structure_to_the_directory: "Redirect output structure to the directory.", + Do_not_emit_comments_to_output: "Do not emit comments to output.", + Skip_resolution_and_preprocessing: "Skip resolution and preprocessing.", + Specify_ECMAScript_target_version_0_default_or_1: "Specify ECMAScript target version: '{0}' (default), or '{1}'", + Specify_module_code_generation_0_or_1: "Specify module code generation: '{0}' or '{1}'", + Print_this_message: "Print this message.", + Print_the_compiler_s_version_0: "Print the compiler's version: {0}", + Allow_use_of_deprecated_0_keyword_when_referencing_an_external_module: "Allow use of deprecated '{0}' keyword when referencing an external module.", + Specify_locale_for_errors_and_messages_For_example_0_or_1: "Specify locale for errors and messages. For example '{0}' or '{1}'", + Syntax_0: "Syntax: {0}", + options: "options", + file1: "file", + Examples: "Examples:", + Options: "Options:", + Insert_command_line_options_and_files_from_a_file: "Insert command line options and files from a file.", + Version_0: "Version {0}", + Use_the_0_flag_to_see_options: "Use the '{0}' flag to see options.", + NL_Recompiling_0: "{NL}Recompiling ({0}):", + STRING: "STRING", + KIND: "KIND", + file2: "FILE", + VERSION: "VERSION", + LOCATION: "LOCATION", + DIRECTORY: "DIRECTORY", + NUMBER: "NUMBER", + Specify_the_codepage_to_use_when_opening_source_files: "Specify the codepage to use when opening source files.", + This_version_of_the_Javascript_runtime_does_not_support_the_0_function: "This version of the Javascript runtime does not support the '{0}' function.", + Unknown_rule: "Unknown rule.", + Invalid_line_number_0: "Invalid line number ({0})", + Warn_on_expressions_and_declarations_with_an_implied_any_type: "Warn on expressions and declarations with an implied 'any' type.", + Variable_0_implicitly_has_an_any_type: "Variable '{0}' implicitly has an 'any' type.", + Parameter_0_of_1_implicitly_has_an_any_type: "Parameter '{0}' of '{1}' implicitly has an 'any' type.", + Parameter_0_of_function_type_implicitly_has_an_any_type: "Parameter '{0}' of function type implicitly has an 'any' type.", + Member_0_of_object_type_implicitly_has_an_any_type: "Member '{0}' of object type implicitly has an 'any' type.", + new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type: "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.", + _0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.", + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.", + Parameter_0_of_lambda_function_implicitly_has_an_any_type: "Parameter '{0}' of lambda function implicitly has an 'any' type.", + Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.", + Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.", + Array_Literal_implicitly_has_an_any_type_from_widening: "Array Literal implicitly has an 'any' type from widening.", + _0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type: "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type." + }; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ArrayUtilities = (function () { + function ArrayUtilities() { + } + ArrayUtilities.isArray = function (value) { + return Object.prototype.toString.apply(value, []) === '[object Array]'; + }; + + ArrayUtilities.sequenceEquals = function (array1, array2, equals) { + if (array1 === array2) { + return true; + } + + if (array1 === null || array2 === null) { + return false; + } + + if (array1.length !== array2.length) { + return false; + } + + for (var i = 0, n = array1.length; i < n; i++) { + if (!equals(array1[i], array2[i])) { + return false; + } + } + + return true; + }; + + ArrayUtilities.contains = function (array, value) { + for (var i = 0; i < array.length; i++) { + if (array[i] === value) { + return true; + } + } + + return false; + }; + + ArrayUtilities.groupBy = function (array, func) { + var result = {}; + + for (var i = 0, n = array.length; i < n; i++) { + var v = array[i]; + var k = func(v); + + var list = result[k] || []; + list.push(v); + result[k] = list; + } + + return result; + }; + + ArrayUtilities.distinct = function (array, equalsFn) { + var result = []; + + for (var i = 0, n = array.length; i < n; i++) { + var current = array[i]; + for (var j = 0; j < result.length; j++) { + if (equalsFn(result[j], current)) { + break; + } + } + + if (j === result.length) { + result.push(current); + } + } + + return result; + }; + + ArrayUtilities.min = function (array, func) { + var min = func(array[0]); + + for (var i = 1; i < array.length; i++) { + var next = func(array[i]); + if (next < min) { + min = next; + } + } + + return min; + }; + + ArrayUtilities.max = function (array, func) { + var max = func(array[0]); + + for (var i = 1; i < array.length; i++) { + var next = func(array[i]); + if (next > max) { + max = next; + } + } + + return max; + }; + + ArrayUtilities.last = function (array) { + if (array.length === 0) { + throw TypeScript.Errors.argumentOutOfRange('array'); + } + + return array[array.length - 1]; + }; + + ArrayUtilities.lastOrDefault = function (array, predicate) { + for (var i = array.length - 1; i >= 0; i--) { + var v = array[i]; + if (predicate(v, i)) { + return v; + } + } + + return null; + }; + + ArrayUtilities.firstOrDefault = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + var value = array[i]; + if (func(value, i)) { + return value; + } + } + + return null; + }; + + ArrayUtilities.first = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + var value = array[i]; + if (!func || func(value, i)) { + return value; + } + } + + throw TypeScript.Errors.invalidOperation(); + }; + + ArrayUtilities.sum = function (array, func) { + var result = 0; + + for (var i = 0, n = array.length; i < n; i++) { + result += func(array[i]); + } + + return result; + }; + + ArrayUtilities.select = function (values, func) { + var result = new Array(values.length); + + for (var i = 0; i < values.length; i++) { + result[i] = func(values[i]); + } + + return result; + }; + + ArrayUtilities.where = function (values, func) { + var result = new Array(); + + for (var i = 0; i < values.length; i++) { + if (func(values[i])) { + result.push(values[i]); + } + } + + return result; + }; + + ArrayUtilities.any = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + if (func(array[i])) { + return true; + } + } + + return false; + }; + + ArrayUtilities.all = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + if (!func(array[i])) { + return false; + } + } + + return true; + }; + + ArrayUtilities.binarySearch = function (array, value) { + var low = 0; + var high = array.length - 1; + + while (low <= high) { + var middle = low + ((high - low) >> 1); + var midValue = array[middle]; + + if (midValue === value) { + return middle; + } else if (midValue > value) { + high = middle - 1; + } else { + low = middle + 1; + } + } + + return ~low; + }; + + ArrayUtilities.createArray = function (length, defaultValue) { + var result = new Array(length); + for (var i = 0; i < length; i++) { + result[i] = defaultValue; + } + + return result; + }; + + ArrayUtilities.grow = function (array, length, defaultValue) { + var count = length - array.length; + for (var i = 0; i < count; i++) { + array.push(defaultValue); + } + }; + + ArrayUtilities.copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) { + for (var i = 0; i < length; i++) { + destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i]; + } + }; + + ArrayUtilities.indexOf = function (array, predicate) { + for (var i = 0, n = array.length; i < n; i++) { + if (predicate(array[i])) { + return i; + } + } + + return -1; + }; + return ArrayUtilities; + })(); + TypeScript.ArrayUtilities = ArrayUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (BitVector) { + var pool = []; + var Constants; + (function (Constants) { + Constants[Constants["MaxBitsPerEncodedNumber"] = 30] = "MaxBitsPerEncodedNumber"; + Constants[Constants["BitsPerEncodedBiStateValue"] = 1] = "BitsPerEncodedBiStateValue"; + + Constants[Constants["BitsPerEncodedTriStateValue"] = 2] = "BitsPerEncodedTriStateValue"; + + Constants[Constants["BiStateEncodedTrue"] = 1] = "BiStateEncodedTrue"; + Constants[Constants["BiStateClearBitsMask"] = 1] = "BiStateClearBitsMask"; + + Constants[Constants["TriStateEncodedFalse"] = 1] = "TriStateEncodedFalse"; + Constants[Constants["TriStateEncodedTrue"] = 2] = "TriStateEncodedTrue"; + Constants[Constants["TriStateClearBitsMask"] = 3] = "TriStateClearBitsMask"; + })(Constants || (Constants = {})); + + var BitVectorImpl = (function () { + function BitVectorImpl(allowUndefinedValues) { + this.allowUndefinedValues = allowUndefinedValues; + this.isReleased = false; + this.bits = []; + } + BitVectorImpl.prototype.computeTriStateArrayIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */; + + return (index / encodedValuesPerNumber) >>> 0; + }; + + BitVectorImpl.prototype.computeBiStateArrayIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */; + + return (index / encodedValuesPerNumber) >>> 0; + }; + + BitVectorImpl.prototype.computeTriStateEncodedValueIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */; + + return (index % encodedValuesPerNumber) * 2 /* BitsPerEncodedTriStateValue */; + }; + + BitVectorImpl.prototype.computeBiStateEncodedValueIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */; + + return (index % encodedValuesPerNumber) * 1 /* BitsPerEncodedBiStateValue */; + }; + + BitVectorImpl.prototype.valueAt = function (index) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + if (this.allowUndefinedValues) { + var arrayIndex = this.computeTriStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + return undefined; + } + + var bitIndex = this.computeTriStateEncodedValueIndex(index); + if (encoded & (2 /* TriStateEncodedTrue */ << bitIndex)) { + return true; + } else if (encoded & (1 /* TriStateEncodedFalse */ << bitIndex)) { + return false; + } else { + return undefined; + } + } else { + var arrayIndex = this.computeBiStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + return false; + } + + var bitIndex = this.computeBiStateEncodedValueIndex(index); + if (encoded & (1 /* BiStateEncodedTrue */ << bitIndex)) { + return true; + } else { + return false; + } + } + }; + + BitVectorImpl.prototype.setValueAt = function (index, value) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + if (this.allowUndefinedValues) { + TypeScript.Debug.assert(value === true || value === false || value === undefined, "value must only be true, false or undefined."); + + var arrayIndex = this.computeTriStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + if (value === undefined) { + return; + } + + encoded = 0; + } + + var bitIndex = this.computeTriStateEncodedValueIndex(index); + + var clearMask = ~(3 /* TriStateClearBitsMask */ << bitIndex); + encoded = encoded & clearMask; + + if (value === true) { + encoded = encoded | (2 /* TriStateEncodedTrue */ << bitIndex); + } else if (value === false) { + encoded = encoded | (1 /* TriStateEncodedFalse */ << bitIndex); + } + + this.bits[arrayIndex] = encoded; + } else { + TypeScript.Debug.assert(value === true || value === false, "value must only be true or false."); + + var arrayIndex = this.computeBiStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + if (value === false) { + return; + } + + encoded = 0; + } + + var bitIndex = this.computeBiStateEncodedValueIndex(index); + + encoded = encoded & ~(1 /* BiStateClearBitsMask */ << bitIndex); + + if (value) { + encoded = encoded | (1 /* BiStateEncodedTrue */ << bitIndex); + } + + this.bits[arrayIndex] = encoded; + } + }; + + BitVectorImpl.prototype.release = function () { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + this.isReleased = true; + this.bits.length = 0; + pool.push(this); + }; + return BitVectorImpl; + })(); + + function getBitVector(allowUndefinedValues) { + if (pool.length === 0) { + return new BitVectorImpl(allowUndefinedValues); + } + + var vector = pool.pop(); + vector.isReleased = false; + vector.allowUndefinedValues = allowUndefinedValues; + + return vector; + } + BitVector.getBitVector = getBitVector; + })(TypeScript.BitVector || (TypeScript.BitVector = {})); + var BitVector = TypeScript.BitVector; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (BitMatrix) { + var pool = []; + + var BitMatrixImpl = (function () { + function BitMatrixImpl(allowUndefinedValues) { + this.allowUndefinedValues = allowUndefinedValues; + this.isReleased = false; + this.vectors = []; + } + BitMatrixImpl.prototype.valueAt = function (x, y) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + var vector = this.vectors[x]; + if (!vector) { + return this.allowUndefinedValues ? undefined : false; + } + + return vector.valueAt(y); + }; + + BitMatrixImpl.prototype.setValueAt = function (x, y, value) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + var vector = this.vectors[x]; + if (!vector) { + if (value === undefined) { + return; + } + + vector = TypeScript.BitVector.getBitVector(this.allowUndefinedValues); + this.vectors[x] = vector; + } + + vector.setValueAt(y, value); + }; + + BitMatrixImpl.prototype.release = function () { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + this.isReleased = true; + + for (var name in this.vectors) { + if (this.vectors.hasOwnProperty(name)) { + var vector = this.vectors[name]; + vector.release(); + } + } + + this.vectors.length = 0; + pool.push(this); + }; + return BitMatrixImpl; + })(); + + function getBitMatrix(allowUndefinedValues) { + if (pool.length === 0) { + return new BitMatrixImpl(allowUndefinedValues); + } + + var matrix = pool.pop(); + matrix.isReleased = false; + matrix.allowUndefinedValues = allowUndefinedValues; + + return matrix; + } + BitMatrix.getBitMatrix = getBitMatrix; + })(TypeScript.BitMatrix || (TypeScript.BitMatrix = {})); + var BitMatrix = TypeScript.BitMatrix; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Constants) { + Constants[Constants["Max31BitInteger"] = 1073741823] = "Max31BitInteger"; + Constants[Constants["Min31BitInteger"] = -1073741824] = "Min31BitInteger"; + })(TypeScript.Constants || (TypeScript.Constants = {})); + var Constants = TypeScript.Constants; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (AssertionLevel) { + AssertionLevel[AssertionLevel["None"] = 0] = "None"; + AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal"; + AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive"; + AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive"; + })(TypeScript.AssertionLevel || (TypeScript.AssertionLevel = {})); + var AssertionLevel = TypeScript.AssertionLevel; + + var Debug = (function () { + function Debug() { + } + Debug.shouldAssert = function (level) { + return this.currentAssertionLevel >= level; + }; + + Debug.assert = function (expression, message, verboseDebugInfo) { + if (typeof message === "undefined") { message = ""; } + if (typeof verboseDebugInfo === "undefined") { verboseDebugInfo = null; } + if (!expression) { + var verboseDebugString = ""; + if (verboseDebugInfo) { + verboseDebugString = "\r\nVerbose Debug Information:" + verboseDebugInfo(); + } + + throw new Error("Debug Failure. False expression: " + message + verboseDebugString); + } + }; + + Debug.fail = function (message) { + Debug.assert(false, message); + }; + Debug.currentAssertionLevel = 0 /* None */; + return Debug; + })(); + TypeScript.Debug = Debug; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.LocalizedDiagnosticMessages = null; + + var Diagnostic = (function () { + function Diagnostic(fileName, lineMap, start, length, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + this._diagnosticKey = diagnosticKey; + this._arguments = (arguments && arguments.length > 0) ? arguments : null; + this._fileName = fileName; + this._lineMap = lineMap; + this._start = start; + this._length = length; + } + Diagnostic.prototype.toJSON = function (key) { + var result = {}; + result.start = this.start(); + result.length = this.length(); + + result.diagnosticCode = this._diagnosticKey; + + var arguments = this.arguments(); + if (arguments && arguments.length > 0) { + result.arguments = arguments; + } + + return result; + }; + + Diagnostic.prototype.fileName = function () { + return this._fileName; + }; + + Diagnostic.prototype.line = function () { + return this._lineMap ? this._lineMap.getLineNumberFromPosition(this.start()) : 0; + }; + + Diagnostic.prototype.character = function () { + return this._lineMap ? this._lineMap.getLineAndCharacterFromPosition(this.start()).character() : 0; + }; + + Diagnostic.prototype.start = function () { + return this._start; + }; + + Diagnostic.prototype.length = function () { + return this._length; + }; + + Diagnostic.prototype.diagnosticKey = function () { + return this._diagnosticKey; + }; + + Diagnostic.prototype.arguments = function () { + return this._arguments; + }; + + Diagnostic.prototype.text = function () { + return TypeScript.getLocalizedText(this._diagnosticKey, this._arguments); + }; + + Diagnostic.prototype.message = function () { + return TypeScript.getDiagnosticMessage(this._diagnosticKey, this._arguments); + }; + + Diagnostic.prototype.additionalLocations = function () { + return []; + }; + + Diagnostic.equals = function (diagnostic1, diagnostic2) { + return diagnostic1._fileName === diagnostic2._fileName && diagnostic1._start === diagnostic2._start && diagnostic1._length === diagnostic2._length && diagnostic1._diagnosticKey === diagnostic2._diagnosticKey && TypeScript.ArrayUtilities.sequenceEquals(diagnostic1._arguments, diagnostic2._arguments, function (v1, v2) { + return v1 === v2; + }); + }; + + Diagnostic.prototype.info = function () { + return getDiagnosticInfoFromKey(this.diagnosticKey()); + }; + return Diagnostic; + })(); + TypeScript.Diagnostic = Diagnostic; + + function newLine() { + return TypeScript.Environment ? TypeScript.Environment.newLine : "\r\n"; + } + TypeScript.newLine = newLine; + + function getLargestIndex(diagnostic) { + var largest = -1; + var regex = /\{(\d+)\}/g; + + var match; + while ((match = regex.exec(diagnostic)) != null) { + var val = parseInt(match[1]); + if (!isNaN(val) && val > largest) { + largest = val; + } + } + + return largest; + } + + function getDiagnosticInfoFromKey(diagnosticKey) { + var result = TypeScript.diagnosticInformationMap[diagnosticKey]; + TypeScript.Debug.assert(result); + return result; + } + + function getLocalizedText(diagnosticKey, args) { + if (TypeScript.LocalizedDiagnosticMessages) { + } + + var diagnosticMessageText = TypeScript.LocalizedDiagnosticMessages ? TypeScript.LocalizedDiagnosticMessages[diagnosticKey] : diagnosticKey; + TypeScript.Debug.assert(diagnosticMessageText !== undefined && diagnosticMessageText !== null); + + var actualCount = args ? args.length : 0; + + var expectedCount = 1 + getLargestIndex(diagnosticKey); + + if (expectedCount !== actualCount) { + throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_0_arguments_to_message_got_1_instead, [expectedCount, actualCount])); + } + + var valueCount = 1 + getLargestIndex(diagnosticMessageText); + if (valueCount !== expectedCount) { + throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_the_message_0_to_have_1_arguments_but_it_had_2, [diagnosticMessageText, expectedCount, valueCount])); + } + + diagnosticMessageText = diagnosticMessageText.replace(/{(\d+)}/g, function (match, num) { + return typeof args[num] !== 'undefined' ? args[num] : match; + }); + + diagnosticMessageText = diagnosticMessageText.replace(/{(NL)}/g, function (match) { + return TypeScript.newLine(); + }); + + return diagnosticMessageText; + } + TypeScript.getLocalizedText = getLocalizedText; + + function getDiagnosticMessage(diagnosticKey, args) { + var diagnostic = getDiagnosticInfoFromKey(diagnosticKey); + var diagnosticMessageText = getLocalizedText(diagnosticKey, args); + + var message; + if (diagnostic.category === 1 /* Error */) { + message = getLocalizedText(TypeScript.DiagnosticCode.error_TS_0_1, [diagnostic.code, diagnosticMessageText]); + } else if (diagnostic.category === 0 /* Warning */) { + message = getLocalizedText(TypeScript.DiagnosticCode.warning_TS_0_1, [diagnostic.code, diagnosticMessageText]); + } else { + message = diagnosticMessageText; + } + + return message; + } + TypeScript.getDiagnosticMessage = getDiagnosticMessage; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Errors = (function () { + function Errors() { + } + Errors.argument = function (argument, message) { + return new Error("Invalid argument: " + argument + ". " + message); + }; + + Errors.argumentOutOfRange = function (argument) { + return new Error("Argument out of range: " + argument); + }; + + Errors.argumentNull = function (argument) { + return new Error("Argument null: " + argument); + }; + + Errors.abstract = function () { + return new Error("Operation not implemented properly by subclass."); + }; + + Errors.notYetImplemented = function () { + return new Error("Not yet implemented."); + }; + + Errors.invalidOperation = function (message) { + return new Error("Invalid operation: " + message); + }; + return Errors; + })(); + TypeScript.Errors = Errors; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Hash = (function () { + function Hash() { + } + Hash.computeFnv1aCharArrayHashCode = function (text, start, len) { + var hashCode = Hash.FNV_BASE; + var end = start + len; + + for (var i = start; i < end; i++) { + hashCode = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(hashCode ^ text[i], Hash.FNV_PRIME); + } + + return hashCode; + }; + + Hash.computeSimple31BitCharArrayHashCode = function (key, start, len) { + var hash = 0; + + for (var i = 0; i < len; i++) { + var ch = key[start + i]; + + hash = ((((hash << 5) - hash) | 0) + ch) | 0; + } + + return hash & 0x7FFFFFFF; + }; + + Hash.computeSimple31BitStringHashCode = function (key) { + var hash = 0; + + var start = 0; + var len = key.length; + + for (var i = 0; i < len; i++) { + var ch = key.charCodeAt(start + i); + + hash = ((((hash << 5) - hash) | 0) + ch) | 0; + } + + return hash & 0x7FFFFFFF; + }; + + Hash.computeMurmur2StringHashCode = function (key, seed) { + var m = 0x5bd1e995; + var r = 24; + + var numberOfCharsLeft = key.length; + var h = Math.abs(seed ^ numberOfCharsLeft); + + var index = 0; + while (numberOfCharsLeft >= 2) { + var c1 = key.charCodeAt(index); + var c2 = key.charCodeAt(index + 1); + + var k = Math.abs(c1 | (c2 << 16)); + + k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m); + k ^= k >> r; + k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m); + + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + h ^= k; + + index += 2; + numberOfCharsLeft -= 2; + } + + if (numberOfCharsLeft == 1) { + h ^= key.charCodeAt(index); + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + } + + h ^= h >> 13; + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + h ^= h >> 15; + + return h; + }; + + Hash.getPrime = function (min) { + for (var i = 0; i < Hash.primes.length; i++) { + var num = Hash.primes[i]; + if (num >= min) { + return num; + } + } + + throw TypeScript.Errors.notYetImplemented(); + }; + + Hash.expandPrime = function (oldSize) { + var num = oldSize << 1; + if (num > 2146435069 && 2146435069 > oldSize) { + return 2146435069; + } + return Hash.getPrime(num); + }; + + Hash.combine = function (value, currentHash) { + return (((currentHash << 5) + currentHash) + value) & 0x7FFFFFFF; + }; + Hash.FNV_BASE = 2166136261; + Hash.FNV_PRIME = 16777619; + + Hash.primes = [ + 3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, + 631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, + 10103, 12143, 14591, 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, + 90523, 108631, 130363, 156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, + 672827, 807403, 968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, + 4166287, 4999559, 5999471, 7199369]; + return Hash; + })(); + TypeScript.Hash = Hash; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Collections) { + Collections.DefaultHashTableCapacity = 1024; + + var HashTableEntry = (function () { + function HashTableEntry(Key, Value, HashCode, Next) { + this.Key = Key; + this.Value = Value; + this.HashCode = HashCode; + this.Next = Next; + } + return HashTableEntry; + })(); + + var HashTable = (function () { + function HashTable(capacity, hash) { + this.hash = hash; + this.count = 0; + var size = TypeScript.Hash.getPrime(capacity); + this.entries = TypeScript.ArrayUtilities.createArray(size, null); + } + HashTable.prototype.set = function (key, value) { + this.addOrSet(key, value, false); + }; + + HashTable.prototype.add = function (key, value) { + this.addOrSet(key, value, true); + }; + + HashTable.prototype.containsKey = function (key) { + var hashCode = this.computeHashCode(key); + var entry = this.findEntry(key, hashCode); + return entry !== null; + }; + + HashTable.prototype.get = function (key) { + var hashCode = this.computeHashCode(key); + var entry = this.findEntry(key, hashCode); + + return entry === null ? null : entry.Value; + }; + + HashTable.prototype.computeHashCode = function (key) { + var hashCode = this.hash === null ? key.hashCode : this.hash(key); + + hashCode = hashCode & 0x7FFFFFFF; + TypeScript.Debug.assert(hashCode >= 0); + + return hashCode; + }; + + HashTable.prototype.addOrSet = function (key, value, throwOnExistingEntry) { + var hashCode = this.computeHashCode(key); + + var entry = this.findEntry(key, hashCode); + if (entry !== null) { + if (throwOnExistingEntry) { + throw TypeScript.Errors.argument('key', "Key was already in table."); + } + + entry.Key = key; + entry.Value = value; + return; + } + + return this.addEntry(key, value, hashCode); + }; + + HashTable.prototype.findEntry = function (key, hashCode) { + for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) { + if (e.HashCode === hashCode && key === e.Key) { + return e; + } + } + + return null; + }; + + HashTable.prototype.addEntry = function (key, value, hashCode) { + var index = hashCode % this.entries.length; + + var e = new HashTableEntry(key, value, hashCode, this.entries[index]); + + this.entries[index] = e; + + if (this.count >= (this.entries.length / 2)) { + this.grow(); + } + + this.count++; + return e.Key; + }; + + HashTable.prototype.grow = function () { + var newSize = TypeScript.Hash.expandPrime(this.entries.length); + + var oldEntries = this.entries; + var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null); + + this.entries = newEntries; + + for (var i = 0; i < oldEntries.length; i++) { + var e = oldEntries[i]; + + while (e !== null) { + var newIndex = e.HashCode % newSize; + var tmp = e.Next; + e.Next = newEntries[newIndex]; + newEntries[newIndex] = e; + e = tmp; + } + } + }; + return HashTable; + })(); + Collections.HashTable = HashTable; + + function createHashTable(capacity, hash) { + if (typeof capacity === "undefined") { capacity = Collections.DefaultHashTableCapacity; } + if (typeof hash === "undefined") { hash = null; } + return new HashTable(capacity, hash); + } + Collections.createHashTable = createHashTable; + + var currentHashCode = 1; + function identityHashCode(value) { + if (value.__hash === undefined) { + value.__hash = currentHashCode; + currentHashCode++; + } + + return value.__hash; + } + Collections.identityHashCode = identityHashCode; + })(TypeScript.Collections || (TypeScript.Collections = {})); + var Collections = TypeScript.Collections; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + TypeScript.nodeMakeDirectoryTime = 0; + TypeScript.nodeCreateBufferTime = 0; + TypeScript.nodeWriteFileSyncTime = 0; + + (function (ByteOrderMark) { + ByteOrderMark[ByteOrderMark["None"] = 0] = "None"; + ByteOrderMark[ByteOrderMark["Utf8"] = 1] = "Utf8"; + ByteOrderMark[ByteOrderMark["Utf16BigEndian"] = 2] = "Utf16BigEndian"; + ByteOrderMark[ByteOrderMark["Utf16LittleEndian"] = 3] = "Utf16LittleEndian"; + })(TypeScript.ByteOrderMark || (TypeScript.ByteOrderMark = {})); + var ByteOrderMark = TypeScript.ByteOrderMark; + + var FileInformation = (function () { + function FileInformation(contents, byteOrderMark) { + this.contents = contents; + this.byteOrderMark = byteOrderMark; + } + return FileInformation; + })(); + TypeScript.FileInformation = FileInformation; + + TypeScript.Environment = (function () { + function getWindowsScriptHostEnvironment() { + try { + var fso = new ActiveXObject("Scripting.FileSystemObject"); + } catch (e) { + return null; + } + + var streamObjectPool = []; + + function getStreamObject() { + if (streamObjectPool.length > 0) { + return streamObjectPool.pop(); + } else { + return new ActiveXObject("ADODB.Stream"); + } + } + + function releaseStreamObject(obj) { + streamObjectPool.push(obj); + } + + var args = []; + for (var i = 0; i < WScript.Arguments.length; i++) { + args[i] = WScript.Arguments.Item(i); + } + + return { + newLine: "\r\n", + currentDirectory: function () { + return WScript.CreateObject("WScript.Shell").CurrentDirectory; + }, + supportsCodePage: function () { + return WScript.ReadFile; + }, + readFile: function (path, codepage) { + try { + if (codepage !== null && this.supportsCodePage()) { + try { + var contents = WScript.ReadFile(path, codepage); + return new FileInformation(contents, 0 /* None */); + } catch (e) { + } + } + + var streamObj = getStreamObject(); + streamObj.Open(); + streamObj.Type = 2; + + streamObj.Charset = 'x-ansi'; + + streamObj.LoadFromFile(path); + var bomChar = streamObj.ReadText(2); + + streamObj.Position = 0; + + var byteOrderMark = 0 /* None */; + + if (bomChar.charCodeAt(0) === 0xFE && bomChar.charCodeAt(1) === 0xFF) { + streamObj.Charset = 'unicode'; + byteOrderMark = 2 /* Utf16BigEndian */; + } else if (bomChar.charCodeAt(0) === 0xFF && bomChar.charCodeAt(1) === 0xFE) { + streamObj.Charset = 'unicode'; + byteOrderMark = 3 /* Utf16LittleEndian */; + } else if (bomChar.charCodeAt(0) === 0xEF && bomChar.charCodeAt(1) === 0xBB) { + streamObj.Charset = 'utf-8'; + byteOrderMark = 1 /* Utf8 */; + } else { + streamObj.Charset = 'utf-8'; + } + + var contents = streamObj.ReadText(-1); + streamObj.Close(); + releaseStreamObject(streamObj); + return new FileInformation(contents, byteOrderMark); + } catch (err) { + var message; + if (err.number === -2147024809) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unsupported_file_encoding, null); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Cannot_read_file_0_1, [path, err.message]); + } + + throw new Error(message); + } + }, + writeFile: function (path, contents, writeByteOrderMark) { + var textStream = getStreamObject(); + textStream.Charset = 'utf-8'; + textStream.Open(); + textStream.WriteText(contents, 0); + + if (!writeByteOrderMark) { + textStream.Position = 3; + } else { + textStream.Position = 0; + } + + var fileStream = getStreamObject(); + fileStream.Type = 1; + fileStream.Open(); + + textStream.CopyTo(fileStream); + + fileStream.Flush(); + fileStream.SaveToFile(path, 2); + fileStream.Close(); + + textStream.Flush(); + textStream.Close(); + }, + fileExists: function (path) { + return fso.FileExists(path); + }, + deleteFile: function (path) { + if (fso.FileExists(path)) { + fso.DeleteFile(path, true); + } + }, + directoryExists: function (path) { + return fso.FolderExists(path); + }, + listFiles: function (path, spec, options) { + options = options || {}; + function filesInFolder(folder, root) { + var paths = []; + var fc; + + if (options.recursive) { + fc = new Enumerator(folder.subfolders); + + for (; !fc.atEnd(); fc.moveNext()) { + paths = paths.concat(filesInFolder(fc.item(), root + "\\" + fc.item().Name)); + } + } + + fc = new Enumerator(folder.files); + + for (; !fc.atEnd(); fc.moveNext()) { + if (!spec || fc.item().Name.match(spec)) { + paths.push(root + "\\" + fc.item().Name); + } + } + + return paths; + } + + var folder = fso.GetFolder(path); + var paths = []; + + return filesInFolder(folder, path); + }, + arguments: args, + standardOut: WScript.StdOut + }; + } + ; + + function getNodeEnvironment() { + var _fs = require('fs'); + var _path = require('path'); + var _module = require('module'); + var _os = require('os'); + + return { + newLine: _os.EOL, + currentDirectory: function () { + return process.cwd(); + }, + supportsCodePage: function () { + return false; + }, + readFile: function (file, codepage) { + if (codepage !== null) { + throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.codepage_option_not_supported_on_current_platform, null)); + } + + var buffer = _fs.readFileSync(file); + switch (buffer[0]) { + case 0xFE: + if (buffer[1] === 0xFF) { + var i = 0; + while ((i + 1) < buffer.length) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + i += 2; + } + return new FileInformation(buffer.toString("ucs2", 2), 2 /* Utf16BigEndian */); + } + break; + case 0xFF: + if (buffer[1] === 0xFE) { + return new FileInformation(buffer.toString("ucs2", 2), 3 /* Utf16LittleEndian */); + } + break; + case 0xEF: + if (buffer[1] === 0xBB) { + return new FileInformation(buffer.toString("utf8", 3), 1 /* Utf8 */); + } + } + + return new FileInformation(buffer.toString("utf8", 0), 0 /* None */); + }, + writeFile: function (path, contents, writeByteOrderMark) { + function mkdirRecursiveSync(path) { + var stats = _fs.statSync(path); + if (stats.isFile()) { + throw "\"" + path + "\" exists but isn't a directory."; + } else if (stats.isDirectory()) { + return; + } else { + mkdirRecursiveSync(_path.dirname(path)); + _fs.mkdirSync(path, 509); + } + } + var start = new Date().getTime(); + mkdirRecursiveSync(_path.dirname(path)); + TypeScript.nodeMakeDirectoryTime += new Date().getTime() - start; + + if (writeByteOrderMark) { + contents = '\uFEFF' + contents; + } + + var start = new Date().getTime(); + + var chunkLength = 4 * 1024; + var fileDescriptor = _fs.openSync(path, "w"); + try { + for (var index = 0; index < contents.length; index += chunkLength) { + var bufferStart = new Date().getTime(); + var buffer = new Buffer(contents.substr(index, chunkLength), "utf8"); + TypeScript.nodeCreateBufferTime += new Date().getTime() - bufferStart; + + _fs.writeSync(fileDescriptor, buffer, 0, buffer.length, null); + } + } finally { + _fs.closeSync(fileDescriptor); + } + + TypeScript.nodeWriteFileSyncTime += new Date().getTime() - start; + }, + fileExists: function (path) { + return _fs.existsSync(path); + }, + deleteFile: function (path) { + try { + _fs.unlinkSync(path); + } catch (e) { + } + }, + directoryExists: function (path) { + return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); + }, + listFiles: function dir(path, spec, options) { + options = options || {}; + + function filesInFolder(folder) { + var paths = []; + + var files = _fs.readdirSync(folder); + for (var i = 0; i < files.length; i++) { + var stat = _fs.statSync(folder + "\\" + files[i]); + if (options.recursive && stat.isDirectory()) { + paths = paths.concat(filesInFolder(folder + "\\" + files[i])); + } else if (stat.isFile() && (!spec || files[i].match(spec))) { + paths.push(folder + "\\" + files[i]); + } + } + + return paths; + } + + return filesInFolder(path); + }, + arguments: process.argv.slice(2), + standardOut: { + Write: function (str) { + process.stdout.write(str); + }, + WriteLine: function (str) { + process.stdout.write(str + '\n'); + }, + Close: function () { + } + } + }; + } + ; + + if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { + return getWindowsScriptHostEnvironment(); + } else if (typeof module !== 'undefined' && module.exports) { + return getNodeEnvironment(); + } else { + return null; + } + })(); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (IntegerUtilities) { + function integerDivide(numerator, denominator) { + return (numerator / denominator) >> 0; + } + IntegerUtilities.integerDivide = integerDivide; + + function integerMultiplyLow32Bits(n1, n2) { + var n1Low16 = n1 & 0x0000ffff; + var n1High16 = n1 >>> 16; + + var n2Low16 = n2 & 0x0000ffff; + var n2High16 = n2 >>> 16; + + var resultLow32 = (((n1 & 0xffff0000) * n2) >>> 0) + (((n1 & 0x0000ffff) * n2) >>> 0) >>> 0; + return resultLow32; + } + IntegerUtilities.integerMultiplyLow32Bits = integerMultiplyLow32Bits; + + function integerMultiplyHigh32Bits(n1, n2) { + var n1Low16 = n1 & 0x0000ffff; + var n1High16 = n1 >>> 16; + + var n2Low16 = n2 & 0x0000ffff; + var n2High16 = n2 >>> 16; + + var resultHigh32 = n1High16 * n2High16 + ((((n1Low16 * n2Low16) >>> 17) + n1Low16 * n2High16) >>> 15); + return resultHigh32; + } + IntegerUtilities.integerMultiplyHigh32Bits = integerMultiplyHigh32Bits; + + function isInteger(text) { + return /^[0-9]+$/.test(text); + } + IntegerUtilities.isInteger = isInteger; + + function isHexInteger(text) { + return /^0(x|X)[0-9a-fA-F]+$/.test(text); + } + IntegerUtilities.isHexInteger = isHexInteger; + })(TypeScript.IntegerUtilities || (TypeScript.IntegerUtilities = {})); + var IntegerUtilities = TypeScript.IntegerUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var LineMap = (function () { + function LineMap(_computeLineStarts, length) { + this._computeLineStarts = _computeLineStarts; + this.length = length; + this._lineStarts = null; + } + LineMap.prototype.toJSON = function (key) { + return { lineStarts: this.lineStarts(), length: this.length }; + }; + + LineMap.prototype.equals = function (other) { + return this.length === other.length && TypeScript.ArrayUtilities.sequenceEquals(this.lineStarts(), other.lineStarts(), function (v1, v2) { + return v1 === v2; + }); + }; + + LineMap.prototype.lineStarts = function () { + if (this._lineStarts === null) { + this._lineStarts = this._computeLineStarts(); + } + + return this._lineStarts; + }; + + LineMap.prototype.lineCount = function () { + return this.lineStarts().length; + }; + + LineMap.prototype.getPosition = function (line, character) { + return this.lineStarts()[line] + character; + }; + + LineMap.prototype.getLineNumberFromPosition = function (position) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + if (position === this.length) { + return this.lineCount() - 1; + } + + var lineNumber = TypeScript.ArrayUtilities.binarySearch(this.lineStarts(), position); + if (lineNumber < 0) { + lineNumber = (~lineNumber) - 1; + } + + return lineNumber; + }; + + LineMap.prototype.getLineStartPosition = function (lineNumber) { + return this.lineStarts()[lineNumber]; + }; + + LineMap.prototype.fillLineAndCharacterFromPosition = function (position, lineAndCharacter) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + lineAndCharacter.line = lineNumber; + lineAndCharacter.character = position - this.lineStarts()[lineNumber]; + }; + + LineMap.prototype.getLineAndCharacterFromPosition = function (position) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + + return new TypeScript.LineAndCharacter(lineNumber, position - this.lineStarts()[lineNumber]); + }; + LineMap.empty = new LineMap(function () { + return [0]; + }, 0); + return LineMap; + })(); + TypeScript.LineMap = LineMap; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var LineAndCharacter = (function () { + function LineAndCharacter(line, character) { + this._line = 0; + this._character = 0; + if (line < 0) { + throw TypeScript.Errors.argumentOutOfRange("line"); + } + + if (character < 0) { + throw TypeScript.Errors.argumentOutOfRange("character"); + } + + this._line = line; + this._character = character; + } + LineAndCharacter.prototype.line = function () { + return this._line; + }; + + LineAndCharacter.prototype.character = function () { + return this._character; + }; + return LineAndCharacter; + })(); + TypeScript.LineAndCharacter = LineAndCharacter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var MathPrototype = (function () { + function MathPrototype() { + } + MathPrototype.max = function (a, b) { + return a >= b ? a : b; + }; + + MathPrototype.min = function (a, b) { + return a <= b ? a : b; + }; + return MathPrototype; + })(); + TypeScript.MathPrototype = MathPrototype; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Collections) { + Collections.DefaultStringTableCapacity = 256; + + var StringTableEntry = (function () { + function StringTableEntry(Text, HashCode, Next) { + this.Text = Text; + this.HashCode = HashCode; + this.Next = Next; + } + return StringTableEntry; + })(); + + var StringTable = (function () { + function StringTable(capacity) { + this.count = 0; + var size = TypeScript.Hash.getPrime(capacity); + this.entries = TypeScript.ArrayUtilities.createArray(size, null); + } + StringTable.prototype.addCharArray = function (key, start, len) { + var hashCode = TypeScript.Hash.computeSimple31BitCharArrayHashCode(key, start, len) & 0x7FFFFFFF; + + var entry = this.findCharArrayEntry(key, start, len, hashCode); + if (entry !== null) { + return entry.Text; + } + + var slice = key.slice(start, start + len); + return this.addEntry(TypeScript.StringUtilities.fromCharCodeArray(slice), hashCode); + }; + + StringTable.prototype.findCharArrayEntry = function (key, start, len, hashCode) { + for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) { + if (e.HashCode === hashCode && StringTable.textCharArrayEquals(e.Text, key, start, len)) { + return e; + } + } + + return null; + }; + + StringTable.prototype.addEntry = function (text, hashCode) { + var index = hashCode % this.entries.length; + + var e = new StringTableEntry(text, hashCode, this.entries[index]); + + this.entries[index] = e; + + if (this.count === this.entries.length) { + this.grow(); + } + + this.count++; + return e.Text; + }; + + StringTable.prototype.grow = function () { + var newSize = TypeScript.Hash.expandPrime(this.entries.length); + + var oldEntries = this.entries; + var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null); + + this.entries = newEntries; + + for (var i = 0; i < oldEntries.length; i++) { + var e = oldEntries[i]; + while (e !== null) { + var newIndex = e.HashCode % newSize; + var tmp = e.Next; + e.Next = newEntries[newIndex]; + newEntries[newIndex] = e; + e = tmp; + } + } + }; + + StringTable.textCharArrayEquals = function (text, array, start, length) { + if (text.length !== length) { + return false; + } + + var s = start; + for (var i = 0; i < length; i++) { + if (text.charCodeAt(i) !== array[s]) { + return false; + } + + s++; + } + + return true; + }; + return StringTable; + })(); + Collections.StringTable = StringTable; + + Collections.DefaultStringTable = new StringTable(Collections.DefaultStringTableCapacity); + })(TypeScript.Collections || (TypeScript.Collections = {})); + var Collections = TypeScript.Collections; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var StringUtilities = (function () { + function StringUtilities() { + } + StringUtilities.isString = function (value) { + return Object.prototype.toString.apply(value, []) === '[object String]'; + }; + + StringUtilities.fromCharCodeArray = function (array) { + return String.fromCharCode.apply(null, array); + }; + + StringUtilities.endsWith = function (string, value) { + return string.substring(string.length - value.length, string.length) === value; + }; + + StringUtilities.startsWith = function (string, value) { + return string.substr(0, value.length) === value; + }; + + StringUtilities.copyTo = function (source, sourceIndex, destination, destinationIndex, count) { + for (var i = 0; i < count; i++) { + destination[destinationIndex + i] = source.charCodeAt(sourceIndex + i); + } + }; + + StringUtilities.repeat = function (value, count) { + return Array(count + 1).join(value); + }; + + StringUtilities.stringEquals = function (val1, val2) { + return val1 === val2; + }; + return StringUtilities; + })(); + TypeScript.StringUtilities = StringUtilities; +})(TypeScript || (TypeScript = {})); +var global = Function("return this").call(null); + +var TypeScript; +(function (TypeScript) { + var Clock; + (function (Clock) { + Clock.now; + Clock.resolution; + + if (typeof WScript !== "undefined" && typeof global['WScript'].InitializeProjection !== "undefined") { + global['WScript'].InitializeProjection(); + + Clock.now = function () { + return TestUtilities.QueryPerformanceCounter(); + }; + + Clock.resolution = TestUtilities.QueryPerformanceFrequency(); + } else { + Clock.now = function () { + return Date.now(); + }; + + Clock.resolution = 1000; + } + })(Clock || (Clock = {})); + + var Timer = (function () { + function Timer() { + this.time = 0; + } + Timer.prototype.start = function () { + this.time = 0; + this.startTime = Clock.now(); + }; + + Timer.prototype.end = function () { + this.time = (Clock.now() - this.startTime); + }; + return Timer; + })(); + TypeScript.Timer = Timer; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message"; + DiagnosticCategory[DiagnosticCategory["NoPrefix"] = 3] = "NoPrefix"; + })(TypeScript.DiagnosticCategory || (TypeScript.DiagnosticCategory = {})); + var DiagnosticCategory = TypeScript.DiagnosticCategory; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.diagnosticInformationMap = { + "error TS{0}: {1}": { + "code": 0, + "category": 3 /* NoPrefix */ + }, + "warning TS{0}: {1}": { + "code": 1, + "category": 3 /* NoPrefix */ + }, + "Unrecognized escape sequence.": { + "code": 1000, + "category": 1 /* Error */ + }, + "Unexpected character {0}.": { + "code": 1001, + "category": 1 /* Error */ + }, + "Missing close quote character.": { + "code": 1002, + "category": 1 /* Error */ + }, + "Identifier expected.": { + "code": 1003, + "category": 1 /* Error */ + }, + "'{0}' keyword expected.": { + "code": 1004, + "category": 1 /* Error */ + }, + "'{0}' expected.": { + "code": 1005, + "category": 1 /* Error */ + }, + "Identifier expected; '{0}' is a keyword.": { + "code": 1006, + "category": 1 /* Error */ + }, + "Automatic semicolon insertion not allowed.": { + "code": 1007, + "category": 1 /* Error */ + }, + "Unexpected token; '{0}' expected.": { + "code": 1008, + "category": 1 /* Error */ + }, + "Trailing separator not allowed.": { + "code": 1009, + "category": 1 /* Error */ + }, + "'*/' expected.": { + "code": 1010, + "category": 1 /* Error */ + }, + "'public' or 'private' modifier must precede 'static'.": { + "code": 1011, + "category": 1 /* Error */ + }, + "Unexpected token.": { + "code": 1012, + "category": 1 /* Error */ + }, + "Catch clause parameter cannot have a type annotation.": { + "code": 1013, + "category": 1 /* Error */ + }, + "Rest parameter must be last in list.": { + "code": 1014, + "category": 1 /* Error */ + }, + "Parameter cannot have question mark and initializer.": { + "code": 1015, + "category": 1 /* Error */ + }, + "Required parameter cannot follow optional parameter.": { + "code": 1016, + "category": 1 /* Error */ + }, + "Index signatures cannot have rest parameters.": { + "code": 1017, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have accessibility modifiers.": { + "code": 1018, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have a question mark.": { + "code": 1019, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have an initializer.": { + "code": 1020, + "category": 1 /* Error */ + }, + "Index signature must have a type annotation.": { + "code": 1021, + "category": 1 /* Error */ + }, + "Index signature parameter must have a type annotation.": { + "code": 1022, + "category": 1 /* Error */ + }, + "Index signature parameter type must be 'string' or 'number'.": { + "code": 1023, + "category": 1 /* Error */ + }, + "'extends' clause already seen.": { + "code": 1024, + "category": 1 /* Error */ + }, + "'extends' clause must precede 'implements' clause.": { + "code": 1025, + "category": 1 /* Error */ + }, + "Classes can only extend a single class.": { + "code": 1026, + "category": 1 /* Error */ + }, + "'implements' clause already seen.": { + "code": 1027, + "category": 1 /* Error */ + }, + "Accessibility modifier already seen.": { + "code": 1028, + "category": 1 /* Error */ + }, + "'{0}' modifier must precede '{1}' modifier.": { + "code": 1029, + "category": 1 /* Error */ + }, + "'{0}' modifier already seen.": { + "code": 1030, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a class element.": { + "code": 1031, + "category": 1 /* Error */ + }, + "Interface declaration cannot have 'implements' clause.": { + "code": 1032, + "category": 1 /* Error */ + }, + "'super' invocation cannot have type arguments.": { + "code": 1034, + "category": 1 /* Error */ + }, + "Only ambient modules can use quoted names.": { + "code": 1035, + "category": 1 /* Error */ + }, + "Statements are not allowed in ambient contexts.": { + "code": 1036, + "category": 1 /* Error */ + }, + "Implementations are not allowed in ambient contexts.": { + "code": 1037, + "category": 1 /* Error */ + }, + "'declare' modifier not allowed for code already in an ambient context.": { + "code": 1038, + "category": 1 /* Error */ + }, + "Initializers are not allowed in ambient contexts.": { + "code": 1039, + "category": 1 /* Error */ + }, + "Parameter property declarations can only be used in constructors.": { + "code": 1040, + "category": 1 /* Error */ + }, + "Function implementation expected.": { + "code": 1041, + "category": 1 /* Error */ + }, + "Constructor implementation expected.": { + "code": 1042, + "category": 1 /* Error */ + }, + "Function overload name must be '{0}'.": { + "code": 1043, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a module element.": { + "code": 1044, + "category": 1 /* Error */ + }, + "'declare' modifier cannot appear on an interface declaration.": { + "code": 1045, + "category": 1 /* Error */ + }, + "'declare' modifier required for top level element.": { + "code": 1046, + "category": 1 /* Error */ + }, + "Rest parameter cannot be optional.": { + "code": 1047, + "category": 1 /* Error */ + }, + "Rest parameter cannot have an initializer.": { + "code": 1048, + "category": 1 /* Error */ + }, + "'set' accessor must have one and only one parameter.": { + "code": 1049, + "category": 1 /* Error */ + }, + "'set' accessor parameter cannot be optional.": { + "code": 1051, + "category": 1 /* Error */ + }, + "'set' accessor parameter cannot have an initializer.": { + "code": 1052, + "category": 1 /* Error */ + }, + "'set' accessor cannot have rest parameter.": { + "code": 1053, + "category": 1 /* Error */ + }, + "'get' accessor cannot have parameters.": { + "code": 1054, + "category": 1 /* Error */ + }, + "Modifiers cannot appear here.": { + "code": 1055, + "category": 1 /* Error */ + }, + "Accessors are only available when targeting ECMAScript 5 and higher.": { + "code": 1056, + "category": 1 /* Error */ + }, + "Class name cannot be '{0}'.": { + "code": 1057, + "category": 1 /* Error */ + }, + "Interface name cannot be '{0}'.": { + "code": 1058, + "category": 1 /* Error */ + }, + "Enum name cannot be '{0}'.": { + "code": 1059, + "category": 1 /* Error */ + }, + "Module name cannot be '{0}'.": { + "code": 1060, + "category": 1 /* Error */ + }, + "Enum member must have initializer.": { + "code": 1061, + "category": 1 /* Error */ + }, + "Export assignment cannot be used in internal modules.": { + "code": 1063, + "category": 1 /* Error */ + }, + "Export assignment not allowed in module with exported element.": { + "code": 1064, + "category": 1 /* Error */ + }, + "Module cannot have multiple export assignments.": { + "code": 1065, + "category": 1 /* Error */ + }, + "Ambient enum elements can only have integer literal initializers.": { + "code": 1066, + "category": 1 /* Error */ + }, + "module, class, interface, enum, import or statement": { + "code": 1067, + "category": 3 /* NoPrefix */ + }, + "constructor, function, accessor or variable": { + "code": 1068, + "category": 3 /* NoPrefix */ + }, + "statement": { + "code": 1069, + "category": 3 /* NoPrefix */ + }, + "case or default clause": { + "code": 1070, + "category": 3 /* NoPrefix */ + }, + "identifier": { + "code": 1071, + "category": 3 /* NoPrefix */ + }, + "call, construct, index, property or function signature": { + "code": 1072, + "category": 3 /* NoPrefix */ + }, + "expression": { + "code": 1073, + "category": 3 /* NoPrefix */ + }, + "type name": { + "code": 1074, + "category": 3 /* NoPrefix */ + }, + "property or accessor": { + "code": 1075, + "category": 3 /* NoPrefix */ + }, + "parameter": { + "code": 1076, + "category": 3 /* NoPrefix */ + }, + "type": { + "code": 1077, + "category": 3 /* NoPrefix */ + }, + "type parameter": { + "code": 1078, + "category": 3 /* NoPrefix */ + }, + "'declare' modifier not allowed on import declaration.": { + "code": 1079, + "category": 1 /* Error */ + }, + "Function overload must be static.": { + "code": 1080, + "category": 1 /* Error */ + }, + "Function overload must not be static.": { + "code": 1081, + "category": 1 /* Error */ + }, + "Parameter property declarations cannot be used in an ambient context.": { + "code": 1082, + "category": 1 /* Error */ + }, + "Parameter property declarations cannot be used in a constructor overload.": { + "code": 1083, + "category": 1 /* Error */ + }, + "Invalid 'reference' directive syntax.": { + "code": 1084, + "category": 1 /* Error */ + }, + "Octal literals are not available when targeting ECMAScript 5 and higher.": { + "code": 1085, + "category": 1 /* Error */ + }, + "Accessors are not allowed in ambient contexts.": { + "code": 1086, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a constructor declaration.": { + "code": 1089, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a parameter.": { + "code": 1090, + "category": 1 /* Error */ + }, + "Duplicate identifier '{0}'.": { + "code": 2000, + "category": 1 /* Error */ + }, + "The name '{0}' does not exist in the current scope.": { + "code": 2001, + "category": 1 /* Error */ + }, + "The name '{0}' does not refer to a value.": { + "code": 2002, + "category": 1 /* Error */ + }, + "'super' can only be used inside a class instance method.": { + "code": 2003, + "category": 1 /* Error */ + }, + "The left-hand side of an assignment expression must be a variable, property or indexer.": { + "code": 2004, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not callable. Did you mean to include 'new'?": { + "code": 2161, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not callable.": { + "code": 2006, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not newable.": { + "code": 2007, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not indexable by type '{1}'.": { + "code": 2008, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to types '{1}' and '{2}'.": { + "code": 2009, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}": { + "code": 2010, + "category": 1 /* Error */ + }, + "Cannot convert '{0}' to '{1}'.": { + "code": 2011, + "category": 1 /* Error */ + }, + "Cannot convert '{0}' to '{1}':{NL}{2}": { + "code": 2012, + "category": 1 /* Error */ + }, + "Expected var, class, interface, or module.": { + "code": 2013, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to type '{1}'.": { + "code": 2014, + "category": 1 /* Error */ + }, + "Getter '{0}' already declared.": { + "code": 2015, + "category": 1 /* Error */ + }, + "Setter '{0}' already declared.": { + "code": 2016, + "category": 1 /* Error */ + }, + "Exported class '{0}' extends private class '{1}'.": { + "code": 2018, + "category": 1 /* Error */ + }, + "Exported class '{0}' implements private interface '{1}'.": { + "code": 2019, + "category": 1 /* Error */ + }, + "Exported interface '{0}' extends private interface '{1}'.": { + "code": 2020, + "category": 1 /* Error */ + }, + "Exported class '{0}' extends class from inaccessible module {1}.": { + "code": 2021, + "category": 1 /* Error */ + }, + "Exported class '{0}' implements interface from inaccessible module {1}.": { + "code": 2022, + "category": 1 /* Error */ + }, + "Exported interface '{0}' extends interface from inaccessible module {1}.": { + "code": 2023, + "category": 1 /* Error */ + }, + "Public static property '{0}' of exported class has or is using private type '{1}'.": { + "code": 2024, + "category": 1 /* Error */ + }, + "Public property '{0}' of exported class has or is using private type '{1}'.": { + "code": 2025, + "category": 1 /* Error */ + }, + "Property '{0}' of exported interface has or is using private type '{1}'.": { + "code": 2026, + "category": 1 /* Error */ + }, + "Exported variable '{0}' has or is using private type '{1}'.": { + "code": 2027, + "category": 1 /* Error */ + }, + "Public static property '{0}' of exported class is using inaccessible module {1}.": { + "code": 2028, + "category": 1 /* Error */ + }, + "Public property '{0}' of exported class is using inaccessible module {1}.": { + "code": 2029, + "category": 1 /* Error */ + }, + "Property '{0}' of exported interface is using inaccessible module {1}.": { + "code": 2030, + "category": 1 /* Error */ + }, + "Exported variable '{0}' is using inaccessible module {1}.": { + "code": 2031, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.": { + "code": 2032, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.": { + "code": 2033, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.": { + "code": 2034, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": { + "code": 2035, + "category": 1 /* Error */ + }, + "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.": { + "code": 2036, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.": { + "code": 2037, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public method from exported class has or is using private type '{1}'.": { + "code": 2038, + "category": 1 /* Error */ + }, + "Parameter '{0}' of method from exported interface has or is using private type '{1}'.": { + "code": 2039, + "category": 1 /* Error */ + }, + "Parameter '{0}' of exported function has or is using private type '{1}'.": { + "code": 2040, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.": { + "code": 2041, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.": { + "code": 2042, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.": { + "code": 2043, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": { + "code": 2044, + "category": 1 /* Error */ + }, + "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}": { + "code": 2045, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.": { + "code": 2046, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public method from exported class is using inaccessible module {1}.": { + "code": 2047, + "category": 1 /* Error */ + }, + "Parameter '{0}' of method from exported interface is using inaccessible module {1}.": { + "code": 2048, + "category": 1 /* Error */ + }, + "Parameter '{0}' of exported function is using inaccessible module {1}.": { + "code": 2049, + "category": 1 /* Error */ + }, + "Return type of public static property getter from exported class has or is using private type '{0}'.": { + "code": 2050, + "category": 1 /* Error */ + }, + "Return type of public property getter from exported class has or is using private type '{0}'.": { + "code": 2051, + "category": 1 /* Error */ + }, + "Return type of constructor signature from exported interface has or is using private type '{0}'.": { + "code": 2052, + "category": 1 /* Error */ + }, + "Return type of call signature from exported interface has or is using private type '{0}'.": { + "code": 2053, + "category": 1 /* Error */ + }, + "Return type of index signature from exported interface has or is using private type '{0}'.": { + "code": 2054, + "category": 1 /* Error */ + }, + "Return type of public static method from exported class has or is using private type '{0}'.": { + "code": 2055, + "category": 1 /* Error */ + }, + "Return type of public method from exported class has or is using private type '{0}'.": { + "code": 2056, + "category": 1 /* Error */ + }, + "Return type of method from exported interface has or is using private type '{0}'.": { + "code": 2057, + "category": 1 /* Error */ + }, + "Return type of exported function has or is using private type '{0}'.": { + "code": 2058, + "category": 1 /* Error */ + }, + "Return type of public static property getter from exported class is using inaccessible module {0}.": { + "code": 2059, + "category": 1 /* Error */ + }, + "Return type of public property getter from exported class is using inaccessible module {0}.": { + "code": 2060, + "category": 1 /* Error */ + }, + "Return type of constructor signature from exported interface is using inaccessible module {0}.": { + "code": 2061, + "category": 1 /* Error */ + }, + "Return type of call signature from exported interface is using inaccessible module {0}.": { + "code": 2062, + "category": 1 /* Error */ + }, + "Return type of index signature from exported interface is using inaccessible module {0}.": { + "code": 2063, + "category": 1 /* Error */ + }, + "Return type of public static method from exported class is using inaccessible module {0}.": { + "code": 2064, + "category": 1 /* Error */ + }, + "Return type of public method from exported class is using inaccessible module {0}.": { + "code": 2065, + "category": 1 /* Error */ + }, + "Return type of method from exported interface is using inaccessible module {0}.": { + "code": 2066, + "category": 1 /* Error */ + }, + "Return type of exported function is using inaccessible module {0}.": { + "code": 2067, + "category": 1 /* Error */ + }, + "'new T[]' cannot be used to create an array. Use 'new Array()' instead.": { + "code": 2068, + "category": 1 /* Error */ + }, + "A parameter list must follow a generic type argument list. '(' expected.": { + "code": 2069, + "category": 1 /* Error */ + }, + "Multiple constructor implementations are not allowed.": { + "code": 2070, + "category": 1 /* Error */ + }, + "Unable to resolve external module '{0}'.": { + "code": 2071, + "category": 1 /* Error */ + }, + "Module cannot be aliased to a non-module type.": { + "code": 2072, + "category": 1 /* Error */ + }, + "A class may only extend another class.": { + "code": 2073, + "category": 1 /* Error */ + }, + "A class may only implement another class or interface.": { + "code": 2074, + "category": 1 /* Error */ + }, + "An interface may only extend another class or interface.": { + "code": 2075, + "category": 1 /* Error */ + }, + "Unable to resolve type.": { + "code": 2077, + "category": 1 /* Error */ + }, + "Unable to resolve type of '{0}'.": { + "code": 2078, + "category": 1 /* Error */ + }, + "Unable to resolve type parameter constraint.": { + "code": 2079, + "category": 1 /* Error */ + }, + "Type parameter constraint cannot be a primitive type.": { + "code": 2080, + "category": 1 /* Error */ + }, + "Supplied parameters do not match any signature of call target.": { + "code": 2081, + "category": 1 /* Error */ + }, + "Supplied parameters do not match any signature of call target:{NL}{0}": { + "code": 2082, + "category": 1 /* Error */ + }, + "Invalid 'new' expression.": { + "code": 2083, + "category": 1 /* Error */ + }, + "Call signatures used in a 'new' expression must have a 'void' return type.": { + "code": 2084, + "category": 1 /* Error */ + }, + "Could not select overload for 'new' expression.": { + "code": 2085, + "category": 1 /* Error */ + }, + "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.": { + "code": 2086, + "category": 1 /* Error */ + }, + "Could not select overload for 'call' expression.": { + "code": 2087, + "category": 1 /* Error */ + }, + "Cannot invoke an expression whose type lacks a call signature.": { + "code": 2088, + "category": 1 /* Error */ + }, + "Calls to 'super' are only valid inside a class.": { + "code": 2089, + "category": 1 /* Error */ + }, + "Generic type '{0}' requires {1} type argument(s).": { + "code": 2090, + "category": 1 /* Error */ + }, + "Type of array literal cannot be determined. Best common type could not be found for array elements.": { + "code": 2092, + "category": 1 /* Error */ + }, + "Could not find enclosing symbol for dotted name '{0}'.": { + "code": 2093, + "category": 1 /* Error */ + }, + "The property '{0}' does not exist on value of type '{1}'.": { + "code": 2094, + "category": 1 /* Error */ + }, + "Could not find symbol '{0}'.": { + "code": 2095, + "category": 1 /* Error */ + }, + "'get' and 'set' accessor must have the same type.": { + "code": 2096, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in current location.": { + "code": 2097, + "category": 1 /* Error */ + }, + "Static methods cannot reference class type parameters.": { + "code": 2099, + "category": 1 /* Error */ + }, + "Class '{0}' is recursively referenced as a base type of itself.": { + "code": 2100, + "category": 1 /* Error */ + }, + "Interface '{0}' is recursively referenced as a base type of itself.": { + "code": 2101, + "category": 1 /* Error */ + }, + "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.": { + "code": 2102, + "category": 1 /* Error */ + }, + "'super' cannot be referenced in non-derived classes.": { + "code": 2103, + "category": 1 /* Error */ + }, + "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.": { + "code": 2104, + "category": 1 /* Error */ + }, + "Constructors for derived classes must contain a 'super' call.": { + "code": 2105, + "category": 1 /* Error */ + }, + "Super calls are not permitted outside constructors or in local functions inside constructors.": { + "code": 2106, + "category": 1 /* Error */ + }, + "'{0}.{1}' is inaccessible.": { + "code": 2107, + "category": 1 /* Error */ + }, + "'this' cannot be referenced within module bodies.": { + "code": 2108, + "category": 1 /* Error */ + }, + "Invalid '+' expression - types not known to support the addition operator.": { + "code": 2111, + "category": 1 /* Error */ + }, + "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": { + "code": 2112, + "category": 1 /* Error */ + }, + "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": { + "code": 2113, + "category": 1 /* Error */ + }, + "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.": { + "code": 2114, + "category": 1 /* Error */ + }, + "Variable declarations of a 'for' statement cannot use a type annotation.": { + "code": 2115, + "category": 1 /* Error */ + }, + "Variable declarations of a 'for' statement must be of types 'string' or 'any'.": { + "code": 2116, + "category": 1 /* Error */ + }, + "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.": { + "code": 2117, + "category": 1 /* Error */ + }, + "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.": { + "code": 2118, + "category": 1 /* Error */ + }, + "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.": { + "code": 2119, + "category": 1 /* Error */ + }, + "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.": { + "code": 2120, + "category": 1 /* Error */ + }, + "The right-hand side of an 'instanceof' expression must be of type 'any' or a subtype of the 'Function' interface type.": { + "code": 2121, + "category": 1 /* Error */ + }, + "Setters cannot return a value.": { + "code": 2122, + "category": 1 /* Error */ + }, + "Tried to query type of uninitialized module '{0}'.": { + "code": 2123, + "category": 1 /* Error */ + }, + "Tried to set variable type to uninitialized module type '{0}'.": { + "code": 2124, + "category": 1 /* Error */ + }, + "Function '{0}' declared a non-void return type, but has no return expression.": { + "code": 2125, + "category": 1 /* Error */ + }, + "Getters must return a value.": { + "code": 2126, + "category": 1 /* Error */ + }, + "Getter and setter accessors do not agree in visibility.": { + "code": 2127, + "category": 1 /* Error */ + }, + "Invalid left-hand side of assignment expression.": { + "code": 2130, + "category": 1 /* Error */ + }, + "Function declared a non-void return type, but has no return expression.": { + "code": 2131, + "category": 1 /* Error */ + }, + "Cannot resolve return type reference.": { + "code": 2132, + "category": 1 /* Error */ + }, + "Constructors cannot have a return type of 'void'.": { + "code": 2133, + "category": 1 /* Error */ + }, + "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'.": { + "code": 2134, + "category": 1 /* Error */ + }, + "All symbols within a with block will be resolved to 'any'.": { + "code": 2135, + "category": 1 /* Error */ + }, + "Import declarations in an internal module cannot reference an external module.": { + "code": 2136, + "category": 1 /* Error */ + }, + "Class {0} declares interface {1} but does not implement it:{NL}{2}": { + "code": 2137, + "category": 1 /* Error */ + }, + "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}": { + "code": 2138, + "category": 1 /* Error */ + }, + "The operand of an increment or decrement operator must be a variable, property or indexer.": { + "code": 2139, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in static initializers in a class body.": { + "code": 2140, + "category": 1 /* Error */ + }, + "Class '{0}' cannot extend class '{1}':{NL}{2}": { + "code": 2141, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot extend class '{1}':{NL}{2}": { + "code": 2142, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot extend interface '{1}':{NL}{2}": { + "code": 2143, + "category": 1 /* Error */ + }, + "Duplicate overload signature for '{0}'.": { + "code": 2144, + "category": 1 /* Error */ + }, + "Duplicate constructor overload signature.": { + "code": 2145, + "category": 1 /* Error */ + }, + "Duplicate overload call signature.": { + "code": 2146, + "category": 1 /* Error */ + }, + "Duplicate overload construct signature.": { + "code": 2147, + "category": 1 /* Error */ + }, + "Overload signature is not compatible with function definition.": { + "code": 2148, + "category": 1 /* Error */ + }, + "Overload signature is not compatible with function definition:{NL}{0}": { + "code": 2149, + "category": 1 /* Error */ + }, + "Overload signatures must all be public or private.": { + "code": 2150, + "category": 1 /* Error */ + }, + "Overload signatures must all be exported or not exported.": { + "code": 2151, + "category": 1 /* Error */ + }, + "Overload signatures must all be ambient or non-ambient.": { + "code": 2152, + "category": 1 /* Error */ + }, + "Overload signatures must all be optional or required.": { + "code": 2153, + "category": 1 /* Error */ + }, + "Specialized overload signature is not subtype of any non-specialized signature.": { + "code": 2154, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in constructor arguments.": { + "code": 2155, + "category": 1 /* Error */ + }, + "Instance member cannot be accessed off a class.": { + "code": 2157, + "category": 1 /* Error */ + }, + "Untyped function calls may not accept type arguments.": { + "code": 2158, + "category": 1 /* Error */ + }, + "Non-generic functions may not accept type arguments.": { + "code": 2159, + "category": 1 /* Error */ + }, + "A generic type may not reference itself with a wrapped form of its own type parameters.": { + "code": 2160, + "category": 1 /* Error */ + }, + "Rest parameters must be array types.": { + "code": 2162, + "category": 1 /* Error */ + }, + "Overload signature implementation cannot use specialized type.": { + "code": 2163, + "category": 1 /* Error */ + }, + "Export assignments may only be used at the top-level of external modules.": { + "code": 2164, + "category": 1 /* Error */ + }, + "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.": { + "code": 2165, + "category": 1 /* Error */ + }, + "Only public methods of the base class are accessible via the 'super' keyword.": { + "code": 2166, + "category": 1 /* Error */ + }, + "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}'.": { + "code": 2167, + "category": 1 /* Error */ + }, + "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}':{NL}{2}": { + "code": 2168, + "category": 1 /* Error */ + }, + "All numerically named properties must be subtypes of numeric indexer type '{0}'.": { + "code": 2169, + "category": 1 /* Error */ + }, + "All numerically named properties must be subtypes of numeric indexer type '{0}':{NL}{1}": { + "code": 2170, + "category": 1 /* Error */ + }, + "All named properties must be subtypes of string indexer type '{0}'.": { + "code": 2171, + "category": 1 /* Error */ + }, + "All named properties must be subtypes of string indexer type '{0}':{NL}{1}": { + "code": 2172, + "category": 1 /* Error */ + }, + "Generic type references must include all type arguments.": { + "code": 2173, + "category": 1 /* Error */ + }, + "Default arguments are not allowed in an overload parameter.": { + "code": 2174, + "category": 1 /* Error */ + }, + "Overloads cannot differ only by return type.": { + "code": 2175, + "category": 1 /* Error */ + }, + "Function expression declared a non-void return type, but has no return expression.": { + "code": 2176, + "category": 1 /* Error */ + }, + "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.": { + "code": 2177, + "category": 1 /* Error */ + }, + "Could not find symbol '{0}' in module '{1}'.": { + "code": 2178, + "category": 1 /* Error */ + }, + "Unable to resolve module reference '{0}'.": { + "code": 2179, + "category": 1 /* Error */ + }, + "Could not find module '{0}' in module '{1}'.": { + "code": 2180, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.": { + "code": 2181, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.": { + "code": 2182, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.": { + "code": 2183, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.": { + "code": 2184, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.": { + "code": 2185, + "category": 1 /* Error */ + }, + "Type reference '{0}' in extends clause does not reference constructor function for '{1}'.": { + "code": 2186, + "category": 1 /* Error */ + }, + "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.": { + "code": 2187, + "category": 1 /* Error */ + }, + "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.": { + "code": 2188, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}": { + "code": 2189, + "category": 1 /* Error */ + }, + "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.": { + "code": 2190, + "category": 1 /* Error */ + }, + "Ambient external module declaration cannot be reopened.": { + "code": 2191, + "category": 1 /* Error */ + }, + "All declarations of merged declaration '{0}' must be exported or not exported.": { + "code": 2192, + "category": 1 /* Error */ + }, + "'super' cannot be referenced in constructor arguments.": { + "code": 2193, + "category": 1 /* Error */ + }, + "Return type of constructor signature must be assignable to the instance type of the class.": { + "code": 2194, + "category": 1 /* Error */ + }, + "Ambient external module declaration must be defined in global context.": { + "code": 2195, + "category": 1 /* Error */ + }, + "Ambient external module declaration cannot specify relative module name.": { + "code": 2196, + "category": 1 /* Error */ + }, + "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.": { + "code": 2197, + "category": 1 /* Error */ + }, + "Could not find the best common type of types of all return statement expressions.": { + "code": 2198, + "category": 1 /* Error */ + }, + "Import declaration cannot refer to external module reference when --noResolve option is set.": { + "code": 2199, + "category": 1 /* Error */ + }, + "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.": { + "code": 2200, + "category": 1 /* Error */ + }, + "'continue' statement can only be used within an enclosing iteration statement.": { + "code": 2201, + "category": 1 /* Error */ + }, + "'break' statement can only be used within an enclosing iteration or switch statement.": { + "code": 2202, + "category": 1 /* Error */ + }, + "Jump target not found.": { + "code": 2203, + "category": 1 /* Error */ + }, + "Jump target cannot cross function boundary.": { + "code": 2204, + "category": 1 /* Error */ + }, + "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.": { + "code": 2205, + "category": 1 /* Error */ + }, + "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.": { + "code": 2206, + "category": 1 /* Error */ + }, + "Expression resolves to '_super' that compiler uses to capture base class reference.": { + "code": 2207, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": { + "code": 2208, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.": { + "code": 2209, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.": { + "code": 2210, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.": { + "code": 2211, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.": { + "code": 2212, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported function has or is using private type '{1}'.": { + "code": 2213, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": { + "code": 2214, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}": { + "code": 2215, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.": { + "code": 2216, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.": { + "code": 2217, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.": { + "code": 2218, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported function is using inaccessible module {1}.": { + "code": 2219, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported class has or is using private type '{1}'.": { + "code": 2220, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported interface has or is using private type '{1}'.": { + "code": 2221, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported class is using inaccessible module {1}.": { + "code": 2222, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported interface is using inaccessible module {1}.": { + "code": 2223, + "category": 1 /* Error */ + }, + "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.": { + "code": 2224, + "category": 1 /* Error */ + }, + "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.": { + "code": 2225, + "category": 1 /* Error */ + }, + "Type of conditional '{0}' must be identical to '{1}' or '{2}'.": { + "code": 2226, + "category": 1 /* Error */ + }, + "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.": { + "code": 2227, + "category": 1 /* Error */ + }, + "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.": { + "code": 2228, + "category": 1 /* Error */ + }, + "Type '{0}' is missing property '{1}' from type '{2}'.": { + "code": 4000, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are incompatible.": { + "code": 4001, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}": { + "code": 4002, + "category": 3 /* NoPrefix */ + }, + "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": { + "code": 4003, + "category": 3 /* NoPrefix */ + }, + "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": { + "code": 4004, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' define property '{2}' as private.": { + "code": 4005, + "category": 3 /* NoPrefix */ + }, + "Call signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4006, + "category": 3 /* NoPrefix */ + }, + "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4007, + "category": 3 /* NoPrefix */ + }, + "Type '{0}' requires a call signature, but type '{1}' lacks one.": { + "code": 4008, + "category": 3 /* NoPrefix */ + }, + "Construct signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4009, + "category": 3 /* NoPrefix */ + }, + "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4010, + "category": 3 /* NoPrefix */ + }, + "Type '{0}' requires a construct signature, but type '{1}' lacks one.": { + "code": 4011, + "category": 3 /* NoPrefix */ + }, + "Index signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4012, + "category": 3 /* NoPrefix */ + }, + "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4013, + "category": 3 /* NoPrefix */ + }, + "Call signature expects {0} or fewer parameters.": { + "code": 4014, + "category": 3 /* NoPrefix */ + }, + "Could not apply type '{0}' to argument {1} which is of type '{2}'.": { + "code": 4015, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.": { + "code": 4016, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.": { + "code": 4017, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.": { + "code": 4018, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.": { + "code": 4019, + "category": 3 /* NoPrefix */ + }, + "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.": { + "code": 4020, + "category": 3 /* NoPrefix */ + }, + "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}": { + "code": 4021, + "category": 3 /* NoPrefix */ + }, + "Type reference cannot refer to container '{0}'.": { + "code": 4022, + "category": 1 /* Error */ + }, + "Type reference must refer to type.": { + "code": 4023, + "category": 1 /* Error */ + }, + "Enums with multiple declarations must provide an initializer for the first enum element.": { + "code": 4024, + "category": 1 /* Error */ + }, + " (+ {0} overload(s))": { + "code": 4025, + "category": 2 /* Message */ + }, + "Variable declaration cannot have the same name as an import declaration.": { + "code": 4026, + "category": 1 /* Error */ + }, + "Signature expected {0} type arguments, got {1} instead.": { + "code": 4027, + "category": 1 /* Error */ + }, + "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.": { + "code": 4028, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference do not refer to same named type.": { + "code": 4029, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments.": { + "code": 4030, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments:{NL}{2}": { + "code": 4031, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are not identical.": { + "code": 4032, + "category": 3 /* NoPrefix */ + }, + "Types of string indexer of types '{0}' and '{1}' are not identical.": { + "code": 4033, + "category": 3 /* NoPrefix */ + }, + "Types of number indexer of types '{0}' and '{1}' are not identical.": { + "code": 4034, + "category": 3 /* NoPrefix */ + }, + "Type of number indexer in type '{0}' is not a subtype of string indexer type in type '{1}'.{NL}{2}": { + "code": 4035, + "category": 3 /* NoPrefix */ + }, + "Type of property '{0}' in type '{1}' is not a subtype of string indexer type in type '{2}'.{NL}{3}": { + "code": 4036, + "category": 3 /* NoPrefix */ + }, + "Type of property '{0}' in type '{1}' is not a subtype of number indexer type in type '{2}'.{NL}{3}": { + "code": 4037, + "category": 3 /* NoPrefix */ + }, + "Current host does not support '{0}' option.": { + "code": 5001, + "category": 1 /* Error */ + }, + "ECMAScript target version '{0}' not supported. Specify a valid target version: '{1}' (default), or '{2}'": { + "code": 5002, + "category": 1 /* Error */ + }, + "Module code generation '{0}' not supported.": { + "code": 5003, + "category": 1 /* Error */ + }, + "Could not find file: '{0}'.": { + "code": 5004, + "category": 1 /* Error */ + }, + "A file cannot have a reference to itself.": { + "code": 5006, + "category": 1 /* Error */ + }, + "Cannot resolve referenced file: '{0}'.": { + "code": 5007, + "category": 1 /* Error */ + }, + "Cannot find the common subdirectory path for the input files.": { + "code": 5009, + "category": 1 /* Error */ + }, + "Emit Error: {0}.": { + "code": 5011, + "category": 1 /* Error */ + }, + "Cannot read file '{0}': {1}": { + "code": 5012, + "category": 1 /* Error */ + }, + "Unsupported file encoding.": { + "code": 5013, + "category": 3 /* NoPrefix */ + }, + "Locale must be of the form or -. For example '{0}' or '{1}'.": { + "code": 5014, + "category": 1 /* Error */ + }, + "Unsupported locale: '{0}'.": { + "code": 5015, + "category": 1 /* Error */ + }, + "Execution Failed.{NL}": { + "code": 5016, + "category": 1 /* Error */ + }, + "Invalid call to 'up'": { + "code": 5019, + "category": 1 /* Error */ + }, + "Invalid call to 'down'": { + "code": 5020, + "category": 1 /* Error */ + }, + "Base64 value '{0}' finished with a continuation bit.": { + "code": 5021, + "category": 1 /* Error */ + }, + "Unknown option '{0}'": { + "code": 5023, + "category": 1 /* Error */ + }, + "Expected {0} arguments to message, got {1} instead.": { + "code": 5024, + "category": 1 /* Error */ + }, + "Expected the message '{0}' to have {1} arguments, but it had {2}": { + "code": 5025, + "category": 1 /* Error */ + }, + "Could not delete file '{0}'": { + "code": 5034, + "category": 1 /* Error */ + }, + "Could not create directory '{0}'": { + "code": 5035, + "category": 1 /* Error */ + }, + "Error while executing file '{0}': ": { + "code": 5036, + "category": 1 /* Error */ + }, + "Cannot compile external modules unless the '--module' flag is provided.": { + "code": 5037, + "category": 1 /* Error */ + }, + "Option mapRoot cannot be specified without specifying sourcemap option.": { + "code": 5038, + "category": 1 /* Error */ + }, + "Option sourceRoot cannot be specified without specifying sourcemap option.": { + "code": 5039, + "category": 1 /* Error */ + }, + "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.": { + "code": 5040, + "category": 1 /* Error */ + }, + "Option '{0}' specified without '{1}'": { + "code": 5041, + "category": 1 /* Error */ + }, + "'codepage' option not supported on current platform.": { + "code": 5042, + "category": 1 /* Error */ + }, + "Concatenate and emit output to single file.": { + "code": 6001, + "category": 2 /* Message */ + }, + "Generates corresponding {0} file.": { + "code": 6002, + "category": 2 /* Message */ + }, + "Specifies the location where debugger should locate map files instead of generated locations.": { + "code": 6003, + "category": 2 /* Message */ + }, + "Specifies the location where debugger should locate TypeScript files instead of source locations.": { + "code": 6004, + "category": 2 /* Message */ + }, + "Watch input files.": { + "code": 6005, + "category": 2 /* Message */ + }, + "Redirect output structure to the directory.": { + "code": 6006, + "category": 2 /* Message */ + }, + "Do not emit comments to output.": { + "code": 6009, + "category": 2 /* Message */ + }, + "Skip resolution and preprocessing.": { + "code": 6010, + "category": 2 /* Message */ + }, + "Specify ECMAScript target version: '{0}' (default), or '{1}'": { + "code": 6015, + "category": 2 /* Message */ + }, + "Specify module code generation: '{0}' or '{1}'": { + "code": 6016, + "category": 2 /* Message */ + }, + "Print this message.": { + "code": 6017, + "category": 2 /* Message */ + }, + "Print the compiler's version: {0}": { + "code": 6019, + "category": 2 /* Message */ + }, + "Allow use of deprecated '{0}' keyword when referencing an external module.": { + "code": 6021, + "category": 2 /* Message */ + }, + "Specify locale for errors and messages. For example '{0}' or '{1}'": { + "code": 6022, + "category": 2 /* Message */ + }, + "Syntax: {0}": { + "code": 6023, + "category": 2 /* Message */ + }, + "options": { + "code": 6024, + "category": 2 /* Message */ + }, + "file1": { + "code": 6025, + "category": 2 /* Message */ + }, + "Examples:": { + "code": 6026, + "category": 2 /* Message */ + }, + "Options:": { + "code": 6027, + "category": 2 /* Message */ + }, + "Insert command line options and files from a file.": { + "code": 6030, + "category": 2 /* Message */ + }, + "Version {0}": { + "code": 6029, + "category": 2 /* Message */ + }, + "Use the '{0}' flag to see options.": { + "code": 6031, + "category": 2 /* Message */ + }, + "{NL}Recompiling ({0}):": { + "code": 6032, + "category": 2 /* Message */ + }, + "STRING": { + "code": 6033, + "category": 2 /* Message */ + }, + "KIND": { + "code": 6034, + "category": 2 /* Message */ + }, + "file2": { + "code": 6035, + "category": 2 /* Message */ + }, + "VERSION": { + "code": 6036, + "category": 2 /* Message */ + }, + "LOCATION": { + "code": 6037, + "category": 2 /* Message */ + }, + "DIRECTORY": { + "code": 6038, + "category": 2 /* Message */ + }, + "NUMBER": { + "code": 6039, + "category": 2 /* Message */ + }, + "Specify the codepage to use when opening source files.": { + "code": 6040, + "category": 2 /* Message */ + }, + "This version of the Javascript runtime does not support the '{0}' function.": { + "code": 7000, + "category": 1 /* Error */ + }, + "Unknown rule.": { + "code": 7002, + "category": 1 /* Error */ + }, + "Invalid line number ({0})": { + "code": 7003, + "category": 1 /* Error */ + }, + "Warn on expressions and declarations with an implied 'any' type.": { + "code": 7004, + "category": 2 /* Message */ + }, + "Variable '{0}' implicitly has an 'any' type.": { + "code": 7005, + "category": 1 /* Error */ + }, + "Parameter '{0}' of '{1}' implicitly has an 'any' type.": { + "code": 7006, + "category": 1 /* Error */ + }, + "Parameter '{0}' of function type implicitly has an 'any' type.": { + "code": 7007, + "category": 1 /* Error */ + }, + "Member '{0}' of object type implicitly has an 'any' type.": { + "code": 7008, + "category": 1 /* Error */ + }, + "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.": { + "code": 7009, + "category": 1 /* Error */ + }, + "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7010, + "category": 1 /* Error */ + }, + "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7011, + "category": 1 /* Error */ + }, + "Parameter '{0}' of lambda function implicitly has an 'any' type.": { + "code": 7012, + "category": 1 /* Error */ + }, + "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7013, + "category": 1 /* Error */ + }, + "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7014, + "category": 1 /* Error */ + }, + "Array Literal implicitly has an 'any' type from widening.": { + "code": 7015, + "category": 1 /* Error */ + }, + "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.": { + "code": 7016, + "category": 1 /* Error */ + } + }; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (CharacterCodes) { + CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter"; + CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter"; + + CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed"; + CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn"; + CharacterCodes[CharacterCodes["lineSeparator"] = 0x2028] = "lineSeparator"; + CharacterCodes[CharacterCodes["paragraphSeparator"] = 0x2029] = "paragraphSeparator"; + + CharacterCodes[CharacterCodes["nextLine"] = 0x0085] = "nextLine"; + + CharacterCodes[CharacterCodes["space"] = 0x0020] = "space"; + CharacterCodes[CharacterCodes["nonBreakingSpace"] = 0x00A0] = "nonBreakingSpace"; + CharacterCodes[CharacterCodes["enQuad"] = 0x2000] = "enQuad"; + CharacterCodes[CharacterCodes["emQuad"] = 0x2001] = "emQuad"; + CharacterCodes[CharacterCodes["enSpace"] = 0x2002] = "enSpace"; + CharacterCodes[CharacterCodes["emSpace"] = 0x2003] = "emSpace"; + CharacterCodes[CharacterCodes["threePerEmSpace"] = 0x2004] = "threePerEmSpace"; + CharacterCodes[CharacterCodes["fourPerEmSpace"] = 0x2005] = "fourPerEmSpace"; + CharacterCodes[CharacterCodes["sixPerEmSpace"] = 0x2006] = "sixPerEmSpace"; + CharacterCodes[CharacterCodes["figureSpace"] = 0x2007] = "figureSpace"; + CharacterCodes[CharacterCodes["punctuationSpace"] = 0x2008] = "punctuationSpace"; + CharacterCodes[CharacterCodes["thinSpace"] = 0x2009] = "thinSpace"; + CharacterCodes[CharacterCodes["hairSpace"] = 0x200A] = "hairSpace"; + CharacterCodes[CharacterCodes["zeroWidthSpace"] = 0x200B] = "zeroWidthSpace"; + CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 0x202F] = "narrowNoBreakSpace"; + CharacterCodes[CharacterCodes["ideographicSpace"] = 0x3000] = "ideographicSpace"; + + CharacterCodes[CharacterCodes["_"] = 95] = "_"; + CharacterCodes[CharacterCodes["$"] = 36] = "$"; + + CharacterCodes[CharacterCodes["_0"] = 48] = "_0"; + CharacterCodes[CharacterCodes["_7"] = 55] = "_7"; + CharacterCodes[CharacterCodes["_9"] = 57] = "_9"; + + CharacterCodes[CharacterCodes["a"] = 97] = "a"; + CharacterCodes[CharacterCodes["b"] = 98] = "b"; + CharacterCodes[CharacterCodes["c"] = 99] = "c"; + CharacterCodes[CharacterCodes["d"] = 100] = "d"; + CharacterCodes[CharacterCodes["e"] = 101] = "e"; + CharacterCodes[CharacterCodes["f"] = 102] = "f"; + CharacterCodes[CharacterCodes["g"] = 103] = "g"; + CharacterCodes[CharacterCodes["h"] = 104] = "h"; + CharacterCodes[CharacterCodes["i"] = 105] = "i"; + CharacterCodes[CharacterCodes["k"] = 107] = "k"; + CharacterCodes[CharacterCodes["l"] = 108] = "l"; + CharacterCodes[CharacterCodes["m"] = 109] = "m"; + CharacterCodes[CharacterCodes["n"] = 110] = "n"; + CharacterCodes[CharacterCodes["o"] = 111] = "o"; + CharacterCodes[CharacterCodes["p"] = 112] = "p"; + CharacterCodes[CharacterCodes["q"] = 113] = "q"; + CharacterCodes[CharacterCodes["r"] = 114] = "r"; + CharacterCodes[CharacterCodes["s"] = 115] = "s"; + CharacterCodes[CharacterCodes["t"] = 116] = "t"; + CharacterCodes[CharacterCodes["u"] = 117] = "u"; + CharacterCodes[CharacterCodes["v"] = 118] = "v"; + CharacterCodes[CharacterCodes["w"] = 119] = "w"; + CharacterCodes[CharacterCodes["x"] = 120] = "x"; + CharacterCodes[CharacterCodes["y"] = 121] = "y"; + CharacterCodes[CharacterCodes["z"] = 122] = "z"; + + CharacterCodes[CharacterCodes["A"] = 65] = "A"; + CharacterCodes[CharacterCodes["E"] = 69] = "E"; + CharacterCodes[CharacterCodes["F"] = 70] = "F"; + CharacterCodes[CharacterCodes["X"] = 88] = "X"; + CharacterCodes[CharacterCodes["Z"] = 90] = "Z"; + + CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand"; + CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk"; + CharacterCodes[CharacterCodes["at"] = 64] = "at"; + CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash"; + CharacterCodes[CharacterCodes["bar"] = 124] = "bar"; + CharacterCodes[CharacterCodes["caret"] = 94] = "caret"; + CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace"; + CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket"; + CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen"; + CharacterCodes[CharacterCodes["colon"] = 58] = "colon"; + CharacterCodes[CharacterCodes["comma"] = 44] = "comma"; + CharacterCodes[CharacterCodes["dot"] = 46] = "dot"; + CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote"; + CharacterCodes[CharacterCodes["equals"] = 61] = "equals"; + CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation"; + CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan"; + CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan"; + CharacterCodes[CharacterCodes["minus"] = 45] = "minus"; + CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace"; + CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket"; + CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen"; + CharacterCodes[CharacterCodes["percent"] = 37] = "percent"; + CharacterCodes[CharacterCodes["plus"] = 43] = "plus"; + CharacterCodes[CharacterCodes["question"] = 63] = "question"; + CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon"; + CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote"; + CharacterCodes[CharacterCodes["slash"] = 47] = "slash"; + CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde"; + + CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace"; + CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed"; + CharacterCodes[CharacterCodes["byteOrderMark"] = 0xFEFF] = "byteOrderMark"; + CharacterCodes[CharacterCodes["tab"] = 9] = "tab"; + CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab"; + })(TypeScript.CharacterCodes || (TypeScript.CharacterCodes = {})); + var CharacterCodes = TypeScript.CharacterCodes; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + + + (function (ScriptSnapshot) { + var StringScriptSnapshot = (function () { + function StringScriptSnapshot(text) { + this.text = text; + this._lineStartPositions = null; + } + StringScriptSnapshot.prototype.getText = function (start, end) { + return this.text.substring(start, end); + }; + + StringScriptSnapshot.prototype.getLength = function () { + return this.text.length; + }; + + StringScriptSnapshot.prototype.getLineStartPositions = function () { + if (!this._lineStartPositions) { + this._lineStartPositions = TypeScript.TextUtilities.parseLineStarts(this.text); + } + + return this._lineStartPositions; + }; + + StringScriptSnapshot.prototype.getTextChangeRangeSinceVersion = function (scriptVersion) { + throw TypeScript.Errors.notYetImplemented(); + }; + return StringScriptSnapshot; + })(); + + function fromString(text) { + return new StringScriptSnapshot(text); + } + ScriptSnapshot.fromString = fromString; + })(TypeScript.ScriptSnapshot || (TypeScript.ScriptSnapshot = {})); + var ScriptSnapshot = TypeScript.ScriptSnapshot; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (LineMap1) { + function fromSimpleText(text) { + return new TypeScript.LineMap(function () { + return TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) { + return text.charCodeAt(index); + }, length: text.length() }); + }, text.length()); + } + LineMap1.fromSimpleText = fromSimpleText; + + function fromScriptSnapshot(scriptSnapshot) { + return new TypeScript.LineMap(function () { + return scriptSnapshot.getLineStartPositions(); + }, scriptSnapshot.getLength()); + } + LineMap1.fromScriptSnapshot = fromScriptSnapshot; + + function fromString(text) { + return new TypeScript.LineMap(function () { + return TypeScript.TextUtilities.parseLineStarts(text); + }, text.length); + } + LineMap1.fromString = fromString; + })(TypeScript.LineMap1 || (TypeScript.LineMap1 = {})); + var LineMap1 = TypeScript.LineMap1; +})(TypeScript || (TypeScript = {})); +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TypeScript; +(function (TypeScript) { + (function (TextFactory) { + function getStartAndLengthOfLineBreakEndingAt(text, index, info) { + var c = text.charCodeAt(index); + if (c === 10 /* lineFeed */) { + if (index > 0 && text.charCodeAt(index - 1) === 13 /* carriageReturn */) { + info.startPosition = index - 1; + info.length = 2; + } else { + info.startPosition = index; + info.length = 1; + } + } else if (TypeScript.TextUtilities.isAnyLineBreakCharacter(c)) { + info.startPosition = index; + info.length = 1; + } else { + info.startPosition = index + 1; + info.length = 0; + } + } + + var LinebreakInfo = (function () { + function LinebreakInfo(startPosition, length) { + this.startPosition = startPosition; + this.length = length; + } + return LinebreakInfo; + })(); + + var TextLine = (function () { + function TextLine(text, body, lineBreakLength, lineNumber) { + this._text = null; + this._textSpan = null; + if (text === null) { + throw TypeScript.Errors.argumentNull('text'); + } + TypeScript.Debug.assert(lineBreakLength >= 0); + TypeScript.Debug.assert(lineNumber >= 0); + this._text = text; + this._textSpan = body; + this._lineBreakLength = lineBreakLength; + this._lineNumber = lineNumber; + } + TextLine.prototype.start = function () { + return this._textSpan.start(); + }; + + TextLine.prototype.end = function () { + return this._textSpan.end(); + }; + + TextLine.prototype.endIncludingLineBreak = function () { + return this.end() + this._lineBreakLength; + }; + + TextLine.prototype.extent = function () { + return this._textSpan; + }; + + TextLine.prototype.extentIncludingLineBreak = function () { + return TypeScript.TextSpan.fromBounds(this.start(), this.endIncludingLineBreak()); + }; + + TextLine.prototype.toString = function () { + return this._text.toString(this._textSpan); + }; + + TextLine.prototype.lineNumber = function () { + return this._lineNumber; + }; + return TextLine; + })(); + + var TextBase = (function () { + function TextBase() { + this.linebreakInfo = new LinebreakInfo(0, 0); + this.lastLineFoundForPosition = null; + } + TextBase.prototype.length = function () { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.charCodeAt = function (position) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.checkSubSpan = function (span) { + if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("span"); + } + }; + + TextBase.prototype.toString = function (span) { + if (typeof span === "undefined") { span = null; } + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SubText(this, span); + }; + + TextBase.prototype.substr = function (start, length, intern) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.lineCount = function () { + return this._lineStarts().length; + }; + + TextBase.prototype.lines = function () { + var lines = []; + + var length = this.lineCount(); + for (var i = 0; i < length; ++i) { + lines[i] = this.getLineFromLineNumber(i); + } + + return lines; + }; + + TextBase.prototype.lineMap = function () { + var _this = this; + return new TypeScript.LineMap(function () { + return _this._lineStarts(); + }, this.length()); + }; + + TextBase.prototype._lineStarts = function () { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.getLineFromLineNumber = function (lineNumber) { + var lineStarts = this._lineStarts(); + + if (lineNumber < 0 || lineNumber >= lineStarts.length) { + throw TypeScript.Errors.argumentOutOfRange("lineNumber"); + } + + var first = lineStarts[lineNumber]; + if (lineNumber === lineStarts.length - 1) { + return new TextLine(this, new TypeScript.TextSpan(first, this.length() - first), 0, lineNumber); + } else { + getStartAndLengthOfLineBreakEndingAt(this, lineStarts[lineNumber + 1] - 1, this.linebreakInfo); + return new TextLine(this, new TypeScript.TextSpan(first, this.linebreakInfo.startPosition - first), this.linebreakInfo.length, lineNumber); + } + }; + + TextBase.prototype.getLineFromPosition = function (position) { + var lastFound = this.lastLineFoundForPosition; + if (lastFound !== null && lastFound.start() <= position && lastFound.endIncludingLineBreak() > position) { + return lastFound; + } + + var lineNumber = this.getLineNumberFromPosition(position); + + var result = this.getLineFromLineNumber(lineNumber); + this.lastLineFoundForPosition = result; + return result; + }; + + TextBase.prototype.getLineNumberFromPosition = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + if (position === this.length()) { + return this.lineCount() - 1; + } + + var lineNumber = TypeScript.ArrayUtilities.binarySearch(this._lineStarts(), position); + if (lineNumber < 0) { + lineNumber = (~lineNumber) - 1; + } + + return lineNumber; + }; + + TextBase.prototype.getLinePosition = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + + return new TypeScript.LineAndCharacter(lineNumber, position - this._lineStarts()[lineNumber]); + }; + return TextBase; + })(); + + var SubText = (function (_super) { + __extends(SubText, _super); + function SubText(text, span) { + _super.call(this); + this._lazyLineStarts = null; + + if (text === null) { + throw TypeScript.Errors.argumentNull("text"); + } + + if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) { + throw TypeScript.Errors.argument("span"); + } + + this.text = text; + this.span = span; + } + SubText.prototype.length = function () { + return this.span.length(); + }; + + SubText.prototype.charCodeAt = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + return this.text.charCodeAt(this.span.start() + position); + }; + + SubText.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SubText(this.text, this.getCompositeSpan(span.start(), span.length())); + }; + + SubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var span = this.getCompositeSpan(sourceIndex, count); + this.text.copyTo(span.start(), destination, destinationIndex, span.length()); + }; + + SubText.prototype.substr = function (start, length, intern) { + var startInOriginalText = this.span.start() + start; + return this.text.substr(startInOriginalText, length, intern); + }; + + SubText.prototype.getCompositeSpan = function (start, length) { + var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start); + var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length); + return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart); + }; + + SubText.prototype._lineStarts = function () { + var _this = this; + if (!this._lazyLineStarts) { + this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) { + return _this.charCodeAt(index); + }, length: this.length() }); + } + + return this._lazyLineStarts; + }; + return SubText; + })(TextBase); + + var StringText = (function (_super) { + __extends(StringText, _super); + function StringText(data) { + _super.call(this); + this.source = null; + this._lazyLineStarts = null; + + if (data === null) { + throw TypeScript.Errors.argumentNull("data"); + } + + this.source = data; + } + StringText.prototype.length = function () { + return this.source.length; + }; + + StringText.prototype.charCodeAt = function (position) { + if (position < 0 || position >= this.source.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + return this.source.charCodeAt(position); + }; + + StringText.prototype.substr = function (start, length, intern) { + return this.source.substr(start, length); + }; + + StringText.prototype.toString = function (span) { + if (typeof span === "undefined") { span = null; } + if (span === null) { + span = new TypeScript.TextSpan(0, this.length()); + } + + this.checkSubSpan(span); + + if (span.start() === 0 && span.length() === this.length()) { + return this.source; + } + + return this.source.substr(span.start(), span.length()); + }; + + StringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + TypeScript.StringUtilities.copyTo(this.source, sourceIndex, destination, destinationIndex, count); + }; + + StringText.prototype._lineStarts = function () { + if (this._lazyLineStarts === null) { + this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts(this.source); + } + + return this._lazyLineStarts; + }; + return StringText; + })(TextBase); + + function createText(value) { + return new StringText(value); + } + TextFactory.createText = createText; + })(TypeScript.TextFactory || (TypeScript.TextFactory = {})); + var TextFactory = TypeScript.TextFactory; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (SimpleText) { + var SimpleSubText = (function () { + function SimpleSubText(text, span) { + this.text = null; + this.span = null; + if (text === null) { + throw TypeScript.Errors.argumentNull("text"); + } + + if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) { + throw TypeScript.Errors.argument("span"); + } + + this.text = text; + this.span = span; + } + SimpleSubText.prototype.checkSubSpan = function (span) { + if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("span"); + } + }; + + SimpleSubText.prototype.checkSubPosition = function (position) { + if (position < 0 || position >= this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + }; + + SimpleSubText.prototype.length = function () { + return this.span.length(); + }; + + SimpleSubText.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SimpleSubText(this.text, this.getCompositeSpan(span.start(), span.length())); + }; + + SimpleSubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var span = this.getCompositeSpan(sourceIndex, count); + this.text.copyTo(span.start(), destination, destinationIndex, span.length()); + }; + + SimpleSubText.prototype.substr = function (start, length, intern) { + var span = this.getCompositeSpan(start, length); + return this.text.substr(span.start(), span.length(), intern); + }; + + SimpleSubText.prototype.getCompositeSpan = function (start, length) { + var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start); + var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length); + return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart); + }; + + SimpleSubText.prototype.charCodeAt = function (index) { + this.checkSubPosition(index); + return this.text.charCodeAt(this.span.start() + index); + }; + + SimpleSubText.prototype.lineMap = function () { + return TypeScript.LineMap1.fromSimpleText(this); + }; + return SimpleSubText; + })(); + + var SimpleStringText = (function () { + function SimpleStringText(value) { + this.value = value; + this._lineMap = null; + } + SimpleStringText.prototype.length = function () { + return this.value.length; + }; + + SimpleStringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + TypeScript.StringUtilities.copyTo(this.value, sourceIndex, destination, destinationIndex, count); + }; + + SimpleStringText.prototype.substr = function (start, length, intern) { + if (intern) { + var array = length <= SimpleStringText.charArray.length ? SimpleStringText.charArray : TypeScript.ArrayUtilities.createArray(length, 0); + this.copyTo(start, array, 0, length); + return TypeScript.Collections.DefaultStringTable.addCharArray(array, 0, length); + } + + return this.value.substr(start, length); + }; + + SimpleStringText.prototype.subText = function (span) { + return new SimpleSubText(this, span); + }; + + SimpleStringText.prototype.charCodeAt = function (index) { + return this.value.charCodeAt(index); + }; + + SimpleStringText.prototype.lineMap = function () { + if (!this._lineMap) { + this._lineMap = TypeScript.LineMap1.fromString(this.value); + } + + return this._lineMap; + }; + SimpleStringText.charArray = TypeScript.ArrayUtilities.createArray(1024, 0); + return SimpleStringText; + })(); + + var SimpleScriptSnapshotText = (function () { + function SimpleScriptSnapshotText(scriptSnapshot) { + this.scriptSnapshot = scriptSnapshot; + } + SimpleScriptSnapshotText.prototype.charCodeAt = function (index) { + return this.scriptSnapshot.getText(index, index + 1).charCodeAt(0); + }; + + SimpleScriptSnapshotText.prototype.length = function () { + return this.scriptSnapshot.getLength(); + }; + + SimpleScriptSnapshotText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var text = this.scriptSnapshot.getText(sourceIndex, sourceIndex + count); + TypeScript.StringUtilities.copyTo(text, 0, destination, destinationIndex, count); + }; + + SimpleScriptSnapshotText.prototype.substr = function (start, length, intern) { + return this.scriptSnapshot.getText(start, start + length); + }; + + SimpleScriptSnapshotText.prototype.subText = function (span) { + return new SimpleSubText(this, span); + }; + + SimpleScriptSnapshotText.prototype.lineMap = function () { + var _this = this; + return new TypeScript.LineMap(function () { + return _this.scriptSnapshot.getLineStartPositions(); + }, this.length()); + }; + return SimpleScriptSnapshotText; + })(); + + function fromString(value) { + return new SimpleStringText(value); + } + SimpleText.fromString = fromString; + + function fromScriptSnapshot(scriptSnapshot) { + return new SimpleScriptSnapshotText(scriptSnapshot); + } + SimpleText.fromScriptSnapshot = fromScriptSnapshot; + })(TypeScript.SimpleText || (TypeScript.SimpleText = {})); + var SimpleText = TypeScript.SimpleText; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (TextUtilities) { + function parseLineStarts(text) { + var length = text.length; + + if (0 === length) { + var result = new Array(); + result.push(0); + return result; + } + + var position = 0; + var index = 0; + var arrayBuilder = new Array(); + var lineNumber = 0; + + while (index < length) { + var c = text.charCodeAt(index); + var lineBreakLength; + + if (c > 13 /* carriageReturn */ && c <= 127) { + index++; + continue; + } else if (c === 13 /* carriageReturn */ && index + 1 < length && text.charCodeAt(index + 1) === 10 /* lineFeed */) { + lineBreakLength = 2; + } else if (c === 10 /* lineFeed */) { + lineBreakLength = 1; + } else { + lineBreakLength = TextUtilities.getLengthOfLineBreak(text, index); + } + + if (0 === lineBreakLength) { + index++; + } else { + arrayBuilder.push(position); + index += lineBreakLength; + position = index; + lineNumber++; + } + } + + arrayBuilder.push(position); + + return arrayBuilder; + } + TextUtilities.parseLineStarts = parseLineStarts; + + function getLengthOfLineBreakSlow(text, index, c) { + if (c === 13 /* carriageReturn */) { + var next = index + 1; + return (next < text.length) && 10 /* lineFeed */ === text.charCodeAt(next) ? 2 : 1; + } else if (isAnyLineBreakCharacter(c)) { + return 1; + } else { + return 0; + } + } + TextUtilities.getLengthOfLineBreakSlow = getLengthOfLineBreakSlow; + + function getLengthOfLineBreak(text, index) { + var c = text.charCodeAt(index); + + if (c > 13 /* carriageReturn */ && c <= 127) { + return 0; + } + + return getLengthOfLineBreakSlow(text, index, c); + } + TextUtilities.getLengthOfLineBreak = getLengthOfLineBreak; + + function isAnyLineBreakCharacter(c) { + return c === 10 /* lineFeed */ || c === 13 /* carriageReturn */ || c === 133 /* nextLine */ || c === 8232 /* lineSeparator */ || c === 8233 /* paragraphSeparator */; + } + TextUtilities.isAnyLineBreakCharacter = isAnyLineBreakCharacter; + })(TypeScript.TextUtilities || (TypeScript.TextUtilities = {})); + var TextUtilities = TypeScript.TextUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextSpan = (function () { + function TextSpan(start, length) { + if (start < 0) { + TypeScript.Errors.argument("start"); + } + + if (length < 0) { + TypeScript.Errors.argument("length"); + } + + this._start = start; + this._length = length; + } + TextSpan.prototype.start = function () { + return this._start; + }; + + TextSpan.prototype.length = function () { + return this._length; + }; + + TextSpan.prototype.end = function () { + return this._start + this._length; + }; + + TextSpan.prototype.isEmpty = function () { + return this._length === 0; + }; + + TextSpan.prototype.containsPosition = function (position) { + return position >= this._start && position < this.end(); + }; + + TextSpan.prototype.containsTextSpan = function (span) { + return span._start >= this._start && span.end() <= this.end(); + }; + + TextSpan.prototype.overlapsWith = function (span) { + var overlapStart = TypeScript.MathPrototype.max(this._start, span._start); + var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + return overlapStart < overlapEnd; + }; + + TextSpan.prototype.overlap = function (span) { + var overlapStart = TypeScript.MathPrototype.max(this._start, span._start); + var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + if (overlapStart < overlapEnd) { + return TextSpan.fromBounds(overlapStart, overlapEnd); + } + + return null; + }; + + TextSpan.prototype.intersectsWithTextSpan = function (span) { + return span._start <= this.end() && span.end() >= this._start; + }; + + TextSpan.prototype.intersectsWith = function (start, length) { + var end = start + length; + return start <= this.end() && end >= this._start; + }; + + TextSpan.prototype.intersectsWithPosition = function (position) { + return position <= this.end() && position >= this._start; + }; + + TextSpan.prototype.intersection = function (span) { + var intersectStart = TypeScript.MathPrototype.max(this._start, span._start); + var intersectEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + if (intersectStart <= intersectEnd) { + return TextSpan.fromBounds(intersectStart, intersectEnd); + } + + return null; + }; + + TextSpan.fromBounds = function (start, end) { + TypeScript.Debug.assert(start >= 0); + TypeScript.Debug.assert(end - start >= 0); + return new TextSpan(start, end - start); + }; + return TextSpan; + })(); + TypeScript.TextSpan = TextSpan; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextChangeRange = (function () { + function TextChangeRange(span, newLength) { + if (newLength < 0) { + throw TypeScript.Errors.argumentOutOfRange("newLength"); + } + + this._span = span; + this._newLength = newLength; + } + TextChangeRange.prototype.span = function () { + return this._span; + }; + + TextChangeRange.prototype.newLength = function () { + return this._newLength; + }; + + TextChangeRange.prototype.newSpan = function () { + return new TypeScript.TextSpan(this.span().start(), this.newLength()); + }; + + TextChangeRange.prototype.isUnchanged = function () { + return this.span().isEmpty() && this.newLength() === 0; + }; + + TextChangeRange.collapseChangesFromSingleVersion = function (changes) { + var diff = 0; + var start = 1073741823 /* Max31BitInteger */; + var end = 0; + + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + diff += change.newLength() - change.span().length(); + + if (change.span().start() < start) { + start = change.span().start(); + } + + if (change.span().end() > end) { + end = change.span().end(); + } + } + + if (start > end) { + return null; + } + + var combined = TypeScript.TextSpan.fromBounds(start, end); + var newLen = combined.length() + diff; + + return new TextChangeRange(combined, newLen); + }; + + TextChangeRange.collapseChangesAcrossMultipleVersions = function (changes) { + if (changes.length === 0) { + return TextChangeRange.unchanged; + } + + if (changes.length === 1) { + return changes[0]; + } + + var change0 = changes[0]; + + var oldStartN = change0.span().start(); + var oldEndN = change0.span().end(); + var newEndN = oldStartN + change0.newLength(); + + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + + var oldStart2 = nextChange.span().start(); + var oldEnd2 = nextChange.span().end(); + var newEnd2 = oldStart2 + nextChange.newLength(); + + oldStartN = TypeScript.MathPrototype.min(oldStart1, oldStart2); + oldEndN = TypeScript.MathPrototype.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = TypeScript.MathPrototype.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + + return new TextChangeRange(TypeScript.TextSpan.fromBounds(oldStartN, oldEndN), newEndN - oldStartN); + }; + TextChangeRange.unchanged = new TextChangeRange(new TypeScript.TextSpan(0, 0), 0); + return TextChangeRange; + })(); + TypeScript.TextChangeRange = TextChangeRange; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CharacterInfo = (function () { + function CharacterInfo() { + } + CharacterInfo.isDecimalDigit = function (c) { + return c >= 48 /* _0 */ && c <= 57 /* _9 */; + }; + CharacterInfo.isOctalDigit = function (c) { + return c >= 48 /* _0 */ && c <= 55 /* _7 */; + }; + + CharacterInfo.isHexDigit = function (c) { + return CharacterInfo.isDecimalDigit(c) || (c >= 65 /* A */ && c <= 70 /* F */) || (c >= 97 /* a */ && c <= 102 /* f */); + }; + + CharacterInfo.hexValue = function (c) { + return CharacterInfo.isDecimalDigit(c) ? (c - 48 /* _0 */) : (c >= 65 /* A */ && c <= 70 /* F */) ? c - 65 /* A */ + 10 : c - 97 /* a */ + 10; + }; + + CharacterInfo.isWhitespace = function (ch) { + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + return true; + } + + return false; + }; + + CharacterInfo.isLineTerminator = function (ch) { + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + return true; + } + + return false; + }; + return CharacterInfo; + })(); + TypeScript.CharacterInfo = CharacterInfo; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxConstants) { + SyntaxConstants[SyntaxConstants["TriviaNewLineMask"] = 0x00000001] = "TriviaNewLineMask"; + SyntaxConstants[SyntaxConstants["TriviaCommentMask"] = 0x00000002] = "TriviaCommentMask"; + SyntaxConstants[SyntaxConstants["TriviaFullWidthShift"] = 2] = "TriviaFullWidthShift"; + + SyntaxConstants[SyntaxConstants["NodeDataComputed"] = 0x00000001] = "NodeDataComputed"; + SyntaxConstants[SyntaxConstants["NodeIncrementallyUnusableMask"] = 0x00000002] = "NodeIncrementallyUnusableMask"; + SyntaxConstants[SyntaxConstants["NodeParsedInStrictModeMask"] = 0x00000004] = "NodeParsedInStrictModeMask"; + SyntaxConstants[SyntaxConstants["NodeFullWidthShift"] = 3] = "NodeFullWidthShift"; + + SyntaxConstants[SyntaxConstants["IsVariableWidthKeyword"] = 1 << 31] = "IsVariableWidthKeyword"; + })(TypeScript.SyntaxConstants || (TypeScript.SyntaxConstants = {})); + var SyntaxConstants = TypeScript.SyntaxConstants; +})(TypeScript || (TypeScript = {})); +var FormattingOptions = (function () { + function FormattingOptions(useTabs, spacesPerTab, indentSpaces, newLineCharacter) { + this.useTabs = useTabs; + this.spacesPerTab = spacesPerTab; + this.indentSpaces = indentSpaces; + this.newLineCharacter = newLineCharacter; + } + FormattingOptions.defaultOptions = new FormattingOptions(false, 4, 4, "\r\n"); + return FormattingOptions; +})(); +var TypeScript; +(function (TypeScript) { + (function (Indentation) { + function columnForEndOfToken(token, syntaxInformationMap, options) { + return columnForStartOfToken(token, syntaxInformationMap, options) + token.width(); + } + Indentation.columnForEndOfToken = columnForEndOfToken; + + function columnForStartOfToken(token, syntaxInformationMap, options) { + var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token); + var leadingTextInReverse = []; + + var current = token; + while (current !== firstTokenInLine) { + current = syntaxInformationMap.previousToken(current); + + if (current === firstTokenInLine) { + leadingTextInReverse.push(current.trailingTrivia().fullText()); + leadingTextInReverse.push(current.text()); + } else { + leadingTextInReverse.push(current.fullText()); + } + } + + collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse); + + return columnForLeadingTextInReverse(leadingTextInReverse, options); + } + Indentation.columnForStartOfToken = columnForStartOfToken; + + function columnForStartOfFirstTokenInLineContainingToken(token, syntaxInformationMap, options) { + var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token); + var leadingTextInReverse = []; + + collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse); + + return columnForLeadingTextInReverse(leadingTextInReverse, options); + } + Indentation.columnForStartOfFirstTokenInLineContainingToken = columnForStartOfFirstTokenInLineContainingToken; + + function collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse) { + var leadingTrivia = firstTokenInLine.leadingTrivia(); + + for (var i = leadingTrivia.count() - 1; i >= 0; i--) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + if (trivia.kind() === 5 /* NewLineTrivia */) { + break; + } + + if (trivia.kind() === 6 /* MultiLineCommentTrivia */) { + var lineSegments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + leadingTextInReverse.push(TypeScript.ArrayUtilities.last(lineSegments)); + + if (lineSegments.length > 0) { + break; + } + } + + leadingTextInReverse.push(trivia.fullText()); + } + } + + function columnForLeadingTextInReverse(leadingTextInReverse, options) { + var column = 0; + + for (var i = leadingTextInReverse.length - 1; i >= 0; i--) { + var text = leadingTextInReverse[i]; + column = columnForPositionInStringWorker(text, text.length, column, options); + } + + return column; + } + + function columnForPositionInString(input, position, options) { + return columnForPositionInStringWorker(input, position, 0, options); + } + Indentation.columnForPositionInString = columnForPositionInString; + + function columnForPositionInStringWorker(input, position, startColumn, options) { + var column = startColumn; + var spacesPerTab = options.spacesPerTab; + + for (var j = 0; j < position; j++) { + var ch = input.charCodeAt(j); + + if (ch === 9 /* tab */) { + column += spacesPerTab - column % spacesPerTab; + } else { + column++; + } + } + + return column; + } + + function indentationString(column, options) { + var numberOfTabs = 0; + var numberOfSpaces = TypeScript.MathPrototype.max(0, column); + + if (options.useTabs) { + numberOfTabs = Math.floor(column / options.spacesPerTab); + numberOfSpaces -= numberOfTabs * options.spacesPerTab; + } + + return TypeScript.StringUtilities.repeat('\t', numberOfTabs) + TypeScript.StringUtilities.repeat(' ', numberOfSpaces); + } + Indentation.indentationString = indentationString; + + function indentationTrivia(column, options) { + return TypeScript.Syntax.whitespace(this.indentationString(column, options)); + } + Indentation.indentationTrivia = indentationTrivia; + + function firstNonWhitespacePosition(value) { + for (var i = 0; i < value.length; i++) { + var ch = value.charCodeAt(i); + if (!TypeScript.CharacterInfo.isWhitespace(ch)) { + return i; + } + } + + return value.length; + } + Indentation.firstNonWhitespacePosition = firstNonWhitespacePosition; + })(TypeScript.Indentation || (TypeScript.Indentation = {})); + var Indentation = TypeScript.Indentation; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (LanguageVersion) { + LanguageVersion[LanguageVersion["EcmaScript3"] = 0] = "EcmaScript3"; + LanguageVersion[LanguageVersion["EcmaScript5"] = 1] = "EcmaScript5"; + })(TypeScript.LanguageVersion || (TypeScript.LanguageVersion = {})); + var LanguageVersion = TypeScript.LanguageVersion; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ParseOptions = (function () { + function ParseOptions(languageVersion, allowAutomaticSemicolonInsertion) { + this._languageVersion = languageVersion; + this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion; + } + ParseOptions.prototype.toJSON = function (key) { + return { allowAutomaticSemicolonInsertion: this._allowAutomaticSemicolonInsertion }; + }; + + ParseOptions.prototype.languageVersion = function () { + return this._languageVersion; + }; + + ParseOptions.prototype.allowAutomaticSemicolonInsertion = function () { + return this._allowAutomaticSemicolonInsertion; + }; + return ParseOptions; + })(); + TypeScript.ParseOptions = ParseOptions; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PositionedElement = (function () { + function PositionedElement(parent, element, fullStart) { + this._parent = parent; + this._element = element; + this._fullStart = fullStart; + } + PositionedElement.create = function (parent, element, fullStart) { + if (element === null) { + return null; + } + + if (element.isNode()) { + return new PositionedNode(parent, element, fullStart); + } else if (element.isToken()) { + return new PositionedToken(parent, element, fullStart); + } else if (element.isList()) { + return new PositionedList(parent, element, fullStart); + } else if (element.isSeparatedList()) { + return new PositionedSeparatedList(parent, element, fullStart); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + PositionedElement.prototype.parent = function () { + return this._parent; + }; + + PositionedElement.prototype.parentElement = function () { + return this._parent && this._parent._element; + }; + + PositionedElement.prototype.element = function () { + return this._element; + }; + + PositionedElement.prototype.kind = function () { + return this.element().kind(); + }; + + PositionedElement.prototype.childIndex = function (child) { + return TypeScript.Syntax.childIndex(this.element(), child); + }; + + PositionedElement.prototype.childCount = function () { + return this.element().childCount(); + }; + + PositionedElement.prototype.childAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + return PositionedElement.create(this, this.element().childAt(index), this.fullStart() + offset); + }; + + PositionedElement.prototype.childStart = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return this.fullStart() + offset + child.leadingTriviaWidth(); + }; + + PositionedElement.prototype.childEnd = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return this.fullStart() + offset + child.leadingTriviaWidth() + child.width(); + }; + + PositionedElement.prototype.childStartAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + var child = this.element().childAt(index); + return this.fullStart() + offset + child.leadingTriviaWidth(); + }; + + PositionedElement.prototype.childEndAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + var child = this.element().childAt(index); + return this.fullStart() + offset + child.leadingTriviaWidth() + child.width(); + }; + + PositionedElement.prototype.getPositionedChild = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return PositionedElement.create(this, child, this.fullStart() + offset); + }; + + PositionedElement.prototype.fullStart = function () { + return this._fullStart; + }; + + PositionedElement.prototype.fullEnd = function () { + return this.fullStart() + this.element().fullWidth(); + }; + + PositionedElement.prototype.fullWidth = function () { + return this.element().fullWidth(); + }; + + PositionedElement.prototype.start = function () { + return this.fullStart() + this.element().leadingTriviaWidth(); + }; + + PositionedElement.prototype.end = function () { + return this.fullStart() + this.element().leadingTriviaWidth() + this.element().width(); + }; + + PositionedElement.prototype.root = function () { + var current = this; + while (current.parent() !== null) { + current = current.parent(); + } + + return current; + }; + + PositionedElement.prototype.containingNode = function () { + var current = this.parent(); + + while (current !== null && !current.element().isNode()) { + current = current.parent(); + } + + return current; + }; + return PositionedElement; + })(); + TypeScript.PositionedElement = PositionedElement; + + var PositionedNodeOrToken = (function (_super) { + __extends(PositionedNodeOrToken, _super); + function PositionedNodeOrToken(parent, nodeOrToken, fullStart) { + _super.call(this, parent, nodeOrToken, fullStart); + } + PositionedNodeOrToken.prototype.nodeOrToken = function () { + return this.element(); + }; + return PositionedNodeOrToken; + })(PositionedElement); + TypeScript.PositionedNodeOrToken = PositionedNodeOrToken; + + var PositionedNode = (function (_super) { + __extends(PositionedNode, _super); + function PositionedNode(parent, node, fullStart) { + _super.call(this, parent, node, fullStart); + } + PositionedNode.prototype.node = function () { + return this.element(); + }; + return PositionedNode; + })(PositionedNodeOrToken); + TypeScript.PositionedNode = PositionedNode; + + var PositionedToken = (function (_super) { + __extends(PositionedToken, _super); + function PositionedToken(parent, token, fullStart) { + _super.call(this, parent, token, fullStart); + } + PositionedToken.prototype.token = function () { + return this.element(); + }; + + PositionedToken.prototype.previousToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var triviaList = this.token().leadingTrivia(); + if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) { + var currentTriviaEndPosition = this.start(); + for (var i = triviaList.count() - 1; i >= 0; i--) { + var trivia = triviaList.syntaxTriviaAt(i); + if (trivia.isSkippedToken()) { + return new PositionedSkippedToken(this, trivia.skippedToken(), currentTriviaEndPosition - trivia.fullWidth()); + } + + currentTriviaEndPosition -= trivia.fullWidth(); + } + } + + var start = this.fullStart(); + if (start === 0) { + return null; + } + + return this.root().node().findToken(start - 1, includeSkippedTokens); + }; + + PositionedToken.prototype.nextToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + if (this.token().tokenKind === 10 /* EndOfFileToken */) { + return null; + } + + var triviaList = this.token().trailingTrivia(); + if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) { + var fullStart = this.end(); + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + if (trivia.isSkippedToken()) { + return new PositionedSkippedToken(this, trivia.skippedToken(), fullStart); + } + + fullStart += trivia.fullWidth(); + } + } + + return this.root().node().findToken(this.fullEnd(), includeSkippedTokens); + }; + return PositionedToken; + })(PositionedNodeOrToken); + TypeScript.PositionedToken = PositionedToken; + + var PositionedList = (function (_super) { + __extends(PositionedList, _super); + function PositionedList(parent, list, fullStart) { + _super.call(this, parent, list, fullStart); + } + PositionedList.prototype.list = function () { + return this.element(); + }; + return PositionedList; + })(PositionedElement); + TypeScript.PositionedList = PositionedList; + + var PositionedSeparatedList = (function (_super) { + __extends(PositionedSeparatedList, _super); + function PositionedSeparatedList(parent, list, fullStart) { + _super.call(this, parent, list, fullStart); + } + PositionedSeparatedList.prototype.list = function () { + return this.element(); + }; + return PositionedSeparatedList; + })(PositionedElement); + TypeScript.PositionedSeparatedList = PositionedSeparatedList; + + var PositionedSkippedToken = (function (_super) { + __extends(PositionedSkippedToken, _super); + function PositionedSkippedToken(parentToken, token, fullStart) { + _super.call(this, parentToken.parent(), token, fullStart); + this._parentToken = parentToken; + } + PositionedSkippedToken.prototype.parentToken = function () { + return this._parentToken; + }; + + PositionedSkippedToken.prototype.previousToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var start = this.fullStart(); + + if (includeSkippedTokens) { + var previousToken; + + if (start >= this.parentToken().end()) { + previousToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), start - 1); + + if (previousToken) { + return previousToken; + } + + return this.parentToken(); + } else { + previousToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), start - 1); + + if (previousToken) { + return previousToken; + } + } + } + + var start = this.parentToken().fullStart(); + if (start === 0) { + return null; + } + + return this.root().node().findToken(start - 1, includeSkippedTokens); + }; + + PositionedSkippedToken.prototype.nextToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + if (this.token().tokenKind === 10 /* EndOfFileToken */) { + return null; + } + + if (includeSkippedTokens) { + var end = this.end(); + var nextToken; + + if (end <= this.parentToken().start()) { + nextToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), end); + + if (nextToken) { + return nextToken; + } + + return this.parentToken(); + } else { + nextToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), end); + + if (nextToken) { + return nextToken; + } + } + } + + return this.root().node().findToken(this.parentToken().fullEnd(), includeSkippedTokens); + }; + return PositionedSkippedToken; + })(PositionedToken); + TypeScript.PositionedSkippedToken = PositionedSkippedToken; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxKind) { + SyntaxKind[SyntaxKind["None"] = 0] = "None"; + SyntaxKind[SyntaxKind["List"] = 1] = "List"; + SyntaxKind[SyntaxKind["SeparatedList"] = 2] = "SeparatedList"; + SyntaxKind[SyntaxKind["TriviaList"] = 3] = "TriviaList"; + + SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia"; + SyntaxKind[SyntaxKind["NewLineTrivia"] = 5] = "NewLineTrivia"; + SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia"; + SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 7] = "SingleLineCommentTrivia"; + SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 8] = "SkippedTokenTrivia"; + + SyntaxKind[SyntaxKind["ErrorToken"] = 9] = "ErrorToken"; + SyntaxKind[SyntaxKind["EndOfFileToken"] = 10] = "EndOfFileToken"; + + SyntaxKind[SyntaxKind["IdentifierName"] = 11] = "IdentifierName"; + + SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 12] = "RegularExpressionLiteral"; + SyntaxKind[SyntaxKind["NumericLiteral"] = 13] = "NumericLiteral"; + SyntaxKind[SyntaxKind["StringLiteral"] = 14] = "StringLiteral"; + + SyntaxKind[SyntaxKind["BreakKeyword"] = 15] = "BreakKeyword"; + SyntaxKind[SyntaxKind["CaseKeyword"] = 16] = "CaseKeyword"; + SyntaxKind[SyntaxKind["CatchKeyword"] = 17] = "CatchKeyword"; + SyntaxKind[SyntaxKind["ContinueKeyword"] = 18] = "ContinueKeyword"; + SyntaxKind[SyntaxKind["DebuggerKeyword"] = 19] = "DebuggerKeyword"; + SyntaxKind[SyntaxKind["DefaultKeyword"] = 20] = "DefaultKeyword"; + SyntaxKind[SyntaxKind["DeleteKeyword"] = 21] = "DeleteKeyword"; + SyntaxKind[SyntaxKind["DoKeyword"] = 22] = "DoKeyword"; + SyntaxKind[SyntaxKind["ElseKeyword"] = 23] = "ElseKeyword"; + SyntaxKind[SyntaxKind["FalseKeyword"] = 24] = "FalseKeyword"; + SyntaxKind[SyntaxKind["FinallyKeyword"] = 25] = "FinallyKeyword"; + SyntaxKind[SyntaxKind["ForKeyword"] = 26] = "ForKeyword"; + SyntaxKind[SyntaxKind["FunctionKeyword"] = 27] = "FunctionKeyword"; + SyntaxKind[SyntaxKind["IfKeyword"] = 28] = "IfKeyword"; + SyntaxKind[SyntaxKind["InKeyword"] = 29] = "InKeyword"; + SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 30] = "InstanceOfKeyword"; + SyntaxKind[SyntaxKind["NewKeyword"] = 31] = "NewKeyword"; + SyntaxKind[SyntaxKind["NullKeyword"] = 32] = "NullKeyword"; + SyntaxKind[SyntaxKind["ReturnKeyword"] = 33] = "ReturnKeyword"; + SyntaxKind[SyntaxKind["SwitchKeyword"] = 34] = "SwitchKeyword"; + SyntaxKind[SyntaxKind["ThisKeyword"] = 35] = "ThisKeyword"; + SyntaxKind[SyntaxKind["ThrowKeyword"] = 36] = "ThrowKeyword"; + SyntaxKind[SyntaxKind["TrueKeyword"] = 37] = "TrueKeyword"; + SyntaxKind[SyntaxKind["TryKeyword"] = 38] = "TryKeyword"; + SyntaxKind[SyntaxKind["TypeOfKeyword"] = 39] = "TypeOfKeyword"; + SyntaxKind[SyntaxKind["VarKeyword"] = 40] = "VarKeyword"; + SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword"; + SyntaxKind[SyntaxKind["WhileKeyword"] = 42] = "WhileKeyword"; + SyntaxKind[SyntaxKind["WithKeyword"] = 43] = "WithKeyword"; + + SyntaxKind[SyntaxKind["ClassKeyword"] = 44] = "ClassKeyword"; + SyntaxKind[SyntaxKind["ConstKeyword"] = 45] = "ConstKeyword"; + SyntaxKind[SyntaxKind["EnumKeyword"] = 46] = "EnumKeyword"; + SyntaxKind[SyntaxKind["ExportKeyword"] = 47] = "ExportKeyword"; + SyntaxKind[SyntaxKind["ExtendsKeyword"] = 48] = "ExtendsKeyword"; + SyntaxKind[SyntaxKind["ImportKeyword"] = 49] = "ImportKeyword"; + SyntaxKind[SyntaxKind["SuperKeyword"] = 50] = "SuperKeyword"; + + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 51] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 52] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 53] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 54] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 55] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 56] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 57] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 58] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 59] = "YieldKeyword"; + + SyntaxKind[SyntaxKind["AnyKeyword"] = 60] = "AnyKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 61] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 62] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 63] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 64] = "GetKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 65] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 66] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 67] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 68] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 69] = "StringKeyword"; + + SyntaxKind[SyntaxKind["OpenBraceToken"] = 70] = "OpenBraceToken"; + SyntaxKind[SyntaxKind["CloseBraceToken"] = 71] = "CloseBraceToken"; + SyntaxKind[SyntaxKind["OpenParenToken"] = 72] = "OpenParenToken"; + SyntaxKind[SyntaxKind["CloseParenToken"] = 73] = "CloseParenToken"; + SyntaxKind[SyntaxKind["OpenBracketToken"] = 74] = "OpenBracketToken"; + SyntaxKind[SyntaxKind["CloseBracketToken"] = 75] = "CloseBracketToken"; + SyntaxKind[SyntaxKind["DotToken"] = 76] = "DotToken"; + SyntaxKind[SyntaxKind["DotDotDotToken"] = 77] = "DotDotDotToken"; + SyntaxKind[SyntaxKind["SemicolonToken"] = 78] = "SemicolonToken"; + SyntaxKind[SyntaxKind["CommaToken"] = 79] = "CommaToken"; + SyntaxKind[SyntaxKind["LessThanToken"] = 80] = "LessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanToken"] = 81] = "GreaterThanToken"; + SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 82] = "LessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 83] = "GreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 84] = "EqualsEqualsToken"; + SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 85] = "EqualsGreaterThanToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 86] = "ExclamationEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 87] = "EqualsEqualsEqualsToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 88] = "ExclamationEqualsEqualsToken"; + SyntaxKind[SyntaxKind["PlusToken"] = 89] = "PlusToken"; + SyntaxKind[SyntaxKind["MinusToken"] = 90] = "MinusToken"; + SyntaxKind[SyntaxKind["AsteriskToken"] = 91] = "AsteriskToken"; + SyntaxKind[SyntaxKind["PercentToken"] = 92] = "PercentToken"; + SyntaxKind[SyntaxKind["PlusPlusToken"] = 93] = "PlusPlusToken"; + SyntaxKind[SyntaxKind["MinusMinusToken"] = 94] = "MinusMinusToken"; + SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 95] = "LessThanLessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 96] = "GreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 97] = "GreaterThanGreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["AmpersandToken"] = 98] = "AmpersandToken"; + SyntaxKind[SyntaxKind["BarToken"] = 99] = "BarToken"; + SyntaxKind[SyntaxKind["CaretToken"] = 100] = "CaretToken"; + SyntaxKind[SyntaxKind["ExclamationToken"] = 101] = "ExclamationToken"; + SyntaxKind[SyntaxKind["TildeToken"] = 102] = "TildeToken"; + SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 103] = "AmpersandAmpersandToken"; + SyntaxKind[SyntaxKind["BarBarToken"] = 104] = "BarBarToken"; + SyntaxKind[SyntaxKind["QuestionToken"] = 105] = "QuestionToken"; + SyntaxKind[SyntaxKind["ColonToken"] = 106] = "ColonToken"; + SyntaxKind[SyntaxKind["EqualsToken"] = 107] = "EqualsToken"; + SyntaxKind[SyntaxKind["PlusEqualsToken"] = 108] = "PlusEqualsToken"; + SyntaxKind[SyntaxKind["MinusEqualsToken"] = 109] = "MinusEqualsToken"; + SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 110] = "AsteriskEqualsToken"; + SyntaxKind[SyntaxKind["PercentEqualsToken"] = 111] = "PercentEqualsToken"; + SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 112] = "LessThanLessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 113] = "GreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 114] = "GreaterThanGreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 115] = "AmpersandEqualsToken"; + SyntaxKind[SyntaxKind["BarEqualsToken"] = 116] = "BarEqualsToken"; + SyntaxKind[SyntaxKind["CaretEqualsToken"] = 117] = "CaretEqualsToken"; + SyntaxKind[SyntaxKind["SlashToken"] = 118] = "SlashToken"; + SyntaxKind[SyntaxKind["SlashEqualsToken"] = 119] = "SlashEqualsToken"; + + SyntaxKind[SyntaxKind["SourceUnit"] = 120] = "SourceUnit"; + + SyntaxKind[SyntaxKind["QualifiedName"] = 121] = "QualifiedName"; + + SyntaxKind[SyntaxKind["ObjectType"] = 122] = "ObjectType"; + SyntaxKind[SyntaxKind["FunctionType"] = 123] = "FunctionType"; + SyntaxKind[SyntaxKind["ArrayType"] = 124] = "ArrayType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 125] = "ConstructorType"; + SyntaxKind[SyntaxKind["GenericType"] = 126] = "GenericType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 127] = "TypeQuery"; + + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 128] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 129] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 130] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 131] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 132] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 133] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 134] = "ExportAssignment"; + + SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 135] = "MemberFunctionDeclaration"; + SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 136] = "MemberVariableDeclaration"; + SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 137] = "ConstructorDeclaration"; + SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 138] = "IndexMemberDeclaration"; + + SyntaxKind[SyntaxKind["GetAccessor"] = 139] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 140] = "SetAccessor"; + + SyntaxKind[SyntaxKind["PropertySignature"] = 141] = "PropertySignature"; + SyntaxKind[SyntaxKind["CallSignature"] = 142] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 143] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 144] = "IndexSignature"; + SyntaxKind[SyntaxKind["MethodSignature"] = 145] = "MethodSignature"; + + SyntaxKind[SyntaxKind["Block"] = 146] = "Block"; + SyntaxKind[SyntaxKind["IfStatement"] = 147] = "IfStatement"; + SyntaxKind[SyntaxKind["VariableStatement"] = 148] = "VariableStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 149] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 150] = "ReturnStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 151] = "SwitchStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 152] = "BreakStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 153] = "ContinueStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 154] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 155] = "ForInStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 156] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 157] = "ThrowStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 158] = "WhileStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 159] = "TryStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 160] = "LabeledStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 161] = "DoStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 162] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 163] = "WithStatement"; + + SyntaxKind[SyntaxKind["PlusExpression"] = 164] = "PlusExpression"; + SyntaxKind[SyntaxKind["NegateExpression"] = 165] = "NegateExpression"; + SyntaxKind[SyntaxKind["BitwiseNotExpression"] = 166] = "BitwiseNotExpression"; + SyntaxKind[SyntaxKind["LogicalNotExpression"] = 167] = "LogicalNotExpression"; + SyntaxKind[SyntaxKind["PreIncrementExpression"] = 168] = "PreIncrementExpression"; + SyntaxKind[SyntaxKind["PreDecrementExpression"] = 169] = "PreDecrementExpression"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 170] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 171] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 172] = "VoidExpression"; + SyntaxKind[SyntaxKind["CommaExpression"] = 173] = "CommaExpression"; + SyntaxKind[SyntaxKind["AssignmentExpression"] = 174] = "AssignmentExpression"; + SyntaxKind[SyntaxKind["AddAssignmentExpression"] = 175] = "AddAssignmentExpression"; + SyntaxKind[SyntaxKind["SubtractAssignmentExpression"] = 176] = "SubtractAssignmentExpression"; + SyntaxKind[SyntaxKind["MultiplyAssignmentExpression"] = 177] = "MultiplyAssignmentExpression"; + SyntaxKind[SyntaxKind["DivideAssignmentExpression"] = 178] = "DivideAssignmentExpression"; + SyntaxKind[SyntaxKind["ModuloAssignmentExpression"] = 179] = "ModuloAssignmentExpression"; + SyntaxKind[SyntaxKind["AndAssignmentExpression"] = 180] = "AndAssignmentExpression"; + SyntaxKind[SyntaxKind["ExclusiveOrAssignmentExpression"] = 181] = "ExclusiveOrAssignmentExpression"; + SyntaxKind[SyntaxKind["OrAssignmentExpression"] = 182] = "OrAssignmentExpression"; + SyntaxKind[SyntaxKind["LeftShiftAssignmentExpression"] = 183] = "LeftShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["SignedRightShiftAssignmentExpression"] = 184] = "SignedRightShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["UnsignedRightShiftAssignmentExpression"] = 185] = "UnsignedRightShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 186] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["LogicalOrExpression"] = 187] = "LogicalOrExpression"; + SyntaxKind[SyntaxKind["LogicalAndExpression"] = 188] = "LogicalAndExpression"; + SyntaxKind[SyntaxKind["BitwiseOrExpression"] = 189] = "BitwiseOrExpression"; + SyntaxKind[SyntaxKind["BitwiseExclusiveOrExpression"] = 190] = "BitwiseExclusiveOrExpression"; + SyntaxKind[SyntaxKind["BitwiseAndExpression"] = 191] = "BitwiseAndExpression"; + SyntaxKind[SyntaxKind["EqualsWithTypeConversionExpression"] = 192] = "EqualsWithTypeConversionExpression"; + SyntaxKind[SyntaxKind["NotEqualsWithTypeConversionExpression"] = 193] = "NotEqualsWithTypeConversionExpression"; + SyntaxKind[SyntaxKind["EqualsExpression"] = 194] = "EqualsExpression"; + SyntaxKind[SyntaxKind["NotEqualsExpression"] = 195] = "NotEqualsExpression"; + SyntaxKind[SyntaxKind["LessThanExpression"] = 196] = "LessThanExpression"; + SyntaxKind[SyntaxKind["GreaterThanExpression"] = 197] = "GreaterThanExpression"; + SyntaxKind[SyntaxKind["LessThanOrEqualExpression"] = 198] = "LessThanOrEqualExpression"; + SyntaxKind[SyntaxKind["GreaterThanOrEqualExpression"] = 199] = "GreaterThanOrEqualExpression"; + SyntaxKind[SyntaxKind["InstanceOfExpression"] = 200] = "InstanceOfExpression"; + SyntaxKind[SyntaxKind["InExpression"] = 201] = "InExpression"; + SyntaxKind[SyntaxKind["LeftShiftExpression"] = 202] = "LeftShiftExpression"; + SyntaxKind[SyntaxKind["SignedRightShiftExpression"] = 203] = "SignedRightShiftExpression"; + SyntaxKind[SyntaxKind["UnsignedRightShiftExpression"] = 204] = "UnsignedRightShiftExpression"; + SyntaxKind[SyntaxKind["MultiplyExpression"] = 205] = "MultiplyExpression"; + SyntaxKind[SyntaxKind["DivideExpression"] = 206] = "DivideExpression"; + SyntaxKind[SyntaxKind["ModuloExpression"] = 207] = "ModuloExpression"; + SyntaxKind[SyntaxKind["AddExpression"] = 208] = "AddExpression"; + SyntaxKind[SyntaxKind["SubtractExpression"] = 209] = "SubtractExpression"; + SyntaxKind[SyntaxKind["PostIncrementExpression"] = 210] = "PostIncrementExpression"; + SyntaxKind[SyntaxKind["PostDecrementExpression"] = 211] = "PostDecrementExpression"; + SyntaxKind[SyntaxKind["MemberAccessExpression"] = 212] = "MemberAccessExpression"; + SyntaxKind[SyntaxKind["InvocationExpression"] = 213] = "InvocationExpression"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 214] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 215] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 216] = "ObjectCreationExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 217] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 218] = "ParenthesizedArrowFunctionExpression"; + SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 219] = "SimpleArrowFunctionExpression"; + SyntaxKind[SyntaxKind["CastExpression"] = 220] = "CastExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 221] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 222] = "FunctionExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 223] = "OmittedExpression"; + + SyntaxKind[SyntaxKind["VariableDeclaration"] = 224] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarator"] = 225] = "VariableDeclarator"; + + SyntaxKind[SyntaxKind["ArgumentList"] = 226] = "ArgumentList"; + SyntaxKind[SyntaxKind["ParameterList"] = 227] = "ParameterList"; + SyntaxKind[SyntaxKind["TypeArgumentList"] = 228] = "TypeArgumentList"; + SyntaxKind[SyntaxKind["TypeParameterList"] = 229] = "TypeParameterList"; + + SyntaxKind[SyntaxKind["ExtendsHeritageClause"] = 230] = "ExtendsHeritageClause"; + SyntaxKind[SyntaxKind["ImplementsHeritageClause"] = 231] = "ImplementsHeritageClause"; + SyntaxKind[SyntaxKind["EqualsValueClause"] = 232] = "EqualsValueClause"; + SyntaxKind[SyntaxKind["CaseSwitchClause"] = 233] = "CaseSwitchClause"; + SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 234] = "DefaultSwitchClause"; + SyntaxKind[SyntaxKind["ElseClause"] = 235] = "ElseClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 236] = "CatchClause"; + SyntaxKind[SyntaxKind["FinallyClause"] = 237] = "FinallyClause"; + + SyntaxKind[SyntaxKind["TypeParameter"] = 238] = "TypeParameter"; + SyntaxKind[SyntaxKind["Constraint"] = 239] = "Constraint"; + + SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 240] = "SimplePropertyAssignment"; + + SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 241] = "FunctionPropertyAssignment"; + + SyntaxKind[SyntaxKind["Parameter"] = 242] = "Parameter"; + SyntaxKind[SyntaxKind["EnumElement"] = 243] = "EnumElement"; + SyntaxKind[SyntaxKind["TypeAnnotation"] = 244] = "TypeAnnotation"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 245] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 246] = "ModuleNameModuleReference"; + SyntaxKind[SyntaxKind["Last"] = SyntaxKind.ModuleNameModuleReference] = "Last"; + + SyntaxKind[SyntaxKind["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword"; + SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword"; + + SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword"; + SyntaxKind[SyntaxKind["LastFutureReservedKeyword"] = SyntaxKind.SuperKeyword] = "LastFutureReservedKeyword"; + + SyntaxKind[SyntaxKind["FirstFutureReservedStrictKeyword"] = SyntaxKind.ImplementsKeyword] = "FirstFutureReservedStrictKeyword"; + SyntaxKind[SyntaxKind["LastFutureReservedStrictKeyword"] = SyntaxKind.YieldKeyword] = "LastFutureReservedStrictKeyword"; + + SyntaxKind[SyntaxKind["FirstTypeScriptKeyword"] = SyntaxKind.AnyKeyword] = "FirstTypeScriptKeyword"; + SyntaxKind[SyntaxKind["LastTypeScriptKeyword"] = SyntaxKind.StringKeyword] = "LastTypeScriptKeyword"; + + SyntaxKind[SyntaxKind["FirstKeyword"] = SyntaxKind.FirstStandardKeyword] = "FirstKeyword"; + SyntaxKind[SyntaxKind["LastKeyword"] = SyntaxKind.LastTypeScriptKeyword] = "LastKeyword"; + + SyntaxKind[SyntaxKind["FirstToken"] = SyntaxKind.ErrorToken] = "FirstToken"; + SyntaxKind[SyntaxKind["LastToken"] = SyntaxKind.SlashEqualsToken] = "LastToken"; + + SyntaxKind[SyntaxKind["FirstPunctuation"] = SyntaxKind.OpenBraceToken] = "FirstPunctuation"; + SyntaxKind[SyntaxKind["LastPunctuation"] = SyntaxKind.SlashEqualsToken] = "LastPunctuation"; + + SyntaxKind[SyntaxKind["FirstFixedWidth"] = SyntaxKind.FirstKeyword] = "FirstFixedWidth"; + SyntaxKind[SyntaxKind["LastFixedWidth"] = SyntaxKind.LastPunctuation] = "LastFixedWidth"; + + SyntaxKind[SyntaxKind["FirstTrivia"] = SyntaxKind.WhitespaceTrivia] = "FirstTrivia"; + SyntaxKind[SyntaxKind["LastTrivia"] = SyntaxKind.SkippedTokenTrivia] = "LastTrivia"; + })(TypeScript.SyntaxKind || (TypeScript.SyntaxKind = {})); + var SyntaxKind = TypeScript.SyntaxKind; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxFacts) { + var textToKeywordKind = { + "any": 60 /* AnyKeyword */, + "boolean": 61 /* BooleanKeyword */, + "break": 15 /* BreakKeyword */, + "case": 16 /* CaseKeyword */, + "catch": 17 /* CatchKeyword */, + "class": 44 /* ClassKeyword */, + "continue": 18 /* ContinueKeyword */, + "const": 45 /* ConstKeyword */, + "constructor": 62 /* ConstructorKeyword */, + "debugger": 19 /* DebuggerKeyword */, + "declare": 63 /* DeclareKeyword */, + "default": 20 /* DefaultKeyword */, + "delete": 21 /* DeleteKeyword */, + "do": 22 /* DoKeyword */, + "else": 23 /* ElseKeyword */, + "enum": 46 /* EnumKeyword */, + "export": 47 /* ExportKeyword */, + "extends": 48 /* ExtendsKeyword */, + "false": 24 /* FalseKeyword */, + "finally": 25 /* FinallyKeyword */, + "for": 26 /* ForKeyword */, + "function": 27 /* FunctionKeyword */, + "get": 64 /* GetKeyword */, + "if": 28 /* IfKeyword */, + "implements": 51 /* ImplementsKeyword */, + "import": 49 /* ImportKeyword */, + "in": 29 /* InKeyword */, + "instanceof": 30 /* InstanceOfKeyword */, + "interface": 52 /* InterfaceKeyword */, + "let": 53 /* LetKeyword */, + "module": 65 /* ModuleKeyword */, + "new": 31 /* NewKeyword */, + "null": 32 /* NullKeyword */, + "number": 67 /* NumberKeyword */, + "package": 54 /* PackageKeyword */, + "private": 55 /* PrivateKeyword */, + "protected": 56 /* ProtectedKeyword */, + "public": 57 /* PublicKeyword */, + "require": 66 /* RequireKeyword */, + "return": 33 /* ReturnKeyword */, + "set": 68 /* SetKeyword */, + "static": 58 /* StaticKeyword */, + "string": 69 /* StringKeyword */, + "super": 50 /* SuperKeyword */, + "switch": 34 /* SwitchKeyword */, + "this": 35 /* ThisKeyword */, + "throw": 36 /* ThrowKeyword */, + "true": 37 /* TrueKeyword */, + "try": 38 /* TryKeyword */, + "typeof": 39 /* TypeOfKeyword */, + "var": 40 /* VarKeyword */, + "void": 41 /* VoidKeyword */, + "while": 42 /* WhileKeyword */, + "with": 43 /* WithKeyword */, + "yield": 59 /* YieldKeyword */, + "{": 70 /* OpenBraceToken */, + "}": 71 /* CloseBraceToken */, + "(": 72 /* OpenParenToken */, + ")": 73 /* CloseParenToken */, + "[": 74 /* OpenBracketToken */, + "]": 75 /* CloseBracketToken */, + ".": 76 /* DotToken */, + "...": 77 /* DotDotDotToken */, + ";": 78 /* SemicolonToken */, + ",": 79 /* CommaToken */, + "<": 80 /* LessThanToken */, + ">": 81 /* GreaterThanToken */, + "<=": 82 /* LessThanEqualsToken */, + ">=": 83 /* GreaterThanEqualsToken */, + "==": 84 /* EqualsEqualsToken */, + "=>": 85 /* EqualsGreaterThanToken */, + "!=": 86 /* ExclamationEqualsToken */, + "===": 87 /* EqualsEqualsEqualsToken */, + "!==": 88 /* ExclamationEqualsEqualsToken */, + "+": 89 /* PlusToken */, + "-": 90 /* MinusToken */, + "*": 91 /* AsteriskToken */, + "%": 92 /* PercentToken */, + "++": 93 /* PlusPlusToken */, + "--": 94 /* MinusMinusToken */, + "<<": 95 /* LessThanLessThanToken */, + ">>": 96 /* GreaterThanGreaterThanToken */, + ">>>": 97 /* GreaterThanGreaterThanGreaterThanToken */, + "&": 98 /* AmpersandToken */, + "|": 99 /* BarToken */, + "^": 100 /* CaretToken */, + "!": 101 /* ExclamationToken */, + "~": 102 /* TildeToken */, + "&&": 103 /* AmpersandAmpersandToken */, + "||": 104 /* BarBarToken */, + "?": 105 /* QuestionToken */, + ":": 106 /* ColonToken */, + "=": 107 /* EqualsToken */, + "+=": 108 /* PlusEqualsToken */, + "-=": 109 /* MinusEqualsToken */, + "*=": 110 /* AsteriskEqualsToken */, + "%=": 111 /* PercentEqualsToken */, + "<<=": 112 /* LessThanLessThanEqualsToken */, + ">>=": 113 /* GreaterThanGreaterThanEqualsToken */, + ">>>=": 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */, + "&=": 115 /* AmpersandEqualsToken */, + "|=": 116 /* BarEqualsToken */, + "^=": 117 /* CaretEqualsToken */, + "/": 118 /* SlashToken */, + "/=": 119 /* SlashEqualsToken */ + }; + + var kindToText = new Array(); + + for (var name in textToKeywordKind) { + if (textToKeywordKind.hasOwnProperty(name)) { + kindToText[textToKeywordKind[name]] = name; + } + } + + kindToText[62 /* ConstructorKeyword */] = "constructor"; + + function getTokenKind(text) { + if (textToKeywordKind.hasOwnProperty(text)) { + return textToKeywordKind[text]; + } + + return 0 /* None */; + } + SyntaxFacts.getTokenKind = getTokenKind; + + function getText(kind) { + var result = kindToText[kind]; + return result !== undefined ? result : null; + } + SyntaxFacts.getText = getText; + + function isTokenKind(kind) { + return kind >= 9 /* FirstToken */ && kind <= 119 /* LastToken */; + } + SyntaxFacts.isTokenKind = isTokenKind; + + function isAnyKeyword(kind) { + return kind >= 15 /* FirstKeyword */ && kind <= 69 /* LastKeyword */; + } + SyntaxFacts.isAnyKeyword = isAnyKeyword; + + function isStandardKeyword(kind) { + return kind >= 15 /* FirstStandardKeyword */ && kind <= 43 /* LastStandardKeyword */; + } + SyntaxFacts.isStandardKeyword = isStandardKeyword; + + function isFutureReservedKeyword(kind) { + return kind >= 44 /* FirstFutureReservedKeyword */ && kind <= 50 /* LastFutureReservedKeyword */; + } + SyntaxFacts.isFutureReservedKeyword = isFutureReservedKeyword; + + function isFutureReservedStrictKeyword(kind) { + return kind >= 51 /* FirstFutureReservedStrictKeyword */ && kind <= 59 /* LastFutureReservedStrictKeyword */; + } + SyntaxFacts.isFutureReservedStrictKeyword = isFutureReservedStrictKeyword; + + function isAnyPunctuation(kind) { + return kind >= 70 /* FirstPunctuation */ && kind <= 119 /* LastPunctuation */; + } + SyntaxFacts.isAnyPunctuation = isAnyPunctuation; + + function isPrefixUnaryExpressionOperatorToken(tokenKind) { + return getPrefixUnaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */; + } + SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken; + + function isBinaryExpressionOperatorToken(tokenKind) { + return getBinaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */; + } + SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken; + + function getPrefixUnaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 89 /* PlusToken */: + return 164 /* PlusExpression */; + case 90 /* MinusToken */: + return 165 /* NegateExpression */; + case 102 /* TildeToken */: + return 166 /* BitwiseNotExpression */; + case 101 /* ExclamationToken */: + return 167 /* LogicalNotExpression */; + case 93 /* PlusPlusToken */: + return 168 /* PreIncrementExpression */; + case 94 /* MinusMinusToken */: + return 169 /* PreDecrementExpression */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken = getPrefixUnaryExpressionFromOperatorToken; + + function getPostfixUnaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 93 /* PlusPlusToken */: + return 210 /* PostIncrementExpression */; + case 94 /* MinusMinusToken */: + return 211 /* PostDecrementExpression */; + default: + return 0 /* None */; + } + } + SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken = getPostfixUnaryExpressionFromOperatorToken; + + function getBinaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 91 /* AsteriskToken */: + return 205 /* MultiplyExpression */; + + case 118 /* SlashToken */: + return 206 /* DivideExpression */; + + case 92 /* PercentToken */: + return 207 /* ModuloExpression */; + + case 89 /* PlusToken */: + return 208 /* AddExpression */; + + case 90 /* MinusToken */: + return 209 /* SubtractExpression */; + + case 95 /* LessThanLessThanToken */: + return 202 /* LeftShiftExpression */; + + case 96 /* GreaterThanGreaterThanToken */: + return 203 /* SignedRightShiftExpression */; + + case 97 /* GreaterThanGreaterThanGreaterThanToken */: + return 204 /* UnsignedRightShiftExpression */; + + case 80 /* LessThanToken */: + return 196 /* LessThanExpression */; + + case 81 /* GreaterThanToken */: + return 197 /* GreaterThanExpression */; + + case 82 /* LessThanEqualsToken */: + return 198 /* LessThanOrEqualExpression */; + + case 83 /* GreaterThanEqualsToken */: + return 199 /* GreaterThanOrEqualExpression */; + + case 30 /* InstanceOfKeyword */: + return 200 /* InstanceOfExpression */; + + case 29 /* InKeyword */: + return 201 /* InExpression */; + + case 84 /* EqualsEqualsToken */: + return 192 /* EqualsWithTypeConversionExpression */; + + case 86 /* ExclamationEqualsToken */: + return 193 /* NotEqualsWithTypeConversionExpression */; + + case 87 /* EqualsEqualsEqualsToken */: + return 194 /* EqualsExpression */; + + case 88 /* ExclamationEqualsEqualsToken */: + return 195 /* NotEqualsExpression */; + + case 98 /* AmpersandToken */: + return 191 /* BitwiseAndExpression */; + + case 100 /* CaretToken */: + return 190 /* BitwiseExclusiveOrExpression */; + + case 99 /* BarToken */: + return 189 /* BitwiseOrExpression */; + + case 103 /* AmpersandAmpersandToken */: + return 188 /* LogicalAndExpression */; + + case 104 /* BarBarToken */: + return 187 /* LogicalOrExpression */; + + case 116 /* BarEqualsToken */: + return 182 /* OrAssignmentExpression */; + + case 115 /* AmpersandEqualsToken */: + return 180 /* AndAssignmentExpression */; + + case 117 /* CaretEqualsToken */: + return 181 /* ExclusiveOrAssignmentExpression */; + + case 112 /* LessThanLessThanEqualsToken */: + return 183 /* LeftShiftAssignmentExpression */; + + case 113 /* GreaterThanGreaterThanEqualsToken */: + return 184 /* SignedRightShiftAssignmentExpression */; + + case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */: + return 185 /* UnsignedRightShiftAssignmentExpression */; + + case 108 /* PlusEqualsToken */: + return 175 /* AddAssignmentExpression */; + + case 109 /* MinusEqualsToken */: + return 176 /* SubtractAssignmentExpression */; + + case 110 /* AsteriskEqualsToken */: + return 177 /* MultiplyAssignmentExpression */; + + case 119 /* SlashEqualsToken */: + return 178 /* DivideAssignmentExpression */; + + case 111 /* PercentEqualsToken */: + return 179 /* ModuloAssignmentExpression */; + + case 107 /* EqualsToken */: + return 174 /* AssignmentExpression */; + + case 79 /* CommaToken */: + return 173 /* CommaExpression */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getBinaryExpressionFromOperatorToken = getBinaryExpressionFromOperatorToken; + + function getOperatorTokenFromBinaryExpression(tokenKind) { + switch (tokenKind) { + case 205 /* MultiplyExpression */: + return 91 /* AsteriskToken */; + + case 206 /* DivideExpression */: + return 118 /* SlashToken */; + + case 207 /* ModuloExpression */: + return 92 /* PercentToken */; + + case 208 /* AddExpression */: + return 89 /* PlusToken */; + + case 209 /* SubtractExpression */: + return 90 /* MinusToken */; + + case 202 /* LeftShiftExpression */: + return 95 /* LessThanLessThanToken */; + + case 203 /* SignedRightShiftExpression */: + return 96 /* GreaterThanGreaterThanToken */; + + case 204 /* UnsignedRightShiftExpression */: + return 97 /* GreaterThanGreaterThanGreaterThanToken */; + + case 196 /* LessThanExpression */: + return 80 /* LessThanToken */; + + case 197 /* GreaterThanExpression */: + return 81 /* GreaterThanToken */; + + case 198 /* LessThanOrEqualExpression */: + return 82 /* LessThanEqualsToken */; + + case 199 /* GreaterThanOrEqualExpression */: + return 83 /* GreaterThanEqualsToken */; + + case 200 /* InstanceOfExpression */: + return 30 /* InstanceOfKeyword */; + + case 201 /* InExpression */: + return 29 /* InKeyword */; + + case 192 /* EqualsWithTypeConversionExpression */: + return 84 /* EqualsEqualsToken */; + + case 193 /* NotEqualsWithTypeConversionExpression */: + return 86 /* ExclamationEqualsToken */; + + case 194 /* EqualsExpression */: + return 87 /* EqualsEqualsEqualsToken */; + + case 195 /* NotEqualsExpression */: + return 88 /* ExclamationEqualsEqualsToken */; + + case 191 /* BitwiseAndExpression */: + return 98 /* AmpersandToken */; + + case 190 /* BitwiseExclusiveOrExpression */: + return 100 /* CaretToken */; + + case 189 /* BitwiseOrExpression */: + return 99 /* BarToken */; + + case 188 /* LogicalAndExpression */: + return 103 /* AmpersandAmpersandToken */; + + case 187 /* LogicalOrExpression */: + return 104 /* BarBarToken */; + + case 182 /* OrAssignmentExpression */: + return 116 /* BarEqualsToken */; + + case 180 /* AndAssignmentExpression */: + return 115 /* AmpersandEqualsToken */; + + case 181 /* ExclusiveOrAssignmentExpression */: + return 117 /* CaretEqualsToken */; + + case 183 /* LeftShiftAssignmentExpression */: + return 112 /* LessThanLessThanEqualsToken */; + + case 184 /* SignedRightShiftAssignmentExpression */: + return 113 /* GreaterThanGreaterThanEqualsToken */; + + case 185 /* UnsignedRightShiftAssignmentExpression */: + return 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */; + + case 175 /* AddAssignmentExpression */: + return 108 /* PlusEqualsToken */; + + case 176 /* SubtractAssignmentExpression */: + return 109 /* MinusEqualsToken */; + + case 177 /* MultiplyAssignmentExpression */: + return 110 /* AsteriskEqualsToken */; + + case 178 /* DivideAssignmentExpression */: + return 119 /* SlashEqualsToken */; + + case 179 /* ModuloAssignmentExpression */: + return 111 /* PercentEqualsToken */; + + case 174 /* AssignmentExpression */: + return 107 /* EqualsToken */; + + case 173 /* CommaExpression */: + return 79 /* CommaToken */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getOperatorTokenFromBinaryExpression = getOperatorTokenFromBinaryExpression; + + function isAnyDivideToken(kind) { + switch (kind) { + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + return true; + default: + return false; + } + } + SyntaxFacts.isAnyDivideToken = isAnyDivideToken; + + function isAnyDivideOrRegularExpressionToken(kind) { + switch (kind) { + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + case 12 /* RegularExpressionLiteral */: + return true; + default: + return false; + } + } + SyntaxFacts.isAnyDivideOrRegularExpressionToken = isAnyDivideOrRegularExpressionToken; + })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {})); + var SyntaxFacts = TypeScript.SyntaxFacts; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var isKeywordStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isIdentifierStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isIdentifierPartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isNumericLiteralStart = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + + for (var character = 0; character < 127 /* maxAsciiCharacter */; character++) { + if (character >= 97 /* a */ && character <= 122 /* z */) { + isIdentifierStartCharacter[character] = true; + isIdentifierPartCharacter[character] = true; + } else if ((character >= 65 /* A */ && character <= 90 /* Z */) || character === 95 /* _ */ || character === 36 /* $ */) { + isIdentifierStartCharacter[character] = true; + isIdentifierPartCharacter[character] = true; + } else if (character >= 48 /* _0 */ && character <= 57 /* _9 */) { + isIdentifierPartCharacter[character] = true; + isNumericLiteralStart[character] = true; + } + } + + isNumericLiteralStart[46 /* dot */] = true; + + for (var keywordKind = 15 /* FirstKeyword */; keywordKind <= 69 /* LastKeyword */; keywordKind++) { + var keyword = TypeScript.SyntaxFacts.getText(keywordKind); + isKeywordStartCharacter[keyword.charCodeAt(0)] = true; + } + + var Scanner = (function () { + function Scanner(fileName, text, languageVersion, window) { + if (typeof window === "undefined") { window = TypeScript.ArrayUtilities.createArray(2048, 0); } + this.slidingWindow = new TypeScript.SlidingWindow(this, window, 0, text.length()); + this.fileName = fileName; + this.text = text; + this._languageVersion = languageVersion; + } + Scanner.prototype.languageVersion = function () { + return this._languageVersion; + }; + + Scanner.prototype.fetchMoreItems = function (argument, sourceIndex, window, destinationIndex, spaceAvailable) { + var charactersRemaining = this.text.length() - sourceIndex; + var amountToRead = TypeScript.MathPrototype.min(charactersRemaining, spaceAvailable); + this.text.copyTo(sourceIndex, window, destinationIndex, amountToRead); + return amountToRead; + }; + + Scanner.prototype.currentCharCode = function () { + return this.slidingWindow.currentItem(null); + }; + + Scanner.prototype.absoluteIndex = function () { + return this.slidingWindow.absoluteIndex(); + }; + + Scanner.prototype.setAbsoluteIndex = function (index) { + this.slidingWindow.setAbsoluteIndex(index); + }; + + Scanner.prototype.scan = function (diagnostics, allowRegularExpression) { + var diagnosticsLength = diagnostics.length; + var fullStart = this.slidingWindow.absoluteIndex(); + var leadingTriviaInfo = this.scanTriviaInfo(diagnostics, false); + + var start = this.slidingWindow.absoluteIndex(); + var kindAndFlags = this.scanSyntaxToken(diagnostics, allowRegularExpression); + var end = this.slidingWindow.absoluteIndex(); + + var trailingTriviaInfo = this.scanTriviaInfo(diagnostics, true); + + var isVariableWidthKeyword = (kindAndFlags & -2147483648 /* IsVariableWidthKeyword */) !== 0; + var kind = kindAndFlags & ~-2147483648 /* IsVariableWidthKeyword */; + + var token = this.createToken(fullStart, leadingTriviaInfo, start, kind, end, trailingTriviaInfo, isVariableWidthKeyword); + + return diagnosticsLength !== diagnostics.length ? TypeScript.Syntax.realizeToken(token) : token; + }; + + Scanner.prototype.createToken = function (fullStart, leadingTriviaInfo, start, kind, end, trailingTriviaInfo, isVariableWidthKeyword) { + if (!isVariableWidthKeyword && kind >= 15 /* FirstFixedWidth */) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.FixedWidthTokenWithNoTrivia(kind); + } else { + return new TypeScript.Syntax.FixedWidthTokenWithTrailingTrivia(this.text, fullStart, kind, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.FixedWidthTokenWithLeadingTrivia(this.text, fullStart, kind, leadingTriviaInfo); + } else { + return new TypeScript.Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia(this.text, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo); + } + } else { + var width = end - start; + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.VariableWidthTokenWithNoTrivia(this.text, fullStart, kind, width); + } else { + return new TypeScript.Syntax.VariableWidthTokenWithTrailingTrivia(this.text, fullStart, kind, width, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.VariableWidthTokenWithLeadingTrivia(this.text, fullStart, kind, leadingTriviaInfo, width); + } else { + return new TypeScript.Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia(this.text, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo); + } + } + }; + + Scanner.scanTrivia = function (text, start, length, isTrailing) { + var scanner = new Scanner(null, text.subText(new TypeScript.TextSpan(start, length)), 1 /* EcmaScript5 */, Scanner.triviaWindow); + return scanner.scanTrivia(text, start, isTrailing); + }; + + Scanner.prototype.scanTrivia = function (underlyingText, underlyingTextStart, isTrailing) { + var trivia = new Array(); + + while (true) { + if (!this.slidingWindow.isAtEndOfSource()) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + trivia.push(this.scanWhitespaceTrivia(underlyingText, underlyingTextStart)); + continue; + + case 47 /* slash */: + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 47 /* slash */) { + trivia.push(this.scanSingleLineCommentTrivia(underlyingText, underlyingTextStart)); + continue; + } + + if (ch2 === 42 /* asterisk */) { + trivia.push(this.scanMultiLineCommentTrivia(underlyingText, underlyingTextStart)); + continue; + } + + throw TypeScript.Errors.invalidOperation(); + + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + trivia.push(this.scanLineTerminatorSequenceTrivia(ch)); + + if (!isTrailing) { + continue; + } + + break; + + default: + throw TypeScript.Errors.invalidOperation(); + } + } + + return TypeScript.Syntax.triviaList(trivia); + } + }; + + Scanner.prototype.scanTriviaInfo = function (diagnostics, isTrailing) { + var width = 0; + var hasCommentOrNewLine = 0; + + while (true) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + this.slidingWindow.moveToNextItem(); + width++; + continue; + + case 47 /* slash */: + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 47 /* slash */) { + hasCommentOrNewLine |= 2 /* TriviaCommentMask */; + width += this.scanSingleLineCommentTriviaLength(); + continue; + } + + if (ch2 === 42 /* asterisk */) { + hasCommentOrNewLine |= 2 /* TriviaCommentMask */; + width += this.scanMultiLineCommentTriviaLength(diagnostics); + continue; + } + + break; + + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + hasCommentOrNewLine |= 1 /* TriviaNewLineMask */; + width += this.scanLineTerminatorSequenceLength(ch); + + if (!isTrailing) { + continue; + } + + break; + } + + return (width << 2 /* TriviaFullWidthShift */) | hasCommentOrNewLine; + } + }; + + Scanner.prototype.isNewLineCharacter = function (ch) { + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + return true; + default: + return false; + } + }; + + Scanner.prototype.scanWhitespaceTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.absoluteIndex(); + + var width = 0; + while (true) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + this.slidingWindow.moveToNextItem(); + width++; + continue; + } + + break; + } + + return TypeScript.Syntax.deferredTrivia(4 /* WhitespaceTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanSingleLineCommentTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.slidingWindow.absoluteIndex(); + var width = this.scanSingleLineCommentTriviaLength(); + + return TypeScript.Syntax.deferredTrivia(7 /* SingleLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanSingleLineCommentTriviaLength = function () { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + var width = 2; + while (true) { + if (this.slidingWindow.isAtEndOfSource() || this.isNewLineCharacter(this.currentCharCode())) { + return width; + } + + this.slidingWindow.moveToNextItem(); + width++; + } + }; + + Scanner.prototype.scanMultiLineCommentTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.absoluteIndex(); + var width = this.scanMultiLineCommentTriviaLength(null); + + return TypeScript.Syntax.deferredTrivia(6 /* MultiLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanMultiLineCommentTriviaLength = function (diagnostics) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + var width = 2; + while (true) { + if (this.slidingWindow.isAtEndOfSource()) { + if (diagnostics !== null) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), this.slidingWindow.absoluteIndex(), 0, TypeScript.DiagnosticCode.AsteriskSlash_expected, null)); + } + + return width; + } + + var ch = this.currentCharCode(); + if (ch === 42 /* asterisk */ && this.slidingWindow.peekItemN(1) === 47 /* slash */) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + width += 2; + return width; + } + + this.slidingWindow.moveToNextItem(); + width++; + } + }; + + Scanner.prototype.scanLineTerminatorSequenceTrivia = function (ch) { + var absoluteStartIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + var width = this.scanLineTerminatorSequenceLength(ch); + + var text = this.substring(absoluteStartIndex, absoluteStartIndex + width, false); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(absoluteStartIndex); + + return TypeScript.Syntax.trivia(5 /* NewLineTrivia */, text); + }; + + Scanner.prototype.scanLineTerminatorSequenceLength = function (ch) { + this.slidingWindow.moveToNextItem(); + + if (ch === 13 /* carriageReturn */ && this.currentCharCode() === 10 /* lineFeed */) { + this.slidingWindow.moveToNextItem(); + return 2; + } else { + return 1; + } + }; + + Scanner.prototype.scanSyntaxToken = function (diagnostics, allowRegularExpression) { + if (this.slidingWindow.isAtEndOfSource()) { + return 10 /* EndOfFileToken */; + } + + var character = this.currentCharCode(); + + switch (character) { + case 34 /* doubleQuote */: + case 39 /* singleQuote */: + return this.scanStringLiteral(diagnostics); + + case 47 /* slash */: + return this.scanSlashToken(allowRegularExpression); + + case 46 /* dot */: + return this.scanDotToken(diagnostics); + + case 45 /* minus */: + return this.scanMinusToken(); + + case 33 /* exclamation */: + return this.scanExclamationToken(); + + case 61 /* equals */: + return this.scanEqualsToken(); + + case 124 /* bar */: + return this.scanBarToken(); + + case 42 /* asterisk */: + return this.scanAsteriskToken(); + + case 43 /* plus */: + return this.scanPlusToken(); + + case 37 /* percent */: + return this.scanPercentToken(); + + case 38 /* ampersand */: + return this.scanAmpersandToken(); + + case 94 /* caret */: + return this.scanCaretToken(); + + case 60 /* lessThan */: + return this.scanLessThanToken(); + + case 62 /* greaterThan */: + return this.advanceAndSetTokenKind(81 /* GreaterThanToken */); + + case 44 /* comma */: + return this.advanceAndSetTokenKind(79 /* CommaToken */); + + case 58 /* colon */: + return this.advanceAndSetTokenKind(106 /* ColonToken */); + + case 59 /* semicolon */: + return this.advanceAndSetTokenKind(78 /* SemicolonToken */); + + case 126 /* tilde */: + return this.advanceAndSetTokenKind(102 /* TildeToken */); + + case 40 /* openParen */: + return this.advanceAndSetTokenKind(72 /* OpenParenToken */); + + case 41 /* closeParen */: + return this.advanceAndSetTokenKind(73 /* CloseParenToken */); + + case 123 /* openBrace */: + return this.advanceAndSetTokenKind(70 /* OpenBraceToken */); + + case 125 /* closeBrace */: + return this.advanceAndSetTokenKind(71 /* CloseBraceToken */); + + case 91 /* openBracket */: + return this.advanceAndSetTokenKind(74 /* OpenBracketToken */); + + case 93 /* closeBracket */: + return this.advanceAndSetTokenKind(75 /* CloseBracketToken */); + + case 63 /* question */: + return this.advanceAndSetTokenKind(105 /* QuestionToken */); + } + + if (isNumericLiteralStart[character]) { + return this.scanNumericLiteral(diagnostics); + } + + if (isIdentifierStartCharacter[character]) { + var result = this.tryFastScanIdentifierOrKeyword(character); + if (result !== 0 /* None */) { + return result; + } + } + + if (this.isIdentifierStart(this.peekCharOrUnicodeEscape())) { + return this.slowScanIdentifierOrKeyword(diagnostics); + } + + return this.scanDefaultCharacter(character, diagnostics); + }; + + Scanner.prototype.isIdentifierStart = function (interpretedChar) { + if (isIdentifierStartCharacter[interpretedChar]) { + return true; + } + + return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierStart(interpretedChar, this._languageVersion); + }; + + Scanner.prototype.isIdentifierPart = function (interpretedChar) { + if (isIdentifierPartCharacter[interpretedChar]) { + return true; + } + + return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierPart(interpretedChar, this._languageVersion); + }; + + Scanner.prototype.tryFastScanIdentifierOrKeyword = function (firstCharacter) { + var slidingWindow = this.slidingWindow; + var window = slidingWindow.window; + + var startIndex = slidingWindow.currentRelativeItemIndex; + var endIndex = slidingWindow.windowCount; + var currentIndex = startIndex; + var character = 0; + + while (currentIndex < endIndex) { + character = window[currentIndex]; + if (!isIdentifierPartCharacter[character]) { + break; + } + + currentIndex++; + } + + if (currentIndex === endIndex) { + return 0 /* None */; + } else if (character === 92 /* backslash */ || character > 127 /* maxAsciiCharacter */) { + return 0 /* None */; + } else { + var kind; + var identifierLength = currentIndex - startIndex; + if (isKeywordStartCharacter[firstCharacter]) { + kind = TypeScript.ScannerUtilities.identifierKind(window, startIndex, identifierLength); + } else { + kind = 11 /* IdentifierName */; + } + + slidingWindow.setAbsoluteIndex(slidingWindow.absoluteIndex() + identifierLength); + + return kind; + } + }; + + Scanner.prototype.slowScanIdentifierOrKeyword = function (diagnostics) { + var startIndex = this.slidingWindow.absoluteIndex(); + var sawUnicodeEscape = false; + + do { + var unicodeEscape = this.scanCharOrUnicodeEscape(diagnostics); + sawUnicodeEscape = sawUnicodeEscape || unicodeEscape; + } while(this.isIdentifierPart(this.peekCharOrUnicodeEscape())); + + var length = this.slidingWindow.absoluteIndex() - startIndex; + var text = this.text.substr(startIndex, length, false); + var valueText = TypeScript.Syntax.massageEscapes(text); + + var keywordKind = TypeScript.SyntaxFacts.getTokenKind(valueText); + if (keywordKind >= 15 /* FirstKeyword */ && keywordKind <= 69 /* LastKeyword */) { + if (sawUnicodeEscape) { + return keywordKind | -2147483648 /* IsVariableWidthKeyword */; + } else { + return keywordKind; + } + } + + return 11 /* IdentifierName */; + }; + + Scanner.prototype.scanNumericLiteral = function (diagnostics) { + if (this.isHexNumericLiteral()) { + this.scanHexNumericLiteral(); + } else if (this.isOctalNumericLiteral()) { + this.scanOctalNumericLiteral(diagnostics); + } else { + this.scanDecimalNumericLiteral(); + } + + return 13 /* NumericLiteral */; + }; + + Scanner.prototype.isOctalNumericLiteral = function () { + return this.currentCharCode() === 48 /* _0 */ && TypeScript.CharacterInfo.isOctalDigit(this.slidingWindow.peekItemN(1)); + }; + + Scanner.prototype.scanOctalNumericLiteral = function (diagnostics) { + var position = this.absoluteIndex(); + + while (TypeScript.CharacterInfo.isOctalDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + + if (this.languageVersion() >= 1 /* EcmaScript5 */) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, this.absoluteIndex() - position, TypeScript.DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, null)); + } + }; + + Scanner.prototype.scanDecimalDigits = function () { + while (TypeScript.CharacterInfo.isDecimalDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + }; + + Scanner.prototype.scanDecimalNumericLiteral = function () { + this.scanDecimalDigits(); + + if (this.currentCharCode() === 46 /* dot */) { + this.slidingWindow.moveToNextItem(); + } + + this.scanDecimalDigits(); + + var ch = this.currentCharCode(); + if (ch === 101 /* e */ || ch === 69 /* E */) { + var nextChar1 = this.slidingWindow.peekItemN(1); + + if (TypeScript.CharacterInfo.isDecimalDigit(nextChar1)) { + this.slidingWindow.moveToNextItem(); + this.scanDecimalDigits(); + } else if (nextChar1 === 45 /* minus */ || nextChar1 === 43 /* plus */) { + var nextChar2 = this.slidingWindow.peekItemN(2); + if (TypeScript.CharacterInfo.isDecimalDigit(nextChar2)) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + this.scanDecimalDigits(); + } + } + } + }; + + Scanner.prototype.scanHexNumericLiteral = function () { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + while (TypeScript.CharacterInfo.isHexDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + }; + + Scanner.prototype.isHexNumericLiteral = function () { + if (this.currentCharCode() === 48 /* _0 */) { + var ch = this.slidingWindow.peekItemN(1); + + if (ch === 120 /* x */ || ch === 88 /* X */) { + ch = this.slidingWindow.peekItemN(2); + + return TypeScript.CharacterInfo.isHexDigit(ch); + } + } + + return false; + }; + + Scanner.prototype.advanceAndSetTokenKind = function (kind) { + this.slidingWindow.moveToNextItem(); + return kind; + }; + + Scanner.prototype.scanLessThanToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 82 /* LessThanEqualsToken */; + } else if (this.currentCharCode() === 60 /* lessThan */) { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 112 /* LessThanLessThanEqualsToken */; + } else { + return 95 /* LessThanLessThanToken */; + } + } else { + return 80 /* LessThanToken */; + } + }; + + Scanner.prototype.scanBarToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 116 /* BarEqualsToken */; + } else if (this.currentCharCode() === 124 /* bar */) { + this.slidingWindow.moveToNextItem(); + return 104 /* BarBarToken */; + } else { + return 99 /* BarToken */; + } + }; + + Scanner.prototype.scanCaretToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 117 /* CaretEqualsToken */; + } else { + return 100 /* CaretToken */; + } + }; + + Scanner.prototype.scanAmpersandToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 115 /* AmpersandEqualsToken */; + } else if (this.currentCharCode() === 38 /* ampersand */) { + this.slidingWindow.moveToNextItem(); + return 103 /* AmpersandAmpersandToken */; + } else { + return 98 /* AmpersandToken */; + } + }; + + Scanner.prototype.scanPercentToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 111 /* PercentEqualsToken */; + } else { + return 92 /* PercentToken */; + } + }; + + Scanner.prototype.scanMinusToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 109 /* MinusEqualsToken */; + } else if (character === 45 /* minus */) { + this.slidingWindow.moveToNextItem(); + return 94 /* MinusMinusToken */; + } else { + return 90 /* MinusToken */; + } + }; + + Scanner.prototype.scanPlusToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 108 /* PlusEqualsToken */; + } else if (character === 43 /* plus */) { + this.slidingWindow.moveToNextItem(); + return 93 /* PlusPlusToken */; + } else { + return 89 /* PlusToken */; + } + }; + + Scanner.prototype.scanAsteriskToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 110 /* AsteriskEqualsToken */; + } else { + return 91 /* AsteriskToken */; + } + }; + + Scanner.prototype.scanEqualsToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + return 87 /* EqualsEqualsEqualsToken */; + } else { + return 84 /* EqualsEqualsToken */; + } + } else if (character === 62 /* greaterThan */) { + this.slidingWindow.moveToNextItem(); + return 85 /* EqualsGreaterThanToken */; + } else { + return 107 /* EqualsToken */; + } + }; + + Scanner.prototype.isDotPrefixedNumericLiteral = function () { + if (this.currentCharCode() === 46 /* dot */) { + var ch = this.slidingWindow.peekItemN(1); + return TypeScript.CharacterInfo.isDecimalDigit(ch); + } + + return false; + }; + + Scanner.prototype.scanDotToken = function (diagnostics) { + if (this.isDotPrefixedNumericLiteral()) { + return this.scanNumericLiteral(diagnostics); + } + + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 46 /* dot */ && this.slidingWindow.peekItemN(1) === 46 /* dot */) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + return 77 /* DotDotDotToken */; + } else { + return 76 /* DotToken */; + } + }; + + Scanner.prototype.scanSlashToken = function (allowRegularExpression) { + if (allowRegularExpression) { + var result = this.tryScanRegularExpressionToken(); + if (result !== 0 /* None */) { + return result; + } + } + + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 119 /* SlashEqualsToken */; + } else { + return 118 /* SlashToken */; + } + }; + + Scanner.prototype.tryScanRegularExpressionToken = function () { + var startIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + this.slidingWindow.moveToNextItem(); + + var inEscape = false; + var inCharacterClass = false; + while (true) { + var ch = this.currentCharCode(); + + if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) { + this.slidingWindow.rewindToPinnedIndex(startIndex); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + return 0 /* None */; + } + + this.slidingWindow.moveToNextItem(); + if (inEscape) { + inEscape = false; + continue; + } + + switch (ch) { + case 92 /* backslash */: + inEscape = true; + continue; + + case 91 /* openBracket */: + inCharacterClass = true; + continue; + + case 93 /* closeBracket */: + inCharacterClass = false; + continue; + + case 47 /* slash */: + if (inCharacterClass) { + continue; + } + + break; + + default: + continue; + } + + break; + } + + while (isIdentifierPartCharacter[this.currentCharCode()]) { + this.slidingWindow.moveToNextItem(); + } + + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + return 12 /* RegularExpressionLiteral */; + }; + + Scanner.prototype.scanExclamationToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + return 88 /* ExclamationEqualsEqualsToken */; + } else { + return 86 /* ExclamationEqualsToken */; + } + } else { + return 101 /* ExclamationToken */; + } + }; + + Scanner.prototype.scanDefaultCharacter = function (character, diagnostics) { + var position = this.slidingWindow.absoluteIndex(); + this.slidingWindow.moveToNextItem(); + + var text = String.fromCharCode(character); + var messageText = this.getErrorMessageText(text); + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, 1, TypeScript.DiagnosticCode.Unexpected_character_0, [messageText])); + + return 9 /* ErrorToken */; + }; + + Scanner.prototype.getErrorMessageText = function (text) { + if (text === "\\") { + return '"\\"'; + } + + return JSON.stringify(text); + }; + + Scanner.prototype.skipEscapeSequence = function (diagnostics) { + var rewindPoint = this.slidingWindow.getAndPinAbsoluteIndex(); + + this.slidingWindow.moveToNextItem(); + + var ch = this.currentCharCode(); + this.slidingWindow.moveToNextItem(); + switch (ch) { + case 120 /* x */: + case 117 /* u */: + this.slidingWindow.rewindToPinnedIndex(rewindPoint); + var value = this.scanUnicodeOrHexEscape(diagnostics); + break; + + case 13 /* carriageReturn */: + if (this.currentCharCode() === 10 /* lineFeed */) { + this.slidingWindow.moveToNextItem(); + } + break; + + default: + break; + } + + this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint); + }; + + Scanner.prototype.scanStringLiteral = function (diagnostics) { + var quoteCharacter = this.currentCharCode(); + + this.slidingWindow.moveToNextItem(); + + while (true) { + var ch = this.currentCharCode(); + if (ch === 92 /* backslash */) { + this.skipEscapeSequence(diagnostics); + } else if (ch === quoteCharacter) { + this.slidingWindow.moveToNextItem(); + break; + } else if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), TypeScript.MathPrototype.min(this.slidingWindow.absoluteIndex(), this.text.length()), 1, TypeScript.DiagnosticCode.Missing_close_quote_character, null)); + break; + } else { + this.slidingWindow.moveToNextItem(); + } + } + + return 14 /* StringLiteral */; + }; + + Scanner.prototype.isUnicodeEscape = function (character) { + if (character === 92 /* backslash */) { + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 117 /* u */) { + return true; + } + } + + return false; + }; + + Scanner.prototype.peekCharOrUnicodeEscape = function () { + var character = this.currentCharCode(); + if (this.isUnicodeEscape(character)) { + return this.peekUnicodeOrHexEscape(); + } else { + return character; + } + }; + + Scanner.prototype.peekUnicodeOrHexEscape = function () { + var startIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + var ch = this.scanUnicodeOrHexEscape(null); + + this.slidingWindow.rewindToPinnedIndex(startIndex); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + + return ch; + }; + + Scanner.prototype.scanCharOrUnicodeEscape = function (errors) { + var ch = this.currentCharCode(); + if (ch === 92 /* backslash */) { + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 117 /* u */) { + this.scanUnicodeOrHexEscape(errors); + return true; + } + } + + this.slidingWindow.moveToNextItem(); + return false; + }; + + Scanner.prototype.scanUnicodeOrHexEscape = function (errors) { + var start = this.slidingWindow.absoluteIndex(); + var character = this.currentCharCode(); + + this.slidingWindow.moveToNextItem(); + + character = this.currentCharCode(); + + var intChar = 0; + this.slidingWindow.moveToNextItem(); + + var count = character === 117 /* u */ ? 4 : 2; + + for (var i = 0; i < count; i++) { + var ch2 = this.currentCharCode(); + if (!TypeScript.CharacterInfo.isHexDigit(ch2)) { + if (errors !== null) { + var end = this.slidingWindow.absoluteIndex(); + var info = this.createIllegalEscapeDiagnostic(start, end); + errors.push(info); + } + + break; + } + + intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2); + this.slidingWindow.moveToNextItem(); + } + + return intChar; + }; + + Scanner.prototype.substring = function (start, end, intern) { + var length = end - start; + var offset = start - this.slidingWindow.windowAbsoluteStartIndex; + + if (intern) { + return TypeScript.Collections.DefaultStringTable.addCharArray(this.slidingWindow.window, offset, length); + } else { + return TypeScript.StringUtilities.fromCharCodeArray(this.slidingWindow.window.slice(offset, offset + length)); + } + }; + + Scanner.prototype.createIllegalEscapeDiagnostic = function (start, end) { + return new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), start, end - start, TypeScript.DiagnosticCode.Unrecognized_escape_sequence, null); + }; + + Scanner.isValidIdentifier = function (text, languageVersion) { + var scanner = new Scanner(null, text, languageVersion, Scanner.triviaWindow); + var errors = new Array(); + var token = scanner.scan(errors, false); + + return errors.length === 0 && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token) && token.width() === text.length(); + }; + Scanner.triviaWindow = TypeScript.ArrayUtilities.createArray(2048, 0); + return Scanner; + })(); + TypeScript.Scanner = Scanner; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ScannerUtilities = (function () { + function ScannerUtilities() { + } + ScannerUtilities.identifierKind = function (array, startIndex, length) { + switch (length) { + case 2: + switch (array[startIndex]) { + case 100 /* d */: + return (array[startIndex + 1] === 111 /* o */) ? 22 /* DoKeyword */ : 11 /* IdentifierName */; + case 105 /* i */: + switch (array[startIndex + 1]) { + case 102 /* f */: + return 28 /* IfKeyword */; + case 110 /* n */: + return 29 /* InKeyword */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 3: + switch (array[startIndex]) { + case 102 /* f */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 114 /* r */) ? 26 /* ForKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 119 /* w */) ? 31 /* NewKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 121 /* y */) ? 38 /* TryKeyword */ : 11 /* IdentifierName */; + case 118 /* v */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 114 /* r */) ? 40 /* VarKeyword */ : 11 /* IdentifierName */; + case 108 /* l */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 53 /* LetKeyword */ : 11 /* IdentifierName */; + case 97 /* a */: + return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 121 /* y */) ? 60 /* AnyKeyword */ : 11 /* IdentifierName */; + case 103 /* g */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 64 /* GetKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 68 /* SetKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 4: + switch (array[startIndex]) { + case 99 /* c */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 16 /* CaseKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + switch (array[startIndex + 1]) { + case 108 /* l */: + return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 23 /* ElseKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 109 /* m */) ? 46 /* EnumKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 110 /* n */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 108 /* l */) ? 32 /* NullKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + switch (array[startIndex + 1]) { + case 104 /* h */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 115 /* s */) ? 35 /* ThisKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 101 /* e */) ? 37 /* TrueKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 118 /* v */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 100 /* d */) ? 41 /* VoidKeyword */ : 11 /* IdentifierName */; + case 119 /* w */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 104 /* h */) ? 43 /* WithKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 5: + switch (array[startIndex]) { + case 98 /* b */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 107 /* k */) ? 15 /* BreakKeyword */ : 11 /* IdentifierName */; + case 99 /* c */: + switch (array[startIndex + 1]) { + case 97 /* a */: + return (array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 104 /* h */) ? 17 /* CatchKeyword */ : 11 /* IdentifierName */; + case 108 /* l */: + return (array[startIndex + 2] === 97 /* a */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 115 /* s */) ? 44 /* ClassKeyword */ : 11 /* IdentifierName */; + case 111 /* o */: + return (array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */) ? 45 /* ConstKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 102 /* f */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 101 /* e */) ? 24 /* FalseKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 114 /* r */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 119 /* w */) ? 36 /* ThrowKeyword */ : 11 /* IdentifierName */; + case 119 /* w */: + return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */) ? 42 /* WhileKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */) ? 50 /* SuperKeyword */ : 11 /* IdentifierName */; + case 121 /* y */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 100 /* d */) ? 59 /* YieldKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 6: + switch (array[startIndex]) { + case 100 /* d */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 101 /* e */) ? 21 /* DeleteKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 110 /* n */) ? 33 /* ReturnKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + switch (array[startIndex + 1]) { + case 119 /* w */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 99 /* c */ && array[startIndex + 5] === 104 /* h */) ? 34 /* SwitchKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + switch (array[startIndex + 2]) { + case 97 /* a */: + return (array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 58 /* StaticKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 3] === 105 /* i */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 103 /* g */) ? 69 /* StringKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 116 /* t */: + return (array[startIndex + 1] === 121 /* y */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 111 /* o */ && array[startIndex + 5] === 102 /* f */) ? 39 /* TypeOfKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 47 /* ExportKeyword */ : 11 /* IdentifierName */; + case 105 /* i */: + return (array[startIndex + 1] === 109 /* m */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 49 /* ImportKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 57 /* PublicKeyword */ : 11 /* IdentifierName */; + case 109 /* m */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 100 /* d */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 101 /* e */) ? 65 /* ModuleKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 109 /* m */ && array[startIndex + 3] === 98 /* b */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 114 /* r */) ? 67 /* NumberKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 7: + switch (array[startIndex]) { + case 100 /* d */: + switch (array[startIndex + 1]) { + case 101 /* e */: + switch (array[startIndex + 2]) { + case 102 /* f */: + return (array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 117 /* u */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 116 /* t */) ? 20 /* DefaultKeyword */ : 11 /* IdentifierName */; + case 99 /* c */: + return (array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 63 /* DeclareKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 102 /* f */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 121 /* y */) ? 25 /* FinallyKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 100 /* d */ && array[startIndex + 6] === 115 /* s */) ? 48 /* ExtendsKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + switch (array[startIndex + 1]) { + case 97 /* a */: + return (array[startIndex + 2] === 99 /* c */ && array[startIndex + 3] === 107 /* k */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */) ? 54 /* PackageKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 118 /* v */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 116 /* t */ && array[startIndex + 6] === 101 /* e */) ? 55 /* PrivateKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 98 /* b */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 97 /* a */ && array[startIndex + 6] === 110 /* n */) ? 61 /* BooleanKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 113 /* q */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 66 /* RequireKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 8: + switch (array[startIndex]) { + case 99 /* c */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 101 /* e */) ? 18 /* ContinueKeyword */ : 11 /* IdentifierName */; + case 100 /* d */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 103 /* g */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 114 /* r */) ? 19 /* DebuggerKeyword */ : 11 /* IdentifierName */; + case 102 /* f */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 105 /* i */ && array[startIndex + 6] === 111 /* o */ && array[startIndex + 7] === 110 /* n */) ? 27 /* FunctionKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 9: + switch (array[startIndex]) { + case 105 /* i */: + return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 102 /* f */ && array[startIndex + 6] === 97 /* a */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 101 /* e */) ? 52 /* InterfaceKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 99 /* c */ && array[startIndex + 6] === 116 /* t */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 100 /* d */) ? 56 /* ProtectedKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 10: + switch (array[startIndex]) { + case 105 /* i */: + switch (array[startIndex + 1]) { + case 110 /* n */: + return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 99 /* c */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 111 /* o */ && array[startIndex + 9] === 102 /* f */) ? 30 /* InstanceOfKeyword */ : 11 /* IdentifierName */; + case 109 /* m */: + return (array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 109 /* m */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 110 /* n */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 115 /* s */) ? 51 /* ImplementsKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 11: + return (array[startIndex] === 99 /* c */ && array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 111 /* o */ && array[startIndex + 10] === 114 /* r */) ? 62 /* ConstructorKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + }; + return ScannerUtilities; + })(); + TypeScript.ScannerUtilities = ScannerUtilities; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var EmptySeparatedSyntaxList = (function () { + function EmptySeparatedSyntaxList() { + } + EmptySeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + EmptySeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isList = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + + EmptySeparatedSyntaxList.prototype.toJSON = function (key) { + return []; + }; + + EmptySeparatedSyntaxList.prototype.childCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.separatorCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.toArray = function () { + return []; + }; + + EmptySeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + return []; + }; + + EmptySeparatedSyntaxList.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.separatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.collectTextElements = function (elements) { + }; + + EmptySeparatedSyntaxList.prototype.firstToken = function () { + return null; + }; + + EmptySeparatedSyntaxList.prototype.lastToken = function () { + return null; + }; + + EmptySeparatedSyntaxList.prototype.fullWidth = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.fullText = function () { + return ""; + }; + + EmptySeparatedSyntaxList.prototype.width = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + throw TypeScript.Errors.invalidOperation(); + }; + + EmptySeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + }; + + EmptySeparatedSyntaxList.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySeparatedSyntaxList.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return 0; + }; + return EmptySeparatedSyntaxList; + })(); + + Syntax.emptySeparatedList = new EmptySeparatedSyntaxList(); + + var SingletonSeparatedSyntaxList = (function () { + function SingletonSeparatedSyntaxList(item) { + this.item = item; + } + SingletonSeparatedSyntaxList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + SingletonSeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isList = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + + SingletonSeparatedSyntaxList.prototype.childCount = function () { + return 1; + }; + SingletonSeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return 1; + }; + SingletonSeparatedSyntaxList.prototype.separatorCount = function () { + return 0; + }; + + SingletonSeparatedSyntaxList.prototype.toArray = function () { + return [this.item]; + }; + SingletonSeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + return [this.item]; + }; + + SingletonSeparatedSyntaxList.prototype.childAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSeparatedSyntaxList.prototype.separatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + SingletonSeparatedSyntaxList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSeparatedSyntaxList.prototype.firstToken = function () { + return this.item.firstToken(); + }; + + SingletonSeparatedSyntaxList.prototype.lastToken = function () { + return this.item.lastToken(); + }; + + SingletonSeparatedSyntaxList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.width = function () { + return this.item.width(); + }; + + SingletonSeparatedSyntaxList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSeparatedSyntaxList.prototype.leadingTrivia = function () { + return this.item.leadingTrivia(); + }; + + SingletonSeparatedSyntaxList.prototype.trailingTrivia = function () { + return this.item.trailingTrivia(); + }; + + SingletonSeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return this.item.leadingTriviaWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return this.item.trailingTriviaWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + return this.item.isTypeScriptSpecific(); + }; + + SingletonSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return this.item.isIncrementallyUnusable(); + }; + + SingletonSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + return this.item.findTokenInternal(new TypeScript.PositionedSeparatedList(parent, this, fullStart), position, fullStart); + }; + + SingletonSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + array.splice(index, 0, this.item); + }; + return SingletonSeparatedSyntaxList; + })(); + + var NormalSeparatedSyntaxList = (function () { + function NormalSeparatedSyntaxList(elements) { + this._data = 0; + this.elements = elements; + } + NormalSeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + NormalSeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isList = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + NormalSeparatedSyntaxList.prototype.toJSON = function (key) { + return this.elements; + }; + + NormalSeparatedSyntaxList.prototype.childCount = function () { + return this.elements.length; + }; + NormalSeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return TypeScript.IntegerUtilities.integerDivide(this.elements.length + 1, 2); + }; + NormalSeparatedSyntaxList.prototype.separatorCount = function () { + return TypeScript.IntegerUtilities.integerDivide(this.elements.length, 2); + }; + + NormalSeparatedSyntaxList.prototype.toArray = function () { + return this.elements.slice(0); + }; + + NormalSeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + var result = []; + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + result.push(this.nonSeparatorAt(i)); + } + + return result; + }; + + NormalSeparatedSyntaxList.prototype.childAt = function (index) { + if (index < 0 || index >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[index]; + }; + + NormalSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + var value = index * 2; + if (value < 0 || value >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[value]; + }; + + NormalSeparatedSyntaxList.prototype.separatorAt = function (index) { + var value = index * 2 + 1; + if (value < 0 || value >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[value]; + }; + + NormalSeparatedSyntaxList.prototype.firstToken = function () { + var token; + for (var i = 0, n = this.elements.length; i < n; i++) { + if (i % 2 === 0) { + var nodeOrToken = this.elements[i]; + token = nodeOrToken.firstToken(); + if (token !== null) { + return token; + } + } else { + token = this.elements[i]; + if (token.width() > 0) { + return token; + } + } + } + + return null; + }; + + NormalSeparatedSyntaxList.prototype.lastToken = function () { + var token; + for (var i = this.elements.length - 1; i >= 0; i--) { + if (i % 2 === 0) { + var nodeOrToken = this.elements[i]; + token = nodeOrToken.lastToken(); + if (token !== null) { + return token; + } + } else { + token = this.elements[i]; + if (token.width() > 0) { + return token; + } + } + } + + return null; + }; + + NormalSeparatedSyntaxList.prototype.fullText = function () { + var elements = []; + this.collectTextElements(elements); + return elements.join(""); + }; + + NormalSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + if (this.nonSeparatorAt(i).isTypeScriptSpecific()) { + return true; + } + } + + return false; + }; + + NormalSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + NormalSeparatedSyntaxList.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + NormalSeparatedSyntaxList.prototype.width = function () { + var fullWidth = this.fullWidth(); + return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.leadingTrivia = function () { + return this.firstToken().leadingTrivia(); + }; + + NormalSeparatedSyntaxList.prototype.trailingTrivia = function () { + return this.lastToken().trailingTrivia(); + }; + + NormalSeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return this.firstToken().leadingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return this.lastToken().trailingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.computeData = function () { + var fullWidth = 0; + var isIncrementallyUnusable = false; + + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + + var childWidth = element.fullWidth(); + fullWidth += childWidth; + + isIncrementallyUnusable = isIncrementallyUnusable || element.isIncrementallyUnusable(); + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + NormalSeparatedSyntaxList.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data = this.computeData(); + } + + return this._data; + }; + + NormalSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedSeparatedList(parent, this, fullStart); + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + + var childWidth = element.fullWidth(); + if (position < childWidth) { + return element.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + NormalSeparatedSyntaxList.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + element.collectTextElements(elements); + } + }; + + NormalSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + if (index === 0) { + array.unshift.apply(array, this.elements); + } else { + array.splice.apply(array, [index, 0].concat(this.elements)); + } + }; + return NormalSeparatedSyntaxList; + })(); + + function separatedList(nodes) { + return separatedListAndValidate(nodes, false); + } + Syntax.separatedList = separatedList; + + function separatedListAndValidate(nodes, validate) { + if (nodes === undefined || nodes === null || nodes.length === 0) { + return Syntax.emptySeparatedList; + } + + if (validate) { + for (var i = 0; i < nodes.length; i++) { + var item = nodes[i]; + + if (i % 2 === 1) { + } + } + } + + if (nodes.length === 1) { + return new SingletonSeparatedSyntaxList(nodes[0]); + } + + return new NormalSeparatedSyntaxList(nodes); + } + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SlidingWindow = (function () { + function SlidingWindow(source, window, defaultValue, sourceLength) { + if (typeof sourceLength === "undefined") { sourceLength = -1; } + this.source = source; + this.window = window; + this.defaultValue = defaultValue; + this.sourceLength = sourceLength; + this.windowCount = 0; + this.windowAbsoluteStartIndex = 0; + this.currentRelativeItemIndex = 0; + this._pinCount = 0; + this.firstPinnedAbsoluteIndex = -1; + } + SlidingWindow.prototype.windowAbsoluteEndIndex = function () { + return this.windowAbsoluteStartIndex + this.windowCount; + }; + + SlidingWindow.prototype.addMoreItemsToWindow = function (argument) { + if (this.sourceLength >= 0 && this.absoluteIndex() >= this.sourceLength) { + return false; + } + + if (this.windowCount >= this.window.length) { + this.tryShiftOrGrowWindow(); + } + + var spaceAvailable = this.window.length - this.windowCount; + var amountFetched = this.source.fetchMoreItems(argument, this.windowAbsoluteEndIndex(), this.window, this.windowCount, spaceAvailable); + + this.windowCount += amountFetched; + return amountFetched > 0; + }; + + SlidingWindow.prototype.tryShiftOrGrowWindow = function () { + var currentIndexIsPastWindowHalfwayPoint = this.currentRelativeItemIndex > (this.window.length >>> 1); + + var isAllowedToShift = this.firstPinnedAbsoluteIndex === -1 || this.firstPinnedAbsoluteIndex > this.windowAbsoluteStartIndex; + + if (currentIndexIsPastWindowHalfwayPoint && isAllowedToShift) { + var shiftStartIndex = this.firstPinnedAbsoluteIndex === -1 ? this.currentRelativeItemIndex : this.firstPinnedAbsoluteIndex - this.windowAbsoluteStartIndex; + + var shiftCount = this.windowCount - shiftStartIndex; + + if (shiftCount > 0) { + TypeScript.ArrayUtilities.copy(this.window, shiftStartIndex, this.window, 0, shiftCount); + } + + this.windowAbsoluteStartIndex += shiftStartIndex; + + this.windowCount -= shiftStartIndex; + + this.currentRelativeItemIndex -= shiftStartIndex; + } else { + TypeScript.ArrayUtilities.grow(this.window, this.window.length * 2, this.defaultValue); + } + }; + + SlidingWindow.prototype.absoluteIndex = function () { + return this.windowAbsoluteStartIndex + this.currentRelativeItemIndex; + }; + + SlidingWindow.prototype.isAtEndOfSource = function () { + return this.absoluteIndex() >= this.sourceLength; + }; + + SlidingWindow.prototype.getAndPinAbsoluteIndex = function () { + var absoluteIndex = this.absoluteIndex(); + var pinCount = this._pinCount++; + if (pinCount === 0) { + this.firstPinnedAbsoluteIndex = absoluteIndex; + } + + return absoluteIndex; + }; + + SlidingWindow.prototype.releaseAndUnpinAbsoluteIndex = function (absoluteIndex) { + this._pinCount--; + if (this._pinCount === 0) { + this.firstPinnedAbsoluteIndex = -1; + } + }; + + SlidingWindow.prototype.rewindToPinnedIndex = function (absoluteIndex) { + var relativeIndex = absoluteIndex - this.windowAbsoluteStartIndex; + + this.currentRelativeItemIndex = relativeIndex; + }; + + SlidingWindow.prototype.currentItem = function (argument) { + if (this.currentRelativeItemIndex >= this.windowCount) { + if (!this.addMoreItemsToWindow(argument)) { + return this.defaultValue; + } + } + + return this.window[this.currentRelativeItemIndex]; + }; + + SlidingWindow.prototype.peekItemN = function (n) { + while (this.currentRelativeItemIndex + n >= this.windowCount) { + if (!this.addMoreItemsToWindow(null)) { + return this.defaultValue; + } + } + + return this.window[this.currentRelativeItemIndex + n]; + }; + + SlidingWindow.prototype.moveToNextItem = function () { + this.currentRelativeItemIndex++; + }; + + SlidingWindow.prototype.disgardAllItemsFromCurrentIndexOnwards = function () { + this.windowCount = this.currentRelativeItemIndex; + }; + + SlidingWindow.prototype.setAbsoluteIndex = function (absoluteIndex) { + if (this.absoluteIndex() === absoluteIndex) { + return; + } + + if (this._pinCount > 0) { + } + + if (absoluteIndex >= this.windowAbsoluteStartIndex && absoluteIndex < this.windowAbsoluteEndIndex()) { + this.currentRelativeItemIndex = (absoluteIndex - this.windowAbsoluteStartIndex); + } else { + this.windowAbsoluteStartIndex = absoluteIndex; + + this.windowCount = 0; + + this.currentRelativeItemIndex = 0; + } + }; + + SlidingWindow.prototype.pinCount = function () { + return this._pinCount; + }; + return SlidingWindow; + })(); + TypeScript.SlidingWindow = SlidingWindow; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + function emptySourceUnit() { + return TypeScript.Syntax.normalModeFactory.sourceUnit(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(10 /* EndOfFileToken */, { text: "" })); + } + Syntax.emptySourceUnit = emptySourceUnit; + + function getStandaloneExpression(positionedToken) { + var token = positionedToken.token(); + if (positionedToken !== null && positionedToken.kind() === 11 /* IdentifierName */) { + var parentPositionedNode = positionedToken.containingNode(); + var parentNode = parentPositionedNode.node(); + + if (parentNode.kind() === 121 /* QualifiedName */ && parentNode.right === token) { + return parentPositionedNode; + } else if (parentNode.kind() === 212 /* MemberAccessExpression */ && parentNode.name === token) { + return parentPositionedNode; + } + } + + return positionedToken; + } + Syntax.getStandaloneExpression = getStandaloneExpression; + + function isInModuleOrTypeContext(positionedToken) { + if (positionedToken !== null) { + var positionedNodeOrToken = TypeScript.Syntax.getStandaloneExpression(positionedToken); + var parent = positionedNodeOrToken.containingNode(); + + if (parent !== null) { + switch (parent.kind()) { + case 246 /* ModuleNameModuleReference */: + return true; + case 121 /* QualifiedName */: + return true; + default: + return isInTypeOnlyContext(positionedToken); + } + } + } + + return false; + } + Syntax.isInModuleOrTypeContext = isInModuleOrTypeContext; + + function isInTypeOnlyContext(positionedToken) { + var positionedNodeOrToken = TypeScript.Syntax.getStandaloneExpression(positionedToken); + var positionedParent = positionedNodeOrToken.containingNode(); + + var parent = positionedParent.node(); + var nodeOrToken = positionedNodeOrToken.nodeOrToken(); + + if (parent !== null) { + switch (parent.kind()) { + case 124 /* ArrayType */: + return parent.type === nodeOrToken; + case 220 /* CastExpression */: + return parent.type === nodeOrToken; + case 244 /* TypeAnnotation */: + case 230 /* ExtendsHeritageClause */: + case 231 /* ImplementsHeritageClause */: + case 228 /* TypeArgumentList */: + return true; + } + } + + return false; + } + Syntax.isInTypeOnlyContext = isInTypeOnlyContext; + + function childOffset(parent, child) { + var offset = 0; + for (var i = 0, n = parent.childCount(); i < n; i++) { + var current = parent.childAt(i); + if (current === child) { + return offset; + } + + if (current !== null) { + offset += current.fullWidth(); + } + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.childOffset = childOffset; + + function childOffsetAt(parent, index) { + var offset = 0; + for (var i = 0; i < index; i++) { + var current = parent.childAt(i); + if (current !== null) { + offset += current.fullWidth(); + } + } + + return offset; + } + Syntax.childOffsetAt = childOffsetAt; + + function childIndex(parent, child) { + for (var i = 0, n = parent.childCount(); i < n; i++) { + var current = parent.childAt(i); + if (current === child) { + return i; + } + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.childIndex = childIndex; + + function nodeStructuralEquals(node1, node2) { + if (node1 === null) { + return node2 === null; + } + + return node1.structuralEquals(node2); + } + Syntax.nodeStructuralEquals = nodeStructuralEquals; + + function nodeOrTokenStructuralEquals(node1, node2) { + if (node1 === node2) { + return true; + } + + if (node1 === null || node2 === null) { + return false; + } + + if (node1.isToken()) { + return node2.isToken() ? tokenStructuralEquals(node1, node2) : false; + } + + return node2.isNode() ? nodeStructuralEquals(node1, node2) : false; + } + Syntax.nodeOrTokenStructuralEquals = nodeOrTokenStructuralEquals; + + function tokenStructuralEquals(token1, token2) { + if (token1 === token2) { + return true; + } + + if (token1 === null || token2 === null) { + return false; + } + + return token1.kind() === token2.kind() && token1.width() === token2.width() && token1.fullWidth() === token2.fullWidth() && token1.text() === token2.text() && TypeScript.Syntax.triviaListStructuralEquals(token1.leadingTrivia(), token2.leadingTrivia()) && TypeScript.Syntax.triviaListStructuralEquals(token1.trailingTrivia(), token2.trailingTrivia()); + } + Syntax.tokenStructuralEquals = tokenStructuralEquals; + + function triviaListStructuralEquals(triviaList1, triviaList2) { + if (triviaList1.count() !== triviaList2.count()) { + return false; + } + + for (var i = 0, n = triviaList1.count(); i < n; i++) { + if (!TypeScript.Syntax.triviaStructuralEquals(triviaList1.syntaxTriviaAt(i), triviaList2.syntaxTriviaAt(i))) { + return false; + } + } + + return true; + } + Syntax.triviaListStructuralEquals = triviaListStructuralEquals; + + function triviaStructuralEquals(trivia1, trivia2) { + return trivia1.kind() === trivia2.kind() && trivia1.fullWidth() === trivia2.fullWidth() && trivia1.fullText() === trivia2.fullText(); + } + Syntax.triviaStructuralEquals = triviaStructuralEquals; + + function listStructuralEquals(list1, list2) { + if (list1.childCount() !== list2.childCount()) { + return false; + } + + for (var i = 0, n = list1.childCount(); i < n; i++) { + var child1 = list1.childAt(i); + var child2 = list2.childAt(i); + + if (!TypeScript.Syntax.nodeOrTokenStructuralEquals(child1, child2)) { + return false; + } + } + + return true; + } + Syntax.listStructuralEquals = listStructuralEquals; + + function separatedListStructuralEquals(list1, list2) { + if (list1.childCount() !== list2.childCount()) { + return false; + } + + for (var i = 0, n = list1.childCount(); i < n; i++) { + var element1 = list1.childAt(i); + var element2 = list2.childAt(i); + if (!TypeScript.Syntax.nodeOrTokenStructuralEquals(element1, element2)) { + return false; + } + } + + return true; + } + Syntax.separatedListStructuralEquals = separatedListStructuralEquals; + + function elementStructuralEquals(element1, element2) { + if (element1 === element2) { + return true; + } + + if (element1 === null || element2 === null) { + return false; + } + + if (element2.kind() !== element2.kind()) { + return false; + } + + if (element1.isToken()) { + return tokenStructuralEquals(element1, element2); + } else if (element1.isNode()) { + return nodeStructuralEquals(element1, element2); + } else if (element1.isList()) { + return listStructuralEquals(element1, element2); + } else if (element1.isSeparatedList()) { + return separatedListStructuralEquals(element1, element2); + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.elementStructuralEquals = elementStructuralEquals; + + function identifierName(text, info) { + if (typeof info === "undefined") { info = null; } + return TypeScript.Syntax.identifier(text); + } + Syntax.identifierName = identifierName; + + function trueExpression() { + return TypeScript.Syntax.token(37 /* TrueKeyword */); + } + Syntax.trueExpression = trueExpression; + + function falseExpression() { + return TypeScript.Syntax.token(24 /* FalseKeyword */); + } + Syntax.falseExpression = falseExpression; + + function numericLiteralExpression(text) { + return TypeScript.Syntax.token(13 /* NumericLiteral */, { text: text }); + } + Syntax.numericLiteralExpression = numericLiteralExpression; + + function stringLiteralExpression(text) { + return TypeScript.Syntax.token(14 /* StringLiteral */, { text: text }); + } + Syntax.stringLiteralExpression = stringLiteralExpression; + + function isSuperInvocationExpression(node) { + return node.kind() === 213 /* InvocationExpression */ && node.expression.kind() === 50 /* SuperKeyword */; + } + Syntax.isSuperInvocationExpression = isSuperInvocationExpression; + + function isSuperInvocationExpressionStatement(node) { + return node.kind() === 149 /* ExpressionStatement */ && isSuperInvocationExpression(node.expression); + } + Syntax.isSuperInvocationExpressionStatement = isSuperInvocationExpressionStatement; + + function isSuperMemberAccessExpression(node) { + return node.kind() === 212 /* MemberAccessExpression */ && node.expression.kind() === 50 /* SuperKeyword */; + } + Syntax.isSuperMemberAccessExpression = isSuperMemberAccessExpression; + + function isSuperMemberAccessInvocationExpression(node) { + return node.kind() === 213 /* InvocationExpression */ && isSuperMemberAccessExpression(node.expression); + } + Syntax.isSuperMemberAccessInvocationExpression = isSuperMemberAccessInvocationExpression; + + function assignmentExpression(left, token, right) { + return TypeScript.Syntax.normalModeFactory.binaryExpression(174 /* AssignmentExpression */, left, token, right); + } + Syntax.assignmentExpression = assignmentExpression; + + function nodeHasSkippedOrMissingTokens(node) { + for (var i = 0; i < node.childCount(); i++) { + var child = node.childAt(i); + if (child !== null && child.isToken()) { + var token = child; + + if (token.hasSkippedToken() || (token.width() === 0 && token.kind() !== 10 /* EndOfFileToken */)) { + return true; + } + } + } + return false; + } + Syntax.nodeHasSkippedOrMissingTokens = nodeHasSkippedOrMissingTokens; + + function isUnterminatedStringLiteral(token) { + if (token && token.kind() === 14 /* StringLiteral */) { + var text = token.text(); + return text.length < 2 || text.charCodeAt(text.length - 1) !== text.charCodeAt(0); + } + + return false; + } + Syntax.isUnterminatedStringLiteral = isUnterminatedStringLiteral; + + function isUnterminatedMultilineCommentTrivia(trivia) { + if (trivia && trivia.kind() === 6 /* MultiLineCommentTrivia */) { + var text = trivia.fullText(); + return text.length < 4 || text.substring(text.length - 2) !== "*/"; + } + return false; + } + Syntax.isUnterminatedMultilineCommentTrivia = isUnterminatedMultilineCommentTrivia; + + function isEntirelyInsideCommentTrivia(trivia, fullStart, position) { + if (trivia && trivia.isComment() && position > fullStart) { + var end = fullStart + trivia.fullWidth(); + if (position < end) { + return true; + } else if (position === end) { + return trivia.kind() === 7 /* SingleLineCommentTrivia */ || isUnterminatedMultilineCommentTrivia(trivia); + } + } + + return false; + } + Syntax.isEntirelyInsideCommentTrivia = isEntirelyInsideCommentTrivia; + + function isEntirelyInsideComment(sourceUnit, position) { + var positionedToken = sourceUnit.findToken(position); + var fullStart = positionedToken.fullStart(); + var triviaList = null; + var lastTriviaBeforeToken = null; + + if (positionedToken.kind() === 10 /* EndOfFileToken */) { + if (positionedToken.token().hasLeadingTrivia()) { + triviaList = positionedToken.token().leadingTrivia(); + } else { + positionedToken = positionedToken.previousToken(); + if (positionedToken) { + if (positionedToken && positionedToken.token().hasTrailingTrivia()) { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + } + } + } else { + if (position <= (fullStart + positionedToken.token().leadingTriviaWidth())) { + triviaList = positionedToken.token().leadingTrivia(); + } else if (position >= (fullStart + positionedToken.token().width())) { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + } + + if (triviaList) { + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + if (position <= fullStart) { + break; + } else if (position <= fullStart + trivia.fullWidth() && trivia.isComment()) { + lastTriviaBeforeToken = trivia; + break; + } + + fullStart += trivia.fullWidth(); + } + } + + return lastTriviaBeforeToken && isEntirelyInsideCommentTrivia(lastTriviaBeforeToken, fullStart, position); + } + Syntax.isEntirelyInsideComment = isEntirelyInsideComment; + + function isEntirelyInStringOrRegularExpressionLiteral(sourceUnit, position) { + var positionedToken = sourceUnit.findToken(position); + + if (positionedToken) { + if (positionedToken.kind() === 10 /* EndOfFileToken */) { + positionedToken = positionedToken.previousToken(); + return positionedToken && positionedToken.token().trailingTriviaWidth() === 0 && isUnterminatedStringLiteral(positionedToken.token()); + } else if (position > positionedToken.start()) { + return (position < positionedToken.end() && (positionedToken.kind() === 14 /* StringLiteral */ || positionedToken.kind() === 12 /* RegularExpressionLiteral */)) || (position <= positionedToken.end() && isUnterminatedStringLiteral(positionedToken.token())); + } + } + + return false; + } + Syntax.isEntirelyInStringOrRegularExpressionLiteral = isEntirelyInStringOrRegularExpressionLiteral; + + function findSkippedTokenInTriviaList(positionedToken, position, lookInLeadingTriviaList) { + var triviaList = null; + var fullStart; + + if (lookInLeadingTriviaList) { + triviaList = positionedToken.token().leadingTrivia(); + fullStart = positionedToken.fullStart(); + } else { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + + if (triviaList && triviaList.hasSkippedToken()) { + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + var triviaWidth = trivia.fullWidth(); + + if (trivia.isSkippedToken() && position >= fullStart && position <= fullStart + triviaWidth) { + return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullStart); + } + + fullStart += triviaWidth; + } + } + + return null; + } + + function findSkippedTokenOnLeftInTriviaList(positionedToken, position, lookInLeadingTriviaList) { + var triviaList = null; + var fullEnd; + + if (lookInLeadingTriviaList) { + triviaList = positionedToken.token().leadingTrivia(); + fullEnd = positionedToken.fullStart() + triviaList.fullWidth(); + } else { + triviaList = positionedToken.token().trailingTrivia(); + fullEnd = positionedToken.fullEnd(); + } + + if (triviaList && triviaList.hasSkippedToken()) { + for (var i = triviaList.count() - 1; i >= 0; i--) { + var trivia = triviaList.syntaxTriviaAt(i); + var triviaWidth = trivia.fullWidth(); + + if (trivia.isSkippedToken() && position >= fullEnd) { + return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullEnd - triviaWidth); + } + + fullEnd -= triviaWidth; + } + } + + return null; + } + + function findSkippedTokenInLeadingTriviaList(positionedToken, position) { + return findSkippedTokenInTriviaList(positionedToken, position, true); + } + Syntax.findSkippedTokenInLeadingTriviaList = findSkippedTokenInLeadingTriviaList; + + function findSkippedTokenInTrailingTriviaList(positionedToken, position) { + return findSkippedTokenInTriviaList(positionedToken, position, false); + } + Syntax.findSkippedTokenInTrailingTriviaList = findSkippedTokenInTrailingTriviaList; + + function findSkippedTokenInPositionedToken(positionedToken, position) { + var positionInLeadingTriviaList = (position < positionedToken.start()); + return findSkippedTokenInTriviaList(positionedToken, position, positionInLeadingTriviaList); + } + Syntax.findSkippedTokenInPositionedToken = findSkippedTokenInPositionedToken; + + function findSkippedTokenOnLeft(positionedToken, position) { + var positionInLeadingTriviaList = (position < positionedToken.start()); + return findSkippedTokenOnLeftInTriviaList(positionedToken, position, positionInLeadingTriviaList); + } + Syntax.findSkippedTokenOnLeft = findSkippedTokenOnLeft; + + function getAncestorOfKind(positionedToken, kind) { + while (positionedToken && positionedToken.parent()) { + if (positionedToken.parent().kind() === kind) { + return positionedToken.parent(); + } + + positionedToken = positionedToken.parent(); + } + + return null; + } + Syntax.getAncestorOfKind = getAncestorOfKind; + + function hasAncestorOfKind(positionedToken, kind) { + return TypeScript.Syntax.getAncestorOfKind(positionedToken, kind) !== null; + } + Syntax.hasAncestorOfKind = hasAncestorOfKind; + + function isIntegerLiteral(expression) { + if (expression) { + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + expression = expression.operand; + return expression.isToken() && TypeScript.IntegerUtilities.isInteger(expression.text()); + + case 13 /* NumericLiteral */: + var text = expression.text(); + return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text); + } + } + + return false; + } + Syntax.isIntegerLiteral = isIntegerLiteral; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var NormalModeFactory = (function () { + function NormalModeFactory() { + } + NormalModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) { + return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, false); + }; + NormalModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, false); + }; + NormalModeFactory.prototype.moduleNameModuleReference = function (moduleName) { + return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, false); + }; + NormalModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false); + }; + NormalModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) { + return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, false); + }; + NormalModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) { + return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, false); + }; + NormalModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, false); + }; + NormalModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) { + return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, false); + }; + NormalModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) { + return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, false); + }; + NormalModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) { + return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, false); + }; + NormalModeFactory.prototype.equalsValueClause = function (equalsToken, value) { + return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, false); + }; + NormalModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) { + return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, false); + }; + NormalModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) { + return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, false); + }; + NormalModeFactory.prototype.omittedExpression = function () { + return new TypeScript.OmittedExpressionSyntax(false); + }; + NormalModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) { + return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, false); + }; + NormalModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) { + return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, false); + }; + NormalModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) { + return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, false); + }; + NormalModeFactory.prototype.qualifiedName = function (left, dotToken, right) { + return new TypeScript.QualifiedNameSyntax(left, dotToken, right, false); + }; + NormalModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) { + return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, false); + }; + NormalModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, false); + }; + NormalModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, false); + }; + NormalModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) { + return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, false); + }; + NormalModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) { + return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, false); + }; + NormalModeFactory.prototype.genericType = function (name, typeArgumentList) { + return new TypeScript.GenericTypeSyntax(name, typeArgumentList, false); + }; + NormalModeFactory.prototype.typeQuery = function (typeOfKeyword, name) { + return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, false); + }; + NormalModeFactory.prototype.typeAnnotation = function (colonToken, type) { + return new TypeScript.TypeAnnotationSyntax(colonToken, type, false); + }; + NormalModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) { + return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, false); + }; + NormalModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, false); + }; + NormalModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) { + return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, false); + }; + NormalModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) { + return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, false); + }; + NormalModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, false); + }; + NormalModeFactory.prototype.invocationExpression = function (expression, argumentList) { + return new TypeScript.InvocationExpressionSyntax(expression, argumentList, false); + }; + NormalModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, false); + }; + NormalModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) { + return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, false); + }; + NormalModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, false); + }; + NormalModeFactory.prototype.constructSignature = function (newKeyword, callSignature) { + return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, false); + }; + NormalModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) { + return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, false); + }; + NormalModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, false); + }; + NormalModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) { + return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, false); + }; + NormalModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) { + return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, false); + }; + NormalModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) { + return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, false); + }; + NormalModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) { + return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, false); + }; + NormalModeFactory.prototype.typeParameter = function (identifier, constraint) { + return new TypeScript.TypeParameterSyntax(identifier, constraint, false); + }; + NormalModeFactory.prototype.constraint = function (extendsKeyword, type) { + return new TypeScript.ConstraintSyntax(extendsKeyword, type, false); + }; + NormalModeFactory.prototype.elseClause = function (elseKeyword, statement) { + return new TypeScript.ElseClauseSyntax(elseKeyword, statement, false); + }; + NormalModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, false); + }; + NormalModeFactory.prototype.expressionStatement = function (expression, semicolonToken) { + return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, false); + }; + NormalModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, false); + }; + NormalModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) { + return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, false); + }; + NormalModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, false); + }; + NormalModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) { + return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, false); + }; + NormalModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) { + return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, false); + }; + NormalModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) { + return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, false); + }; + NormalModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) { + return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, false); + }; + NormalModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) { + return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, false); + }; + NormalModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) { + return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, false); + }; + NormalModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, false); + }; + NormalModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) { + return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, false); + }; + NormalModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) { + return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, false); + }; + NormalModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) { + return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) { + return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) { + return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, false); + }; + NormalModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) { + return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, false); + }; + NormalModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) { + return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, false); + }; + NormalModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) { + return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, false); + }; + NormalModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) { + return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, false); + }; + NormalModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) { + return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, false); + }; + NormalModeFactory.prototype.emptyStatement = function (semicolonToken) { + return new TypeScript.EmptyStatementSyntax(semicolonToken, false); + }; + NormalModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) { + return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, false); + }; + NormalModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, false); + }; + NormalModeFactory.prototype.finallyClause = function (finallyKeyword, block) { + return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, false); + }; + NormalModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) { + return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, false); + }; + NormalModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, false); + }; + NormalModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) { + return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, false); + }; + NormalModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) { + return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, false); + }; + NormalModeFactory.prototype.voidExpression = function (voidKeyword, expression) { + return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, false); + }; + NormalModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) { + return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, false); + }; + return NormalModeFactory; + })(); + Syntax.NormalModeFactory = NormalModeFactory; + + var StrictModeFactory = (function () { + function StrictModeFactory() { + } + StrictModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) { + return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, true); + }; + StrictModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, true); + }; + StrictModeFactory.prototype.moduleNameModuleReference = function (moduleName) { + return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, true); + }; + StrictModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, true); + }; + StrictModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) { + return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, true); + }; + StrictModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) { + return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, true); + }; + StrictModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, true); + }; + StrictModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) { + return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, true); + }; + StrictModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) { + return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, true); + }; + StrictModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) { + return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, true); + }; + StrictModeFactory.prototype.equalsValueClause = function (equalsToken, value) { + return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, true); + }; + StrictModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) { + return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, true); + }; + StrictModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) { + return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, true); + }; + StrictModeFactory.prototype.omittedExpression = function () { + return new TypeScript.OmittedExpressionSyntax(true); + }; + StrictModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) { + return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, true); + }; + StrictModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) { + return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, true); + }; + StrictModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) { + return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, true); + }; + StrictModeFactory.prototype.qualifiedName = function (left, dotToken, right) { + return new TypeScript.QualifiedNameSyntax(left, dotToken, right, true); + }; + StrictModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) { + return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, true); + }; + StrictModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, true); + }; + StrictModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, true); + }; + StrictModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) { + return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, true); + }; + StrictModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) { + return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, true); + }; + StrictModeFactory.prototype.genericType = function (name, typeArgumentList) { + return new TypeScript.GenericTypeSyntax(name, typeArgumentList, true); + }; + StrictModeFactory.prototype.typeQuery = function (typeOfKeyword, name) { + return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, true); + }; + StrictModeFactory.prototype.typeAnnotation = function (colonToken, type) { + return new TypeScript.TypeAnnotationSyntax(colonToken, type, true); + }; + StrictModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) { + return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, true); + }; + StrictModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, true); + }; + StrictModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) { + return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, true); + }; + StrictModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) { + return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, true); + }; + StrictModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, true); + }; + StrictModeFactory.prototype.invocationExpression = function (expression, argumentList) { + return new TypeScript.InvocationExpressionSyntax(expression, argumentList, true); + }; + StrictModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, true); + }; + StrictModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) { + return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, true); + }; + StrictModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, true); + }; + StrictModeFactory.prototype.constructSignature = function (newKeyword, callSignature) { + return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, true); + }; + StrictModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) { + return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, true); + }; + StrictModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, true); + }; + StrictModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) { + return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, true); + }; + StrictModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) { + return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, true); + }; + StrictModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) { + return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, true); + }; + StrictModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) { + return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, true); + }; + StrictModeFactory.prototype.typeParameter = function (identifier, constraint) { + return new TypeScript.TypeParameterSyntax(identifier, constraint, true); + }; + StrictModeFactory.prototype.constraint = function (extendsKeyword, type) { + return new TypeScript.ConstraintSyntax(extendsKeyword, type, true); + }; + StrictModeFactory.prototype.elseClause = function (elseKeyword, statement) { + return new TypeScript.ElseClauseSyntax(elseKeyword, statement, true); + }; + StrictModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, true); + }; + StrictModeFactory.prototype.expressionStatement = function (expression, semicolonToken) { + return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, true); + }; + StrictModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, true); + }; + StrictModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) { + return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, true); + }; + StrictModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, true); + }; + StrictModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) { + return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, true); + }; + StrictModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) { + return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, true); + }; + StrictModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) { + return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, true); + }; + StrictModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) { + return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, true); + }; + StrictModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) { + return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, true); + }; + StrictModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) { + return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, true); + }; + StrictModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, true); + }; + StrictModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) { + return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, true); + }; + StrictModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) { + return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, true); + }; + StrictModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) { + return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) { + return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) { + return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, true); + }; + StrictModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) { + return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, true); + }; + StrictModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) { + return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, true); + }; + StrictModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) { + return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, true); + }; + StrictModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) { + return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, true); + }; + StrictModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) { + return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, true); + }; + StrictModeFactory.prototype.emptyStatement = function (semicolonToken) { + return new TypeScript.EmptyStatementSyntax(semicolonToken, true); + }; + StrictModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) { + return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, true); + }; + StrictModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, true); + }; + StrictModeFactory.prototype.finallyClause = function (finallyKeyword, block) { + return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, true); + }; + StrictModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) { + return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, true); + }; + StrictModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, true); + }; + StrictModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) { + return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, true); + }; + StrictModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) { + return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, true); + }; + StrictModeFactory.prototype.voidExpression = function (voidKeyword, expression) { + return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, true); + }; + StrictModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) { + return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, true); + }; + return StrictModeFactory; + })(); + Syntax.StrictModeFactory = StrictModeFactory; + + Syntax.normalModeFactory = new NormalModeFactory(); + Syntax.strictModeFactory = new StrictModeFactory(); + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxFacts) { + function isDirectivePrologueElement(node) { + if (node.kind() === 149 /* ExpressionStatement */) { + var expressionStatement = node; + var expression = expressionStatement.expression; + + if (expression.kind() === 14 /* StringLiteral */) { + return true; + } + } + + return false; + } + SyntaxFacts.isDirectivePrologueElement = isDirectivePrologueElement; + + function isUseStrictDirective(node) { + var expressionStatement = node; + var stringLiteral = expressionStatement.expression; + + var text = stringLiteral.text(); + return text === '"use strict"' || text === "'use strict'"; + } + SyntaxFacts.isUseStrictDirective = isUseStrictDirective; + + function isIdentifierNameOrAnyKeyword(token) { + var tokenKind = token.tokenKind; + return tokenKind === 11 /* IdentifierName */ || TypeScript.SyntaxFacts.isAnyKeyword(tokenKind); + } + SyntaxFacts.isIdentifierNameOrAnyKeyword = isIdentifierNameOrAnyKeyword; + })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {})); + var SyntaxFacts = TypeScript.SyntaxFacts; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var EmptySyntaxList = (function () { + function EmptySyntaxList() { + } + EmptySyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + EmptySyntaxList.prototype.isNode = function () { + return false; + }; + EmptySyntaxList.prototype.isToken = function () { + return false; + }; + EmptySyntaxList.prototype.isList = function () { + return true; + }; + EmptySyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + EmptySyntaxList.prototype.toJSON = function (key) { + return []; + }; + + EmptySyntaxList.prototype.childCount = function () { + return 0; + }; + + EmptySyntaxList.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySyntaxList.prototype.toArray = function () { + return []; + }; + + EmptySyntaxList.prototype.collectTextElements = function (elements) { + }; + + EmptySyntaxList.prototype.firstToken = function () { + return null; + }; + + EmptySyntaxList.prototype.lastToken = function () { + return null; + }; + + EmptySyntaxList.prototype.fullWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.width = function () { + return 0; + }; + + EmptySyntaxList.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySyntaxList.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySyntaxList.prototype.leadingTriviaWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.trailingTriviaWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.fullText = function () { + return ""; + }; + + EmptySyntaxList.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptySyntaxList.prototype.isIncrementallyUnusable = function () { + return false; + }; + + EmptySyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + throw TypeScript.Errors.invalidOperation(); + }; + + EmptySyntaxList.prototype.insertChildrenInto = function (array, index) { + }; + return EmptySyntaxList; + })(); + Syntax.EmptySyntaxList = EmptySyntaxList; + + Syntax.emptyList = new EmptySyntaxList(); + + var SingletonSyntaxList = (function () { + function SingletonSyntaxList(item) { + this.item = item; + } + SingletonSyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + SingletonSyntaxList.prototype.isToken = function () { + return false; + }; + SingletonSyntaxList.prototype.isNode = function () { + return false; + }; + SingletonSyntaxList.prototype.isList = function () { + return true; + }; + SingletonSyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + SingletonSyntaxList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSyntaxList.prototype.childCount = function () { + return 1; + }; + + SingletonSyntaxList.prototype.childAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSyntaxList.prototype.toArray = function () { + return [this.item]; + }; + + SingletonSyntaxList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSyntaxList.prototype.firstToken = function () { + return this.item.firstToken(); + }; + + SingletonSyntaxList.prototype.lastToken = function () { + return this.item.lastToken(); + }; + + SingletonSyntaxList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSyntaxList.prototype.width = function () { + return this.item.width(); + }; + + SingletonSyntaxList.prototype.leadingTrivia = function () { + return this.item.leadingTrivia(); + }; + + SingletonSyntaxList.prototype.trailingTrivia = function () { + return this.item.trailingTrivia(); + }; + + SingletonSyntaxList.prototype.leadingTriviaWidth = function () { + return this.item.leadingTriviaWidth(); + }; + + SingletonSyntaxList.prototype.trailingTriviaWidth = function () { + return this.item.trailingTriviaWidth(); + }; + + SingletonSyntaxList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSyntaxList.prototype.isTypeScriptSpecific = function () { + return this.item.isTypeScriptSpecific(); + }; + + SingletonSyntaxList.prototype.isIncrementallyUnusable = function () { + return this.item.isIncrementallyUnusable(); + }; + + SingletonSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + return this.item.findTokenInternal(new TypeScript.PositionedList(parent, this, fullStart), position, fullStart); + }; + + SingletonSyntaxList.prototype.insertChildrenInto = function (array, index) { + array.splice(index, 0, this.item); + }; + return SingletonSyntaxList; + })(); + + var NormalSyntaxList = (function () { + function NormalSyntaxList(nodeOrTokens) { + this._data = 0; + this.nodeOrTokens = nodeOrTokens; + } + NormalSyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + NormalSyntaxList.prototype.isNode = function () { + return false; + }; + NormalSyntaxList.prototype.isToken = function () { + return false; + }; + NormalSyntaxList.prototype.isList = function () { + return true; + }; + NormalSyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + NormalSyntaxList.prototype.toJSON = function (key) { + return this.nodeOrTokens; + }; + + NormalSyntaxList.prototype.childCount = function () { + return this.nodeOrTokens.length; + }; + + NormalSyntaxList.prototype.childAt = function (index) { + if (index < 0 || index >= this.nodeOrTokens.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.nodeOrTokens[index]; + }; + + NormalSyntaxList.prototype.toArray = function () { + return this.nodeOrTokens.slice(0); + }; + + NormalSyntaxList.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var element = this.nodeOrTokens[i]; + element.collectTextElements(elements); + } + }; + + NormalSyntaxList.prototype.firstToken = function () { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var token = this.nodeOrTokens[i].firstToken(); + if (token !== null) { + return token; + } + } + + return null; + }; + + NormalSyntaxList.prototype.lastToken = function () { + for (var i = this.nodeOrTokens.length - 1; i >= 0; i--) { + var token = this.nodeOrTokens[i].lastToken(); + if (token !== null) { + return token; + } + } + + return null; + }; + + NormalSyntaxList.prototype.fullText = function () { + var elements = new Array(); + this.collectTextElements(elements); + return elements.join(""); + }; + + NormalSyntaxList.prototype.isTypeScriptSpecific = function () { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + if (this.nodeOrTokens[i].isTypeScriptSpecific()) { + return true; + } + } + + return false; + }; + + NormalSyntaxList.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + NormalSyntaxList.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + NormalSyntaxList.prototype.width = function () { + var fullWidth = this.fullWidth(); + return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + NormalSyntaxList.prototype.leadingTrivia = function () { + return this.firstToken().leadingTrivia(); + }; + + NormalSyntaxList.prototype.trailingTrivia = function () { + return this.lastToken().trailingTrivia(); + }; + + NormalSyntaxList.prototype.leadingTriviaWidth = function () { + return this.firstToken().leadingTriviaWidth(); + }; + + NormalSyntaxList.prototype.trailingTriviaWidth = function () { + return this.lastToken().trailingTriviaWidth(); + }; + + NormalSyntaxList.prototype.computeData = function () { + var fullWidth = 0; + var isIncrementallyUnusable = false; + + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var node = this.nodeOrTokens[i]; + fullWidth += node.fullWidth(); + isIncrementallyUnusable = isIncrementallyUnusable || node.isIncrementallyUnusable(); + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + NormalSyntaxList.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data = this.computeData(); + } + + return this._data; + }; + + NormalSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedList(parent, this, fullStart); + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var nodeOrToken = this.nodeOrTokens[i]; + + var childWidth = nodeOrToken.fullWidth(); + if (position < childWidth) { + return nodeOrToken.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + NormalSyntaxList.prototype.insertChildrenInto = function (array, index) { + if (index === 0) { + array.unshift.apply(array, this.nodeOrTokens); + } else { + array.splice.apply(array, [index, 0].concat(this.nodeOrTokens)); + } + }; + return NormalSyntaxList; + })(); + + function list(nodes) { + if (nodes === undefined || nodes === null || nodes.length === 0) { + return Syntax.emptyList; + } + + if (nodes.length === 1) { + var item = nodes[0]; + return new SingletonSyntaxList(item); + } + + return new NormalSyntaxList(nodes); + } + Syntax.list = list; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxNode = (function () { + function SyntaxNode(parsedInStrictMode) { + this._data = parsedInStrictMode ? 4 /* NodeParsedInStrictModeMask */ : 0; + } + SyntaxNode.prototype.isNode = function () { + return true; + }; + SyntaxNode.prototype.isToken = function () { + return false; + }; + SyntaxNode.prototype.isList = function () { + return false; + }; + SyntaxNode.prototype.isSeparatedList = function () { + return false; + }; + + SyntaxNode.prototype.kind = function () { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.childCount = function () { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.childAt = function (slot) { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.firstToken = function () { + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) { + return element.firstToken(); + } + } + } + + return null; + }; + + SyntaxNode.prototype.lastToken = function () { + for (var i = this.childCount() - 1; i >= 0; i--) { + var element = this.childAt(i); + + if (element !== null) { + if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) { + return element.lastToken(); + } + } + } + + return null; + }; + + SyntaxNode.prototype.insertChildrenInto = function (array, index) { + for (var i = this.childCount() - 1; i >= 0; i--) { + var element = this.childAt(i); + + if (element !== null) { + if (element.isNode() || element.isToken()) { + array.splice(index, 0, element); + } else if (element.isList()) { + element.insertChildrenInto(array, index); + } else if (element.isSeparatedList()) { + element.insertChildrenInto(array, index); + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + } + }; + + SyntaxNode.prototype.leadingTrivia = function () { + var firstToken = this.firstToken(); + return firstToken ? firstToken.leadingTrivia() : TypeScript.Syntax.emptyTriviaList; + }; + + SyntaxNode.prototype.trailingTrivia = function () { + var lastToken = this.lastToken(); + return lastToken ? lastToken.trailingTrivia() : TypeScript.Syntax.emptyTriviaList; + }; + + SyntaxNode.prototype.toJSON = function (key) { + var result = { + kind: TypeScript.SyntaxKind[this.kind()], + fullWidth: this.fullWidth() + }; + + if (this.isIncrementallyUnusable()) { + result.isIncrementallyUnusable = true; + } + + if (this.parsedInStrictMode()) { + result.parsedInStrictMode = true; + } + + for (var i = 0, n = this.childCount(); i < n; i++) { + var value = this.childAt(i); + + if (value) { + for (var name in this) { + if (value === this[name]) { + result[name] = value; + break; + } + } + } + } + + return result; + }; + + SyntaxNode.prototype.accept = function (visitor) { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.fullText = function () { + var elements = []; + this.collectTextElements(elements); + return elements.join(""); + }; + + SyntaxNode.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + element.collectTextElements(elements); + } + } + }; + + SyntaxNode.prototype.replaceToken = function (token1, token2) { + if (token1 === token2) { + return this; + } + + return this.accept(new TypeScript.SyntaxTokenReplacer(token1, token2)); + }; + + SyntaxNode.prototype.withLeadingTrivia = function (trivia) { + return this.replaceToken(this.firstToken(), this.firstToken().withLeadingTrivia(trivia)); + }; + + SyntaxNode.prototype.withTrailingTrivia = function (trivia) { + return this.replaceToken(this.lastToken(), this.lastToken().withTrailingTrivia(trivia)); + }; + + SyntaxNode.prototype.hasLeadingTrivia = function () { + return this.lastToken().hasLeadingTrivia(); + }; + + SyntaxNode.prototype.hasTrailingTrivia = function () { + return this.lastToken().hasTrailingTrivia(); + }; + + SyntaxNode.prototype.isTypeScriptSpecific = function () { + return false; + }; + + SyntaxNode.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + SyntaxNode.prototype.parsedInStrictMode = function () { + return (this.data() & 4 /* NodeParsedInStrictModeMask */) !== 0; + }; + + SyntaxNode.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + SyntaxNode.prototype.computeData = function () { + var slotCount = this.childCount(); + + var fullWidth = 0; + var childWidth = 0; + + var isIncrementallyUnusable = ((this._data & 2 /* NodeIncrementallyUnusableMask */) !== 0) || slotCount === 0; + + for (var i = 0, n = slotCount; i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + childWidth = element.fullWidth(); + fullWidth += childWidth; + + if (!isIncrementallyUnusable) { + isIncrementallyUnusable = element.isIncrementallyUnusable(); + } + } + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + SyntaxNode.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data |= this.computeData(); + } + + return this._data; + }; + + SyntaxNode.prototype.findToken = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var endOfFileToken = this.tryGetEndOfFileAt(position); + if (endOfFileToken !== null) { + return endOfFileToken; + } + + if (position < 0 || position >= this.fullWidth()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var positionedToken = this.findTokenInternal(null, position, 0); + + if (includeSkippedTokens) { + return TypeScript.Syntax.findSkippedTokenInPositionedToken(positionedToken, position) || positionedToken; + } + + return positionedToken; + }; + + SyntaxNode.prototype.tryGetEndOfFileAt = function (position) { + if (this.kind() === 120 /* SourceUnit */ && position === this.fullWidth()) { + var sourceUnit = this; + return new TypeScript.PositionedToken(new TypeScript.PositionedNode(null, sourceUnit, 0), sourceUnit.endOfFileToken, sourceUnit.moduleElements.fullWidth()); + } + + return null; + }; + + SyntaxNode.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedNode(parent, this, fullStart); + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + var childWidth = element.fullWidth(); + + if (position < childWidth) { + return element.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + } + + throw TypeScript.Errors.invalidOperation(); + }; + + SyntaxNode.prototype.findTokenOnLeft = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var positionedToken = this.findToken(position, false); + var start = positionedToken.start(); + + if (includeSkippedTokens) { + positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken; + } + + if (position > start) { + return positionedToken; + } + + if (positionedToken.fullStart() === 0) { + return null; + } + + return positionedToken.previousToken(includeSkippedTokens); + }; + + SyntaxNode.prototype.findCompleteTokenOnLeft = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var positionedToken = this.findToken(position, false); + + if (includeSkippedTokens) { + positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken; + } + + if (positionedToken.token().width() > 0 && position >= positionedToken.end()) { + return positionedToken; + } + + return positionedToken.previousToken(includeSkippedTokens); + }; + + SyntaxNode.prototype.isModuleElement = function () { + return false; + }; + + SyntaxNode.prototype.isClassElement = function () { + return false; + }; + + SyntaxNode.prototype.isTypeMember = function () { + return false; + }; + + SyntaxNode.prototype.isStatement = function () { + return false; + }; + + SyntaxNode.prototype.isExpression = function () { + return false; + }; + + SyntaxNode.prototype.isSwitchClause = function () { + return false; + }; + + SyntaxNode.prototype.structuralEquals = function (node) { + if (this === node) { + return true; + } + if (node === null) { + return false; + } + if (this.kind() !== node.kind()) { + return false; + } + + for (var i = 0, n = this.childCount(); i < n; i++) { + var element1 = this.childAt(i); + var element2 = node.childAt(i); + + if (!TypeScript.Syntax.elementStructuralEquals(element1, element2)) { + return false; + } + } + + return true; + }; + + SyntaxNode.prototype.width = function () { + return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + SyntaxNode.prototype.leadingTriviaWidth = function () { + var firstToken = this.firstToken(); + return firstToken === null ? 0 : firstToken.leadingTriviaWidth(); + }; + + SyntaxNode.prototype.trailingTriviaWidth = function () { + var lastToken = this.lastToken(); + return lastToken === null ? 0 : lastToken.trailingTriviaWidth(); + }; + return SyntaxNode; + })(); + TypeScript.SyntaxNode = SyntaxNode; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SourceUnitSyntax = (function (_super) { + __extends(SourceUnitSyntax, _super); + function SourceUnitSyntax(moduleElements, endOfFileToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.moduleElements = moduleElements; + this.endOfFileToken = endOfFileToken; + } + SourceUnitSyntax.prototype.accept = function (visitor) { + return visitor.visitSourceUnit(this); + }; + + SourceUnitSyntax.prototype.kind = function () { + return 120 /* SourceUnit */; + }; + + SourceUnitSyntax.prototype.childCount = function () { + return 2; + }; + + SourceUnitSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.moduleElements; + case 1: + return this.endOfFileToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SourceUnitSyntax.prototype.update = function (moduleElements, endOfFileToken) { + if (this.moduleElements === moduleElements && this.endOfFileToken === endOfFileToken) { + return this; + } + + return new SourceUnitSyntax(moduleElements, endOfFileToken, this.parsedInStrictMode()); + }; + + SourceUnitSyntax.create = function (endOfFileToken) { + return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false); + }; + + SourceUnitSyntax.create1 = function (endOfFileToken) { + return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false); + }; + + SourceUnitSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SourceUnitSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SourceUnitSyntax.prototype.withModuleElements = function (moduleElements) { + return this.update(moduleElements, this.endOfFileToken); + }; + + SourceUnitSyntax.prototype.withModuleElement = function (moduleElement) { + return this.withModuleElements(TypeScript.Syntax.list([moduleElement])); + }; + + SourceUnitSyntax.prototype.withEndOfFileToken = function (endOfFileToken) { + return this.update(this.moduleElements, endOfFileToken); + }; + + SourceUnitSyntax.prototype.isTypeScriptSpecific = function () { + if (this.moduleElements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SourceUnitSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SourceUnitSyntax = SourceUnitSyntax; + + var ExternalModuleReferenceSyntax = (function (_super) { + __extends(ExternalModuleReferenceSyntax, _super); + function ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.requireKeyword = requireKeyword; + this.openParenToken = openParenToken; + this.stringLiteral = stringLiteral; + this.closeParenToken = closeParenToken; + } + ExternalModuleReferenceSyntax.prototype.accept = function (visitor) { + return visitor.visitExternalModuleReference(this); + }; + + ExternalModuleReferenceSyntax.prototype.kind = function () { + return 245 /* ExternalModuleReference */; + }; + + ExternalModuleReferenceSyntax.prototype.childCount = function () { + return 4; + }; + + ExternalModuleReferenceSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.requireKeyword; + case 1: + return this.openParenToken; + case 2: + return this.stringLiteral; + case 3: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExternalModuleReferenceSyntax.prototype.isModuleReference = function () { + return true; + }; + + ExternalModuleReferenceSyntax.prototype.update = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + if (this.requireKeyword === requireKeyword && this.openParenToken === openParenToken && this.stringLiteral === stringLiteral && this.closeParenToken === closeParenToken) { + return this; + } + + return new ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, this.parsedInStrictMode()); + }; + + ExternalModuleReferenceSyntax.create1 = function (stringLiteral) { + return new ExternalModuleReferenceSyntax(TypeScript.Syntax.token(66 /* RequireKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), stringLiteral, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ExternalModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExternalModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExternalModuleReferenceSyntax.prototype.withRequireKeyword = function (requireKeyword) { + return this.update(requireKeyword, this.openParenToken, this.stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.requireKeyword, openParenToken, this.stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withStringLiteral = function (stringLiteral) { + return this.update(this.requireKeyword, this.openParenToken, stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.requireKeyword, this.openParenToken, this.stringLiteral, closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ExternalModuleReferenceSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExternalModuleReferenceSyntax = ExternalModuleReferenceSyntax; + + var ModuleNameModuleReferenceSyntax = (function (_super) { + __extends(ModuleNameModuleReferenceSyntax, _super); + function ModuleNameModuleReferenceSyntax(moduleName, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.moduleName = moduleName; + } + ModuleNameModuleReferenceSyntax.prototype.accept = function (visitor) { + return visitor.visitModuleNameModuleReference(this); + }; + + ModuleNameModuleReferenceSyntax.prototype.kind = function () { + return 246 /* ModuleNameModuleReference */; + }; + + ModuleNameModuleReferenceSyntax.prototype.childCount = function () { + return 1; + }; + + ModuleNameModuleReferenceSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.moduleName; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ModuleNameModuleReferenceSyntax.prototype.isModuleReference = function () { + return true; + }; + + ModuleNameModuleReferenceSyntax.prototype.update = function (moduleName) { + if (this.moduleName === moduleName) { + return this; + } + + return new ModuleNameModuleReferenceSyntax(moduleName, this.parsedInStrictMode()); + }; + + ModuleNameModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ModuleNameModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ModuleNameModuleReferenceSyntax.prototype.withModuleName = function (moduleName) { + return this.update(moduleName); + }; + + ModuleNameModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ModuleNameModuleReferenceSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ModuleNameModuleReferenceSyntax = ModuleNameModuleReferenceSyntax; + + var ImportDeclarationSyntax = (function (_super) { + __extends(ImportDeclarationSyntax, _super); + function ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.importKeyword = importKeyword; + this.identifier = identifier; + this.equalsToken = equalsToken; + this.moduleReference = moduleReference; + this.semicolonToken = semicolonToken; + } + ImportDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitImportDeclaration(this); + }; + + ImportDeclarationSyntax.prototype.kind = function () { + return 133 /* ImportDeclaration */; + }; + + ImportDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + ImportDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.importKeyword; + case 2: + return this.identifier; + case 3: + return this.equalsToken; + case 4: + return this.moduleReference; + case 5: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ImportDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ImportDeclarationSyntax.prototype.update = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + if (this.modifiers === modifiers && this.importKeyword === importKeyword && this.identifier === identifier && this.equalsToken === equalsToken && this.moduleReference === moduleReference && this.semicolonToken === semicolonToken) { + return this; + } + + return new ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, this.parsedInStrictMode()); + }; + + ImportDeclarationSyntax.create = function (importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false); + }; + + ImportDeclarationSyntax.create1 = function (identifier, moduleReference) { + return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(49 /* ImportKeyword */), identifier, TypeScript.Syntax.token(107 /* EqualsToken */), moduleReference, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ImportDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ImportDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ImportDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ImportDeclarationSyntax.prototype.withImportKeyword = function (importKeyword) { + return this.update(this.modifiers, importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.importKeyword, identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(this.modifiers, this.importKeyword, this.identifier, equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withModuleReference = function (moduleReference) { + return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, semicolonToken); + }; + + ImportDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ImportDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ImportDeclarationSyntax = ImportDeclarationSyntax; + + var ExportAssignmentSyntax = (function (_super) { + __extends(ExportAssignmentSyntax, _super); + function ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.exportKeyword = exportKeyword; + this.equalsToken = equalsToken; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + ExportAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitExportAssignment(this); + }; + + ExportAssignmentSyntax.prototype.kind = function () { + return 134 /* ExportAssignment */; + }; + + ExportAssignmentSyntax.prototype.childCount = function () { + return 4; + }; + + ExportAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.exportKeyword; + case 1: + return this.equalsToken; + case 2: + return this.identifier; + case 3: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExportAssignmentSyntax.prototype.isModuleElement = function () { + return true; + }; + + ExportAssignmentSyntax.prototype.update = function (exportKeyword, equalsToken, identifier, semicolonToken) { + if (this.exportKeyword === exportKeyword && this.equalsToken === equalsToken && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + ExportAssignmentSyntax.create1 = function (identifier) { + return new ExportAssignmentSyntax(TypeScript.Syntax.token(47 /* ExportKeyword */), TypeScript.Syntax.token(107 /* EqualsToken */), identifier, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ExportAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExportAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExportAssignmentSyntax.prototype.withExportKeyword = function (exportKeyword) { + return this.update(exportKeyword, this.equalsToken, this.identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(this.exportKeyword, equalsToken, this.identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.exportKeyword, this.equalsToken, identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.exportKeyword, this.equalsToken, this.identifier, semicolonToken); + }; + + ExportAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ExportAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExportAssignmentSyntax = ExportAssignmentSyntax; + + var ClassDeclarationSyntax = (function (_super) { + __extends(ClassDeclarationSyntax, _super); + function ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.classKeyword = classKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.openBraceToken = openBraceToken; + this.classElements = classElements; + this.closeBraceToken = closeBraceToken; + } + ClassDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitClassDeclaration(this); + }; + + ClassDeclarationSyntax.prototype.kind = function () { + return 131 /* ClassDeclaration */; + }; + + ClassDeclarationSyntax.prototype.childCount = function () { + return 8; + }; + + ClassDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.classKeyword; + case 2: + return this.identifier; + case 3: + return this.typeParameterList; + case 4: + return this.heritageClauses; + case 5: + return this.openBraceToken; + case 6: + return this.classElements; + case 7: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ClassDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ClassDeclarationSyntax.prototype.update = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + if (this.modifiers === modifiers && this.classKeyword === classKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.openBraceToken === openBraceToken && this.classElements === classElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, this.parsedInStrictMode()); + }; + + ClassDeclarationSyntax.create = function (classKeyword, identifier, openBraceToken, closeBraceToken) { + return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, classKeyword, identifier, null, TypeScript.Syntax.emptyList, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + ClassDeclarationSyntax.create1 = function (identifier) { + return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(44 /* ClassKeyword */), identifier, null, TypeScript.Syntax.emptyList, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ClassDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ClassDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ClassDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ClassDeclarationSyntax.prototype.withClassKeyword = function (classKeyword) { + return this.update(this.modifiers, classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.classKeyword, identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.modifiers, this.classKeyword, this.identifier, typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) { + return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause])); + }; + + ClassDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withClassElements = function (classElements) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withClassElement = function (classElement) { + return this.withClassElements(TypeScript.Syntax.list([classElement])); + }; + + ClassDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ClassDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ClassDeclarationSyntax = ClassDeclarationSyntax; + + var InterfaceDeclarationSyntax = (function (_super) { + __extends(InterfaceDeclarationSyntax, _super); + function InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.interfaceKeyword = interfaceKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.body = body; + } + InterfaceDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitInterfaceDeclaration(this); + }; + + InterfaceDeclarationSyntax.prototype.kind = function () { + return 128 /* InterfaceDeclaration */; + }; + + InterfaceDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + InterfaceDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.interfaceKeyword; + case 2: + return this.identifier; + case 3: + return this.typeParameterList; + case 4: + return this.heritageClauses; + case 5: + return this.body; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + InterfaceDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + InterfaceDeclarationSyntax.prototype.update = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + if (this.modifiers === modifiers && this.interfaceKeyword === interfaceKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.body === body) { + return this; + } + + return new InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, this.parsedInStrictMode()); + }; + + InterfaceDeclarationSyntax.create = function (interfaceKeyword, identifier, body) { + return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, interfaceKeyword, identifier, null, TypeScript.Syntax.emptyList, body, false); + }; + + InterfaceDeclarationSyntax.create1 = function (identifier) { + return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(52 /* InterfaceKeyword */), identifier, null, TypeScript.Syntax.emptyList, ObjectTypeSyntax.create1(), false); + }; + + InterfaceDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + InterfaceDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + InterfaceDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + InterfaceDeclarationSyntax.prototype.withInterfaceKeyword = function (interfaceKeyword) { + return this.update(this.modifiers, interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.interfaceKeyword, identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) { + return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause])); + }; + + InterfaceDeclarationSyntax.prototype.withBody = function (body) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, body); + }; + + InterfaceDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return InterfaceDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.InterfaceDeclarationSyntax = InterfaceDeclarationSyntax; + + var HeritageClauseSyntax = (function (_super) { + __extends(HeritageClauseSyntax, _super); + function HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.extendsOrImplementsKeyword = extendsOrImplementsKeyword; + this.typeNames = typeNames; + + this._kind = kind; + } + HeritageClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitHeritageClause(this); + }; + + HeritageClauseSyntax.prototype.childCount = function () { + return 2; + }; + + HeritageClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.extendsOrImplementsKeyword; + case 1: + return this.typeNames; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + HeritageClauseSyntax.prototype.kind = function () { + return this._kind; + }; + + HeritageClauseSyntax.prototype.update = function (kind, extendsOrImplementsKeyword, typeNames) { + if (this._kind === kind && this.extendsOrImplementsKeyword === extendsOrImplementsKeyword && this.typeNames === typeNames) { + return this; + } + + return new HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, this.parsedInStrictMode()); + }; + + HeritageClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + HeritageClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + HeritageClauseSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.extendsOrImplementsKeyword, this.typeNames); + }; + + HeritageClauseSyntax.prototype.withExtendsOrImplementsKeyword = function (extendsOrImplementsKeyword) { + return this.update(this._kind, extendsOrImplementsKeyword, this.typeNames); + }; + + HeritageClauseSyntax.prototype.withTypeNames = function (typeNames) { + return this.update(this._kind, this.extendsOrImplementsKeyword, typeNames); + }; + + HeritageClauseSyntax.prototype.withTypeName = function (typeName) { + return this.withTypeNames(TypeScript.Syntax.separatedList([typeName])); + }; + + HeritageClauseSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return HeritageClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.HeritageClauseSyntax = HeritageClauseSyntax; + + var ModuleDeclarationSyntax = (function (_super) { + __extends(ModuleDeclarationSyntax, _super); + function ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.moduleKeyword = moduleKeyword; + this.name = name; + this.stringLiteral = stringLiteral; + this.openBraceToken = openBraceToken; + this.moduleElements = moduleElements; + this.closeBraceToken = closeBraceToken; + } + ModuleDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitModuleDeclaration(this); + }; + + ModuleDeclarationSyntax.prototype.kind = function () { + return 130 /* ModuleDeclaration */; + }; + + ModuleDeclarationSyntax.prototype.childCount = function () { + return 7; + }; + + ModuleDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.moduleKeyword; + case 2: + return this.name; + case 3: + return this.stringLiteral; + case 4: + return this.openBraceToken; + case 5: + return this.moduleElements; + case 6: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ModuleDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ModuleDeclarationSyntax.prototype.update = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + if (this.modifiers === modifiers && this.moduleKeyword === moduleKeyword && this.name === name && this.stringLiteral === stringLiteral && this.openBraceToken === openBraceToken && this.moduleElements === moduleElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, this.parsedInStrictMode()); + }; + + ModuleDeclarationSyntax.create = function (moduleKeyword, openBraceToken, closeBraceToken) { + return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, moduleKeyword, null, null, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + ModuleDeclarationSyntax.create1 = function () { + return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(65 /* ModuleKeyword */), null, null, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ModuleDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ModuleDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ModuleDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ModuleDeclarationSyntax.prototype.withModuleKeyword = function (moduleKeyword) { + return this.update(this.modifiers, moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withName = function (name) { + return this.update(this.modifiers, this.moduleKeyword, name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withStringLiteral = function (stringLiteral) { + return this.update(this.modifiers, this.moduleKeyword, this.name, stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModuleElements = function (moduleElements) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModuleElement = function (moduleElement) { + return this.withModuleElements(TypeScript.Syntax.list([moduleElement])); + }; + + ModuleDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ModuleDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ModuleDeclarationSyntax = ModuleDeclarationSyntax; + + var FunctionDeclarationSyntax = (function (_super) { + __extends(FunctionDeclarationSyntax, _super); + function FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + } + FunctionDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionDeclaration(this); + }; + + FunctionDeclarationSyntax.prototype.kind = function () { + return 129 /* FunctionDeclaration */; + }; + + FunctionDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + FunctionDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.functionKeyword; + case 2: + return this.identifier; + case 3: + return this.callSignature; + case 4: + return this.block; + case 5: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionDeclarationSyntax.prototype.isStatement = function () { + return true; + }; + + FunctionDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + FunctionDeclarationSyntax.prototype.update = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + if (this.modifiers === modifiers && this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, this.parsedInStrictMode()); + }; + + FunctionDeclarationSyntax.create = function (functionKeyword, identifier, callSignature) { + return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, functionKeyword, identifier, callSignature, null, null, false); + }; + + FunctionDeclarationSyntax.create1 = function (identifier) { + return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(27 /* FunctionKeyword */), identifier, CallSignatureSyntax.create1(), null, null, false); + }; + + FunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + FunctionDeclarationSyntax.prototype.withFunctionKeyword = function (functionKeyword) { + return this.update(this.modifiers, functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.functionKeyword, identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block !== null && this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionDeclarationSyntax = FunctionDeclarationSyntax; + + var VariableStatementSyntax = (function (_super) { + __extends(VariableStatementSyntax, _super); + function VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.variableDeclaration = variableDeclaration; + this.semicolonToken = semicolonToken; + } + VariableStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableStatement(this); + }; + + VariableStatementSyntax.prototype.kind = function () { + return 148 /* VariableStatement */; + }; + + VariableStatementSyntax.prototype.childCount = function () { + return 3; + }; + + VariableStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.variableDeclaration; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableStatementSyntax.prototype.isStatement = function () { + return true; + }; + + VariableStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + VariableStatementSyntax.prototype.update = function (modifiers, variableDeclaration, semicolonToken) { + if (this.modifiers === modifiers && this.variableDeclaration === variableDeclaration && this.semicolonToken === semicolonToken) { + return this; + } + + return new VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, this.parsedInStrictMode()); + }; + + VariableStatementSyntax.create = function (variableDeclaration, semicolonToken) { + return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, semicolonToken, false); + }; + + VariableStatementSyntax.create1 = function (variableDeclaration) { + return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + VariableStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableStatementSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.variableDeclaration, this.semicolonToken); + }; + + VariableStatementSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + VariableStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.modifiers, variableDeclaration, this.semicolonToken); + }; + + VariableStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.variableDeclaration, semicolonToken); + }; + + VariableStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableStatementSyntax = VariableStatementSyntax; + + var VariableDeclarationSyntax = (function (_super) { + __extends(VariableDeclarationSyntax, _super); + function VariableDeclarationSyntax(varKeyword, variableDeclarators, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.varKeyword = varKeyword; + this.variableDeclarators = variableDeclarators; + } + VariableDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableDeclaration(this); + }; + + VariableDeclarationSyntax.prototype.kind = function () { + return 224 /* VariableDeclaration */; + }; + + VariableDeclarationSyntax.prototype.childCount = function () { + return 2; + }; + + VariableDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.varKeyword; + case 1: + return this.variableDeclarators; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableDeclarationSyntax.prototype.update = function (varKeyword, variableDeclarators) { + if (this.varKeyword === varKeyword && this.variableDeclarators === variableDeclarators) { + return this; + } + + return new VariableDeclarationSyntax(varKeyword, variableDeclarators, this.parsedInStrictMode()); + }; + + VariableDeclarationSyntax.create1 = function (variableDeclarators) { + return new VariableDeclarationSyntax(TypeScript.Syntax.token(40 /* VarKeyword */), variableDeclarators, false); + }; + + VariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableDeclarationSyntax.prototype.withVarKeyword = function (varKeyword) { + return this.update(varKeyword, this.variableDeclarators); + }; + + VariableDeclarationSyntax.prototype.withVariableDeclarators = function (variableDeclarators) { + return this.update(this.varKeyword, variableDeclarators); + }; + + VariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) { + return this.withVariableDeclarators(TypeScript.Syntax.separatedList([variableDeclarator])); + }; + + VariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclarators.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableDeclarationSyntax = VariableDeclarationSyntax; + + var VariableDeclaratorSyntax = (function (_super) { + __extends(VariableDeclaratorSyntax, _super); + function VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + } + VariableDeclaratorSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableDeclarator(this); + }; + + VariableDeclaratorSyntax.prototype.kind = function () { + return 225 /* VariableDeclarator */; + }; + + VariableDeclaratorSyntax.prototype.childCount = function () { + return 3; + }; + + VariableDeclaratorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.typeAnnotation; + case 2: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableDeclaratorSyntax.prototype.update = function (propertyName, typeAnnotation, equalsValueClause) { + if (this.propertyName === propertyName && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, this.parsedInStrictMode()); + }; + + VariableDeclaratorSyntax.create = function (propertyName) { + return new VariableDeclaratorSyntax(propertyName, null, null, false); + }; + + VariableDeclaratorSyntax.create1 = function (propertyName) { + return new VariableDeclaratorSyntax(propertyName, null, null, false); + }; + + VariableDeclaratorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableDeclaratorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableDeclaratorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.typeAnnotation, this.equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.propertyName, typeAnnotation, this.equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.propertyName, this.typeAnnotation, equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeAnnotation !== null) { + return true; + } + if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableDeclaratorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableDeclaratorSyntax = VariableDeclaratorSyntax; + + var EqualsValueClauseSyntax = (function (_super) { + __extends(EqualsValueClauseSyntax, _super); + function EqualsValueClauseSyntax(equalsToken, value, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.equalsToken = equalsToken; + this.value = value; + } + EqualsValueClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitEqualsValueClause(this); + }; + + EqualsValueClauseSyntax.prototype.kind = function () { + return 232 /* EqualsValueClause */; + }; + + EqualsValueClauseSyntax.prototype.childCount = function () { + return 2; + }; + + EqualsValueClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.equalsToken; + case 1: + return this.value; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EqualsValueClauseSyntax.prototype.update = function (equalsToken, value) { + if (this.equalsToken === equalsToken && this.value === value) { + return this; + } + + return new EqualsValueClauseSyntax(equalsToken, value, this.parsedInStrictMode()); + }; + + EqualsValueClauseSyntax.create1 = function (value) { + return new EqualsValueClauseSyntax(TypeScript.Syntax.token(107 /* EqualsToken */), value, false); + }; + + EqualsValueClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EqualsValueClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EqualsValueClauseSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(equalsToken, this.value); + }; + + EqualsValueClauseSyntax.prototype.withValue = function (value) { + return this.update(this.equalsToken, value); + }; + + EqualsValueClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.value.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return EqualsValueClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EqualsValueClauseSyntax = EqualsValueClauseSyntax; + + var PrefixUnaryExpressionSyntax = (function (_super) { + __extends(PrefixUnaryExpressionSyntax, _super); + function PrefixUnaryExpressionSyntax(kind, operatorToken, operand, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.operatorToken = operatorToken; + this.operand = operand; + + this._kind = kind; + } + PrefixUnaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitPrefixUnaryExpression(this); + }; + + PrefixUnaryExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + PrefixUnaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.operatorToken; + case 1: + return this.operand; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PrefixUnaryExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + PrefixUnaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + PrefixUnaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + PrefixUnaryExpressionSyntax.prototype.update = function (kind, operatorToken, operand) { + if (this._kind === kind && this.operatorToken === operatorToken && this.operand === operand) { + return this; + } + + return new PrefixUnaryExpressionSyntax(kind, operatorToken, operand, this.parsedInStrictMode()); + }; + + PrefixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PrefixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PrefixUnaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.operatorToken, this.operand); + }; + + PrefixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, operatorToken, this.operand); + }; + + PrefixUnaryExpressionSyntax.prototype.withOperand = function (operand) { + return this.update(this._kind, this.operatorToken, operand); + }; + + PrefixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.operand.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return PrefixUnaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PrefixUnaryExpressionSyntax = PrefixUnaryExpressionSyntax; + + var ArrayLiteralExpressionSyntax = (function (_super) { + __extends(ArrayLiteralExpressionSyntax, _super); + function ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBracketToken = openBracketToken; + this.expressions = expressions; + this.closeBracketToken = closeBracketToken; + } + ArrayLiteralExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitArrayLiteralExpression(this); + }; + + ArrayLiteralExpressionSyntax.prototype.kind = function () { + return 214 /* ArrayLiteralExpression */; + }; + + ArrayLiteralExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ArrayLiteralExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBracketToken; + case 1: + return this.expressions; + case 2: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArrayLiteralExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.update = function (openBracketToken, expressions, closeBracketToken) { + if (this.openBracketToken === openBracketToken && this.expressions === expressions && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, this.parsedInStrictMode()); + }; + + ArrayLiteralExpressionSyntax.create = function (openBracketToken, closeBracketToken) { + return new ArrayLiteralExpressionSyntax(openBracketToken, TypeScript.Syntax.emptySeparatedList, closeBracketToken, false); + }; + + ArrayLiteralExpressionSyntax.create1 = function () { + return new ArrayLiteralExpressionSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ArrayLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArrayLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArrayLiteralExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(openBracketToken, this.expressions, this.closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.withExpressions = function (expressions) { + return this.update(this.openBracketToken, expressions, this.closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.withExpression = function (expression) { + return this.withExpressions(TypeScript.Syntax.separatedList([expression])); + }; + + ArrayLiteralExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.openBracketToken, this.expressions, closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expressions.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ArrayLiteralExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArrayLiteralExpressionSyntax = ArrayLiteralExpressionSyntax; + + var OmittedExpressionSyntax = (function (_super) { + __extends(OmittedExpressionSyntax, _super); + function OmittedExpressionSyntax(parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + } + OmittedExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitOmittedExpression(this); + }; + + OmittedExpressionSyntax.prototype.kind = function () { + return 223 /* OmittedExpression */; + }; + + OmittedExpressionSyntax.prototype.childCount = function () { + return 0; + }; + + OmittedExpressionSyntax.prototype.childAt = function (slot) { + throw TypeScript.Errors.invalidOperation(); + }; + + OmittedExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + OmittedExpressionSyntax.prototype.update = function () { + return this; + }; + + OmittedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + OmittedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + OmittedExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return OmittedExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.OmittedExpressionSyntax = OmittedExpressionSyntax; + + var ParenthesizedExpressionSyntax = (function (_super) { + __extends(ParenthesizedExpressionSyntax, _super); + function ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + } + ParenthesizedExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitParenthesizedExpression(this); + }; + + ParenthesizedExpressionSyntax.prototype.kind = function () { + return 217 /* ParenthesizedExpression */; + }; + + ParenthesizedExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ParenthesizedExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openParenToken; + case 1: + return this.expression; + case 2: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParenthesizedExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.update = function (openParenToken, expression, closeParenToken) { + if (this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken) { + return this; + } + + return new ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, this.parsedInStrictMode()); + }; + + ParenthesizedExpressionSyntax.create1 = function (expression) { + return new ParenthesizedExpressionSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ParenthesizedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParenthesizedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParenthesizedExpressionSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(openParenToken, this.expression, this.closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.openParenToken, expression, this.closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.openParenToken, this.expression, closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ParenthesizedExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParenthesizedExpressionSyntax = ParenthesizedExpressionSyntax; + + var SimpleArrowFunctionExpressionSyntax = (function (_super) { + __extends(SimpleArrowFunctionExpressionSyntax, _super); + function SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + } + SimpleArrowFunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitSimpleArrowFunctionExpression(this); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.kind = function () { + return 219 /* SimpleArrowFunctionExpression */; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.equalsGreaterThanToken; + case 2: + return this.block; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.update = function (identifier, equalsGreaterThanToken, block, expression) { + if (this.identifier === identifier && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) { + return this; + } + + return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, this.parsedInStrictMode()); + }; + + SimpleArrowFunctionExpressionSyntax.create = function (identifier, equalsGreaterThanToken) { + return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, null, null, false); + }; + + SimpleArrowFunctionExpressionSyntax.create1 = function (identifier) { + return new SimpleArrowFunctionExpressionSyntax(identifier, TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.equalsGreaterThanToken, this.block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.identifier, equalsGreaterThanToken, this.block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.identifier, this.equalsGreaterThanToken, block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.identifier, this.equalsGreaterThanToken, this.block, expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return SimpleArrowFunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SimpleArrowFunctionExpressionSyntax = SimpleArrowFunctionExpressionSyntax; + + var ParenthesizedArrowFunctionExpressionSyntax = (function (_super) { + __extends(ParenthesizedArrowFunctionExpressionSyntax, _super); + function ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.callSignature = callSignature; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + } + ParenthesizedArrowFunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitParenthesizedArrowFunctionExpression(this); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = function () { + return 218 /* ParenthesizedArrowFunctionExpression */; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.callSignature; + case 1: + return this.equalsGreaterThanToken; + case 2: + return this.block; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.update = function (callSignature, equalsGreaterThanToken, block, expression) { + if (this.callSignature === callSignature && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) { + return this; + } + + return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, this.parsedInStrictMode()); + }; + + ParenthesizedArrowFunctionExpressionSyntax.create = function (callSignature, equalsGreaterThanToken) { + return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, null, null, false); + }; + + ParenthesizedArrowFunctionExpressionSyntax.create1 = function () { + return new ParenthesizedArrowFunctionExpressionSyntax(CallSignatureSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(callSignature, this.equalsGreaterThanToken, this.block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.callSignature, equalsGreaterThanToken, this.block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.callSignature, this.equalsGreaterThanToken, block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.callSignature, this.equalsGreaterThanToken, this.block, expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ParenthesizedArrowFunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParenthesizedArrowFunctionExpressionSyntax = ParenthesizedArrowFunctionExpressionSyntax; + + var QualifiedNameSyntax = (function (_super) { + __extends(QualifiedNameSyntax, _super); + function QualifiedNameSyntax(left, dotToken, right, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.left = left; + this.dotToken = dotToken; + this.right = right; + } + QualifiedNameSyntax.prototype.accept = function (visitor) { + return visitor.visitQualifiedName(this); + }; + + QualifiedNameSyntax.prototype.kind = function () { + return 121 /* QualifiedName */; + }; + + QualifiedNameSyntax.prototype.childCount = function () { + return 3; + }; + + QualifiedNameSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.left; + case 1: + return this.dotToken; + case 2: + return this.right; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + QualifiedNameSyntax.prototype.isName = function () { + return true; + }; + + QualifiedNameSyntax.prototype.isType = function () { + return true; + }; + + QualifiedNameSyntax.prototype.update = function (left, dotToken, right) { + if (this.left === left && this.dotToken === dotToken && this.right === right) { + return this; + } + + return new QualifiedNameSyntax(left, dotToken, right, this.parsedInStrictMode()); + }; + + QualifiedNameSyntax.create1 = function (left, right) { + return new QualifiedNameSyntax(left, TypeScript.Syntax.token(76 /* DotToken */), right, false); + }; + + QualifiedNameSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + QualifiedNameSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + QualifiedNameSyntax.prototype.withLeft = function (left) { + return this.update(left, this.dotToken, this.right); + }; + + QualifiedNameSyntax.prototype.withDotToken = function (dotToken) { + return this.update(this.left, dotToken, this.right); + }; + + QualifiedNameSyntax.prototype.withRight = function (right) { + return this.update(this.left, this.dotToken, right); + }; + + QualifiedNameSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return QualifiedNameSyntax; + })(TypeScript.SyntaxNode); + TypeScript.QualifiedNameSyntax = QualifiedNameSyntax; + + var TypeArgumentListSyntax = (function (_super) { + __extends(TypeArgumentListSyntax, _super); + function TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.typeArguments = typeArguments; + this.greaterThanToken = greaterThanToken; + } + TypeArgumentListSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeArgumentList(this); + }; + + TypeArgumentListSyntax.prototype.kind = function () { + return 228 /* TypeArgumentList */; + }; + + TypeArgumentListSyntax.prototype.childCount = function () { + return 3; + }; + + TypeArgumentListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.typeArguments; + case 2: + return this.greaterThanToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeArgumentListSyntax.prototype.update = function (lessThanToken, typeArguments, greaterThanToken) { + if (this.lessThanToken === lessThanToken && this.typeArguments === typeArguments && this.greaterThanToken === greaterThanToken) { + return this; + } + + return new TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, this.parsedInStrictMode()); + }; + + TypeArgumentListSyntax.create = function (lessThanToken, greaterThanToken) { + return new TypeArgumentListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false); + }; + + TypeArgumentListSyntax.create1 = function () { + return new TypeArgumentListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false); + }; + + TypeArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeArgumentListSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.typeArguments, this.greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.withTypeArguments = function (typeArguments) { + return this.update(this.lessThanToken, typeArguments, this.greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.withTypeArgument = function (typeArgument) { + return this.withTypeArguments(TypeScript.Syntax.separatedList([typeArgument])); + }; + + TypeArgumentListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.typeArguments, greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeArgumentListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeArgumentListSyntax = TypeArgumentListSyntax; + + var ConstructorTypeSyntax = (function (_super) { + __extends(ConstructorTypeSyntax, _super); + function ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + } + ConstructorTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructorType(this); + }; + + ConstructorTypeSyntax.prototype.kind = function () { + return 125 /* ConstructorType */; + }; + + ConstructorTypeSyntax.prototype.childCount = function () { + return 5; + }; + + ConstructorTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.typeParameterList; + case 2: + return this.parameterList; + case 3: + return this.equalsGreaterThanToken; + case 4: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructorTypeSyntax.prototype.isType = function () { + return true; + }; + + ConstructorTypeSyntax.prototype.update = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + if (this.newKeyword === newKeyword && this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) { + return this; + } + + return new ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode()); + }; + + ConstructorTypeSyntax.create = function (newKeyword, parameterList, equalsGreaterThanToken, type) { + return new ConstructorTypeSyntax(newKeyword, null, parameterList, equalsGreaterThanToken, type, false); + }; + + ConstructorTypeSyntax.create1 = function (type) { + return new ConstructorTypeSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false); + }; + + ConstructorTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructorTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructorTypeSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.newKeyword, typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.newKeyword, this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.newKeyword, this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withType = function (type) { + return this.update(this.newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type); + }; + + ConstructorTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructorTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructorTypeSyntax = ConstructorTypeSyntax; + + var FunctionTypeSyntax = (function (_super) { + __extends(FunctionTypeSyntax, _super); + function FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + } + FunctionTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionType(this); + }; + + FunctionTypeSyntax.prototype.kind = function () { + return 123 /* FunctionType */; + }; + + FunctionTypeSyntax.prototype.childCount = function () { + return 4; + }; + + FunctionTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeParameterList; + case 1: + return this.parameterList; + case 2: + return this.equalsGreaterThanToken; + case 3: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionTypeSyntax.prototype.isType = function () { + return true; + }; + + FunctionTypeSyntax.prototype.update = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) { + return this; + } + + return new FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode()); + }; + + FunctionTypeSyntax.create = function (parameterList, equalsGreaterThanToken, type) { + return new FunctionTypeSyntax(null, parameterList, equalsGreaterThanToken, type, false); + }; + + FunctionTypeSyntax.create1 = function (type) { + return new FunctionTypeSyntax(null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false); + }; + + FunctionTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withType = function (type) { + return this.update(this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type); + }; + + FunctionTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return FunctionTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionTypeSyntax = FunctionTypeSyntax; + + var ObjectTypeSyntax = (function (_super) { + __extends(ObjectTypeSyntax, _super); + function ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.typeMembers = typeMembers; + this.closeBraceToken = closeBraceToken; + } + ObjectTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectType(this); + }; + + ObjectTypeSyntax.prototype.kind = function () { + return 122 /* ObjectType */; + }; + + ObjectTypeSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.typeMembers; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectTypeSyntax.prototype.isType = function () { + return true; + }; + + ObjectTypeSyntax.prototype.update = function (openBraceToken, typeMembers, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.typeMembers === typeMembers && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, this.parsedInStrictMode()); + }; + + ObjectTypeSyntax.create = function (openBraceToken, closeBraceToken) { + return new ObjectTypeSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + ObjectTypeSyntax.create1 = function () { + return new ObjectTypeSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ObjectTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectTypeSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.typeMembers, this.closeBraceToken); + }; + + ObjectTypeSyntax.prototype.withTypeMembers = function (typeMembers) { + return this.update(this.openBraceToken, typeMembers, this.closeBraceToken); + }; + + ObjectTypeSyntax.prototype.withTypeMember = function (typeMember) { + return this.withTypeMembers(TypeScript.Syntax.separatedList([typeMember])); + }; + + ObjectTypeSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.typeMembers, closeBraceToken); + }; + + ObjectTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ObjectTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectTypeSyntax = ObjectTypeSyntax; + + var ArrayTypeSyntax = (function (_super) { + __extends(ArrayTypeSyntax, _super); + function ArrayTypeSyntax(type, openBracketToken, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.type = type; + this.openBracketToken = openBracketToken; + this.closeBracketToken = closeBracketToken; + } + ArrayTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitArrayType(this); + }; + + ArrayTypeSyntax.prototype.kind = function () { + return 124 /* ArrayType */; + }; + + ArrayTypeSyntax.prototype.childCount = function () { + return 3; + }; + + ArrayTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.type; + case 1: + return this.openBracketToken; + case 2: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArrayTypeSyntax.prototype.isType = function () { + return true; + }; + + ArrayTypeSyntax.prototype.update = function (type, openBracketToken, closeBracketToken) { + if (this.type === type && this.openBracketToken === openBracketToken && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ArrayTypeSyntax(type, openBracketToken, closeBracketToken, this.parsedInStrictMode()); + }; + + ArrayTypeSyntax.create1 = function (type) { + return new ArrayTypeSyntax(type, TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ArrayTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArrayTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArrayTypeSyntax.prototype.withType = function (type) { + return this.update(type, this.openBracketToken, this.closeBracketToken); + }; + + ArrayTypeSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(this.type, openBracketToken, this.closeBracketToken); + }; + + ArrayTypeSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.type, this.openBracketToken, closeBracketToken); + }; + + ArrayTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ArrayTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArrayTypeSyntax = ArrayTypeSyntax; + + var GenericTypeSyntax = (function (_super) { + __extends(GenericTypeSyntax, _super); + function GenericTypeSyntax(name, typeArgumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.name = name; + this.typeArgumentList = typeArgumentList; + } + GenericTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitGenericType(this); + }; + + GenericTypeSyntax.prototype.kind = function () { + return 126 /* GenericType */; + }; + + GenericTypeSyntax.prototype.childCount = function () { + return 2; + }; + + GenericTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.name; + case 1: + return this.typeArgumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + GenericTypeSyntax.prototype.isType = function () { + return true; + }; + + GenericTypeSyntax.prototype.update = function (name, typeArgumentList) { + if (this.name === name && this.typeArgumentList === typeArgumentList) { + return this; + } + + return new GenericTypeSyntax(name, typeArgumentList, this.parsedInStrictMode()); + }; + + GenericTypeSyntax.create1 = function (name) { + return new GenericTypeSyntax(name, TypeArgumentListSyntax.create1(), false); + }; + + GenericTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + GenericTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + GenericTypeSyntax.prototype.withName = function (name) { + return this.update(name, this.typeArgumentList); + }; + + GenericTypeSyntax.prototype.withTypeArgumentList = function (typeArgumentList) { + return this.update(this.name, typeArgumentList); + }; + + GenericTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return GenericTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.GenericTypeSyntax = GenericTypeSyntax; + + var TypeQuerySyntax = (function (_super) { + __extends(TypeQuerySyntax, _super); + function TypeQuerySyntax(typeOfKeyword, name, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeOfKeyword = typeOfKeyword; + this.name = name; + } + TypeQuerySyntax.prototype.accept = function (visitor) { + return visitor.visitTypeQuery(this); + }; + + TypeQuerySyntax.prototype.kind = function () { + return 127 /* TypeQuery */; + }; + + TypeQuerySyntax.prototype.childCount = function () { + return 2; + }; + + TypeQuerySyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeOfKeyword; + case 1: + return this.name; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeQuerySyntax.prototype.isType = function () { + return true; + }; + + TypeQuerySyntax.prototype.update = function (typeOfKeyword, name) { + if (this.typeOfKeyword === typeOfKeyword && this.name === name) { + return this; + } + + return new TypeQuerySyntax(typeOfKeyword, name, this.parsedInStrictMode()); + }; + + TypeQuerySyntax.create1 = function (name) { + return new TypeQuerySyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), name, false); + }; + + TypeQuerySyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeQuerySyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeQuerySyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) { + return this.update(typeOfKeyword, this.name); + }; + + TypeQuerySyntax.prototype.withName = function (name) { + return this.update(this.typeOfKeyword, name); + }; + + TypeQuerySyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeQuerySyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeQuerySyntax = TypeQuerySyntax; + + var TypeAnnotationSyntax = (function (_super) { + __extends(TypeAnnotationSyntax, _super); + function TypeAnnotationSyntax(colonToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.colonToken = colonToken; + this.type = type; + } + TypeAnnotationSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeAnnotation(this); + }; + + TypeAnnotationSyntax.prototype.kind = function () { + return 244 /* TypeAnnotation */; + }; + + TypeAnnotationSyntax.prototype.childCount = function () { + return 2; + }; + + TypeAnnotationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.colonToken; + case 1: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeAnnotationSyntax.prototype.update = function (colonToken, type) { + if (this.colonToken === colonToken && this.type === type) { + return this; + } + + return new TypeAnnotationSyntax(colonToken, type, this.parsedInStrictMode()); + }; + + TypeAnnotationSyntax.create1 = function (type) { + return new TypeAnnotationSyntax(TypeScript.Syntax.token(106 /* ColonToken */), type, false); + }; + + TypeAnnotationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeAnnotationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeAnnotationSyntax.prototype.withColonToken = function (colonToken) { + return this.update(colonToken, this.type); + }; + + TypeAnnotationSyntax.prototype.withType = function (type) { + return this.update(this.colonToken, type); + }; + + TypeAnnotationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeAnnotationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeAnnotationSyntax = TypeAnnotationSyntax; + + var BlockSyntax = (function (_super) { + __extends(BlockSyntax, _super); + function BlockSyntax(openBraceToken, statements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.statements = statements; + this.closeBraceToken = closeBraceToken; + } + BlockSyntax.prototype.accept = function (visitor) { + return visitor.visitBlock(this); + }; + + BlockSyntax.prototype.kind = function () { + return 146 /* Block */; + }; + + BlockSyntax.prototype.childCount = function () { + return 3; + }; + + BlockSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.statements; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BlockSyntax.prototype.isStatement = function () { + return true; + }; + + BlockSyntax.prototype.isModuleElement = function () { + return true; + }; + + BlockSyntax.prototype.update = function (openBraceToken, statements, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.statements === statements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new BlockSyntax(openBraceToken, statements, closeBraceToken, this.parsedInStrictMode()); + }; + + BlockSyntax.create = function (openBraceToken, closeBraceToken) { + return new BlockSyntax(openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + BlockSyntax.create1 = function () { + return new BlockSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + BlockSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BlockSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BlockSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.statements, this.closeBraceToken); + }; + + BlockSyntax.prototype.withStatements = function (statements) { + return this.update(this.openBraceToken, statements, this.closeBraceToken); + }; + + BlockSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + BlockSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.statements, closeBraceToken); + }; + + BlockSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return BlockSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BlockSyntax = BlockSyntax; + + var ParameterSyntax = (function (_super) { + __extends(ParameterSyntax, _super); + function ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.dotDotDotToken = dotDotDotToken; + this.modifiers = modifiers; + this.identifier = identifier; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + } + ParameterSyntax.prototype.accept = function (visitor) { + return visitor.visitParameter(this); + }; + + ParameterSyntax.prototype.kind = function () { + return 242 /* Parameter */; + }; + + ParameterSyntax.prototype.childCount = function () { + return 6; + }; + + ParameterSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.dotDotDotToken; + case 1: + return this.modifiers; + case 2: + return this.identifier; + case 3: + return this.questionToken; + case 4: + return this.typeAnnotation; + case 5: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParameterSyntax.prototype.update = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + if (this.dotDotDotToken === dotDotDotToken && this.modifiers === modifiers && this.identifier === identifier && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, this.parsedInStrictMode()); + }; + + ParameterSyntax.create = function (identifier) { + return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false); + }; + + ParameterSyntax.create1 = function (identifier) { + return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false); + }; + + ParameterSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParameterSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParameterSyntax.prototype.withDotDotDotToken = function (dotDotDotToken) { + return this.update(dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withModifiers = function (modifiers) { + return this.update(this.dotDotDotToken, modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ParameterSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.dotDotDotToken, this.modifiers, identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, equalsValueClause); + }; + + ParameterSyntax.prototype.isTypeScriptSpecific = function () { + if (this.dotDotDotToken !== null) { + return true; + } + if (this.modifiers.isTypeScriptSpecific()) { + return true; + } + if (this.questionToken !== null) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + if (this.equalsValueClause !== null) { + return true; + } + return false; + }; + return ParameterSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParameterSyntax = ParameterSyntax; + + var MemberAccessExpressionSyntax = (function (_super) { + __extends(MemberAccessExpressionSyntax, _super); + function MemberAccessExpressionSyntax(expression, dotToken, name, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.dotToken = dotToken; + this.name = name; + } + MemberAccessExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberAccessExpression(this); + }; + + MemberAccessExpressionSyntax.prototype.kind = function () { + return 212 /* MemberAccessExpression */; + }; + + MemberAccessExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + MemberAccessExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.dotToken; + case 2: + return this.name; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberAccessExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.update = function (expression, dotToken, name) { + if (this.expression === expression && this.dotToken === dotToken && this.name === name) { + return this; + } + + return new MemberAccessExpressionSyntax(expression, dotToken, name, this.parsedInStrictMode()); + }; + + MemberAccessExpressionSyntax.create1 = function (expression, name) { + return new MemberAccessExpressionSyntax(expression, TypeScript.Syntax.token(76 /* DotToken */), name, false); + }; + + MemberAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberAccessExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.dotToken, this.name); + }; + + MemberAccessExpressionSyntax.prototype.withDotToken = function (dotToken) { + return this.update(this.expression, dotToken, this.name); + }; + + MemberAccessExpressionSyntax.prototype.withName = function (name) { + return this.update(this.expression, this.dotToken, name); + }; + + MemberAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return MemberAccessExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberAccessExpressionSyntax = MemberAccessExpressionSyntax; + + var PostfixUnaryExpressionSyntax = (function (_super) { + __extends(PostfixUnaryExpressionSyntax, _super); + function PostfixUnaryExpressionSyntax(kind, operand, operatorToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.operand = operand; + this.operatorToken = operatorToken; + + this._kind = kind; + } + PostfixUnaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitPostfixUnaryExpression(this); + }; + + PostfixUnaryExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + PostfixUnaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.operand; + case 1: + return this.operatorToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PostfixUnaryExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + PostfixUnaryExpressionSyntax.prototype.update = function (kind, operand, operatorToken) { + if (this._kind === kind && this.operand === operand && this.operatorToken === operatorToken) { + return this; + } + + return new PostfixUnaryExpressionSyntax(kind, operand, operatorToken, this.parsedInStrictMode()); + }; + + PostfixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PostfixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PostfixUnaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.operand, this.operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.withOperand = function (operand) { + return this.update(this._kind, operand, this.operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, this.operand, operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.operand.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return PostfixUnaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PostfixUnaryExpressionSyntax = PostfixUnaryExpressionSyntax; + + var ElementAccessExpressionSyntax = (function (_super) { + __extends(ElementAccessExpressionSyntax, _super); + function ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.openBracketToken = openBracketToken; + this.argumentExpression = argumentExpression; + this.closeBracketToken = closeBracketToken; + } + ElementAccessExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitElementAccessExpression(this); + }; + + ElementAccessExpressionSyntax.prototype.kind = function () { + return 221 /* ElementAccessExpression */; + }; + + ElementAccessExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + ElementAccessExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.openBracketToken; + case 2: + return this.argumentExpression; + case 3: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ElementAccessExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.update = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + if (this.expression === expression && this.openBracketToken === openBracketToken && this.argumentExpression === argumentExpression && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, this.parsedInStrictMode()); + }; + + ElementAccessExpressionSyntax.create1 = function (expression, argumentExpression) { + return new ElementAccessExpressionSyntax(expression, TypeScript.Syntax.token(74 /* OpenBracketToken */), argumentExpression, TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ElementAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ElementAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ElementAccessExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.openBracketToken, this.argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(this.expression, openBracketToken, this.argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withArgumentExpression = function (argumentExpression) { + return this.update(this.expression, this.openBracketToken, argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.expression, this.openBracketToken, this.argumentExpression, closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentExpression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ElementAccessExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ElementAccessExpressionSyntax = ElementAccessExpressionSyntax; + + var InvocationExpressionSyntax = (function (_super) { + __extends(InvocationExpressionSyntax, _super); + function InvocationExpressionSyntax(expression, argumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.argumentList = argumentList; + } + InvocationExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitInvocationExpression(this); + }; + + InvocationExpressionSyntax.prototype.kind = function () { + return 213 /* InvocationExpression */; + }; + + InvocationExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + InvocationExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.argumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + InvocationExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.update = function (expression, argumentList) { + if (this.expression === expression && this.argumentList === argumentList) { + return this; + } + + return new InvocationExpressionSyntax(expression, argumentList, this.parsedInStrictMode()); + }; + + InvocationExpressionSyntax.create1 = function (expression) { + return new InvocationExpressionSyntax(expression, ArgumentListSyntax.create1(), false); + }; + + InvocationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + InvocationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + InvocationExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.argumentList); + }; + + InvocationExpressionSyntax.prototype.withArgumentList = function (argumentList) { + return this.update(this.expression, argumentList); + }; + + InvocationExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentList.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return InvocationExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.InvocationExpressionSyntax = InvocationExpressionSyntax; + + var ArgumentListSyntax = (function (_super) { + __extends(ArgumentListSyntax, _super); + function ArgumentListSyntax(typeArgumentList, openParenToken, arguments, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeArgumentList = typeArgumentList; + this.openParenToken = openParenToken; + this.arguments = arguments; + this.closeParenToken = closeParenToken; + } + ArgumentListSyntax.prototype.accept = function (visitor) { + return visitor.visitArgumentList(this); + }; + + ArgumentListSyntax.prototype.kind = function () { + return 226 /* ArgumentList */; + }; + + ArgumentListSyntax.prototype.childCount = function () { + return 4; + }; + + ArgumentListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeArgumentList; + case 1: + return this.openParenToken; + case 2: + return this.arguments; + case 3: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArgumentListSyntax.prototype.update = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + if (this.typeArgumentList === typeArgumentList && this.openParenToken === openParenToken && this.arguments === _arguments && this.closeParenToken === closeParenToken) { + return this; + } + + return new ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, this.parsedInStrictMode()); + }; + + ArgumentListSyntax.create = function (openParenToken, closeParenToken) { + return new ArgumentListSyntax(null, openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false); + }; + + ArgumentListSyntax.create1 = function () { + return new ArgumentListSyntax(null, TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArgumentListSyntax.prototype.withTypeArgumentList = function (typeArgumentList) { + return this.update(typeArgumentList, this.openParenToken, this.arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.typeArgumentList, openParenToken, this.arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withArguments = function (_arguments) { + return this.update(this.typeArgumentList, this.openParenToken, _arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withArgument = function (_argument) { + return this.withArguments(TypeScript.Syntax.separatedList([_argument])); + }; + + ArgumentListSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.typeArgumentList, this.openParenToken, this.arguments, closeParenToken); + }; + + ArgumentListSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeArgumentList !== null && this.typeArgumentList.isTypeScriptSpecific()) { + return true; + } + if (this.arguments.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ArgumentListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArgumentListSyntax = ArgumentListSyntax; + + var BinaryExpressionSyntax = (function (_super) { + __extends(BinaryExpressionSyntax, _super); + function BinaryExpressionSyntax(kind, left, operatorToken, right, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.left = left; + this.operatorToken = operatorToken; + this.right = right; + + this._kind = kind; + } + BinaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitBinaryExpression(this); + }; + + BinaryExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + BinaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.left; + case 1: + return this.operatorToken; + case 2: + return this.right; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BinaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + BinaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + BinaryExpressionSyntax.prototype.update = function (kind, left, operatorToken, right) { + if (this._kind === kind && this.left === left && this.operatorToken === operatorToken && this.right === right) { + return this; + } + + return new BinaryExpressionSyntax(kind, left, operatorToken, right, this.parsedInStrictMode()); + }; + + BinaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BinaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BinaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.left, this.operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withLeft = function (left) { + return this.update(this._kind, left, this.operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, this.left, operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withRight = function (right) { + return this.update(this._kind, this.left, this.operatorToken, right); + }; + + BinaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.left.isTypeScriptSpecific()) { + return true; + } + if (this.right.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return BinaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BinaryExpressionSyntax = BinaryExpressionSyntax; + + var ConditionalExpressionSyntax = (function (_super) { + __extends(ConditionalExpressionSyntax, _super); + function ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.condition = condition; + this.questionToken = questionToken; + this.whenTrue = whenTrue; + this.colonToken = colonToken; + this.whenFalse = whenFalse; + } + ConditionalExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitConditionalExpression(this); + }; + + ConditionalExpressionSyntax.prototype.kind = function () { + return 186 /* ConditionalExpression */; + }; + + ConditionalExpressionSyntax.prototype.childCount = function () { + return 5; + }; + + ConditionalExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.condition; + case 1: + return this.questionToken; + case 2: + return this.whenTrue; + case 3: + return this.colonToken; + case 4: + return this.whenFalse; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConditionalExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ConditionalExpressionSyntax.prototype.update = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + if (this.condition === condition && this.questionToken === questionToken && this.whenTrue === whenTrue && this.colonToken === colonToken && this.whenFalse === whenFalse) { + return this; + } + + return new ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, this.parsedInStrictMode()); + }; + + ConditionalExpressionSyntax.create1 = function (condition, whenTrue, whenFalse) { + return new ConditionalExpressionSyntax(condition, TypeScript.Syntax.token(105 /* QuestionToken */), whenTrue, TypeScript.Syntax.token(106 /* ColonToken */), whenFalse, false); + }; + + ConditionalExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConditionalExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConditionalExpressionSyntax.prototype.withCondition = function (condition) { + return this.update(condition, this.questionToken, this.whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.condition, questionToken, this.whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withWhenTrue = function (whenTrue) { + return this.update(this.condition, this.questionToken, whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.condition, this.questionToken, this.whenTrue, colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withWhenFalse = function (whenFalse) { + return this.update(this.condition, this.questionToken, this.whenTrue, this.colonToken, whenFalse); + }; + + ConditionalExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.whenTrue.isTypeScriptSpecific()) { + return true; + } + if (this.whenFalse.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ConditionalExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConditionalExpressionSyntax = ConditionalExpressionSyntax; + + var ConstructSignatureSyntax = (function (_super) { + __extends(ConstructSignatureSyntax, _super); + function ConstructSignatureSyntax(newKeyword, callSignature, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.callSignature = callSignature; + } + ConstructSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructSignature(this); + }; + + ConstructSignatureSyntax.prototype.kind = function () { + return 143 /* ConstructSignature */; + }; + + ConstructSignatureSyntax.prototype.childCount = function () { + return 2; + }; + + ConstructSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.callSignature; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + ConstructSignatureSyntax.prototype.update = function (newKeyword, callSignature) { + if (this.newKeyword === newKeyword && this.callSignature === callSignature) { + return this; + } + + return new ConstructSignatureSyntax(newKeyword, callSignature, this.parsedInStrictMode()); + }; + + ConstructSignatureSyntax.create1 = function () { + return new ConstructSignatureSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), CallSignatureSyntax.create1(), false); + }; + + ConstructSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructSignatureSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.callSignature); + }; + + ConstructSignatureSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.newKeyword, callSignature); + }; + + ConstructSignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructSignatureSyntax = ConstructSignatureSyntax; + + var MethodSignatureSyntax = (function (_super) { + __extends(MethodSignatureSyntax, _super); + function MethodSignatureSyntax(propertyName, questionToken, callSignature, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.callSignature = callSignature; + } + MethodSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitMethodSignature(this); + }; + + MethodSignatureSyntax.prototype.kind = function () { + return 145 /* MethodSignature */; + }; + + MethodSignatureSyntax.prototype.childCount = function () { + return 3; + }; + + MethodSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.questionToken; + case 2: + return this.callSignature; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MethodSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + MethodSignatureSyntax.prototype.update = function (propertyName, questionToken, callSignature) { + if (this.propertyName === propertyName && this.questionToken === questionToken && this.callSignature === callSignature) { + return this; + } + + return new MethodSignatureSyntax(propertyName, questionToken, callSignature, this.parsedInStrictMode()); + }; + + MethodSignatureSyntax.create = function (propertyName, callSignature) { + return new MethodSignatureSyntax(propertyName, null, callSignature, false); + }; + + MethodSignatureSyntax.create1 = function (propertyName) { + return new MethodSignatureSyntax(propertyName, null, CallSignatureSyntax.create1(), false); + }; + + MethodSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MethodSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MethodSignatureSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.questionToken, this.callSignature); + }; + + MethodSignatureSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.propertyName, questionToken, this.callSignature); + }; + + MethodSignatureSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.propertyName, this.questionToken, callSignature); + }; + + MethodSignatureSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return MethodSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MethodSignatureSyntax = MethodSignatureSyntax; + + var IndexSignatureSyntax = (function (_super) { + __extends(IndexSignatureSyntax, _super); + function IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBracketToken = openBracketToken; + this.parameter = parameter; + this.closeBracketToken = closeBracketToken; + this.typeAnnotation = typeAnnotation; + } + IndexSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitIndexSignature(this); + }; + + IndexSignatureSyntax.prototype.kind = function () { + return 144 /* IndexSignature */; + }; + + IndexSignatureSyntax.prototype.childCount = function () { + return 4; + }; + + IndexSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBracketToken; + case 1: + return this.parameter; + case 2: + return this.closeBracketToken; + case 3: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IndexSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + IndexSignatureSyntax.prototype.update = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + if (this.openBracketToken === openBracketToken && this.parameter === parameter && this.closeBracketToken === closeBracketToken && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, this.parsedInStrictMode()); + }; + + IndexSignatureSyntax.create = function (openBracketToken, parameter, closeBracketToken) { + return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, null, false); + }; + + IndexSignatureSyntax.create1 = function (parameter) { + return new IndexSignatureSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), parameter, TypeScript.Syntax.token(75 /* CloseBracketToken */), null, false); + }; + + IndexSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IndexSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IndexSignatureSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(openBracketToken, this.parameter, this.closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withParameter = function (parameter) { + return this.update(this.openBracketToken, parameter, this.closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.openBracketToken, this.parameter, closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.openBracketToken, this.parameter, this.closeBracketToken, typeAnnotation); + }; + + IndexSignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return IndexSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IndexSignatureSyntax = IndexSignatureSyntax; + + var PropertySignatureSyntax = (function (_super) { + __extends(PropertySignatureSyntax, _super); + function PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + } + PropertySignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitPropertySignature(this); + }; + + PropertySignatureSyntax.prototype.kind = function () { + return 141 /* PropertySignature */; + }; + + PropertySignatureSyntax.prototype.childCount = function () { + return 3; + }; + + PropertySignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.questionToken; + case 2: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PropertySignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + PropertySignatureSyntax.prototype.update = function (propertyName, questionToken, typeAnnotation) { + if (this.propertyName === propertyName && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, this.parsedInStrictMode()); + }; + + PropertySignatureSyntax.create = function (propertyName) { + return new PropertySignatureSyntax(propertyName, null, null, false); + }; + + PropertySignatureSyntax.create1 = function (propertyName) { + return new PropertySignatureSyntax(propertyName, null, null, false); + }; + + PropertySignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PropertySignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PropertySignatureSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.questionToken, this.typeAnnotation); + }; + + PropertySignatureSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.propertyName, questionToken, this.typeAnnotation); + }; + + PropertySignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.propertyName, this.questionToken, typeAnnotation); + }; + + PropertySignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return PropertySignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PropertySignatureSyntax = PropertySignatureSyntax; + + var CallSignatureSyntax = (function (_super) { + __extends(CallSignatureSyntax, _super); + function CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + } + CallSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitCallSignature(this); + }; + + CallSignatureSyntax.prototype.kind = function () { + return 142 /* CallSignature */; + }; + + CallSignatureSyntax.prototype.childCount = function () { + return 3; + }; + + CallSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeParameterList; + case 1: + return this.parameterList; + case 2: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CallSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + CallSignatureSyntax.prototype.update = function (typeParameterList, parameterList, typeAnnotation) { + if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, this.parsedInStrictMode()); + }; + + CallSignatureSyntax.create = function (parameterList) { + return new CallSignatureSyntax(null, parameterList, null, false); + }; + + CallSignatureSyntax.create1 = function () { + return new CallSignatureSyntax(null, ParameterListSyntax.create1(), null, false); + }; + + CallSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CallSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CallSignatureSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(typeParameterList, this.parameterList, this.typeAnnotation); + }; + + CallSignatureSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.typeParameterList, parameterList, this.typeAnnotation); + }; + + CallSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.typeParameterList, this.parameterList, typeAnnotation); + }; + + CallSignatureSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeParameterList !== null) { + return true; + } + if (this.parameterList.isTypeScriptSpecific()) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + return false; + }; + return CallSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CallSignatureSyntax = CallSignatureSyntax; + + var ParameterListSyntax = (function (_super) { + __extends(ParameterListSyntax, _super); + function ParameterListSyntax(openParenToken, parameters, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openParenToken = openParenToken; + this.parameters = parameters; + this.closeParenToken = closeParenToken; + } + ParameterListSyntax.prototype.accept = function (visitor) { + return visitor.visitParameterList(this); + }; + + ParameterListSyntax.prototype.kind = function () { + return 227 /* ParameterList */; + }; + + ParameterListSyntax.prototype.childCount = function () { + return 3; + }; + + ParameterListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openParenToken; + case 1: + return this.parameters; + case 2: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParameterListSyntax.prototype.update = function (openParenToken, parameters, closeParenToken) { + if (this.openParenToken === openParenToken && this.parameters === parameters && this.closeParenToken === closeParenToken) { + return this; + } + + return new ParameterListSyntax(openParenToken, parameters, closeParenToken, this.parsedInStrictMode()); + }; + + ParameterListSyntax.create = function (openParenToken, closeParenToken) { + return new ParameterListSyntax(openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false); + }; + + ParameterListSyntax.create1 = function () { + return new ParameterListSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ParameterListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParameterListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParameterListSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(openParenToken, this.parameters, this.closeParenToken); + }; + + ParameterListSyntax.prototype.withParameters = function (parameters) { + return this.update(this.openParenToken, parameters, this.closeParenToken); + }; + + ParameterListSyntax.prototype.withParameter = function (parameter) { + return this.withParameters(TypeScript.Syntax.separatedList([parameter])); + }; + + ParameterListSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.openParenToken, this.parameters, closeParenToken); + }; + + ParameterListSyntax.prototype.isTypeScriptSpecific = function () { + if (this.parameters.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ParameterListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParameterListSyntax = ParameterListSyntax; + + var TypeParameterListSyntax = (function (_super) { + __extends(TypeParameterListSyntax, _super); + function TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.typeParameters = typeParameters; + this.greaterThanToken = greaterThanToken; + } + TypeParameterListSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeParameterList(this); + }; + + TypeParameterListSyntax.prototype.kind = function () { + return 229 /* TypeParameterList */; + }; + + TypeParameterListSyntax.prototype.childCount = function () { + return 3; + }; + + TypeParameterListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.typeParameters; + case 2: + return this.greaterThanToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeParameterListSyntax.prototype.update = function (lessThanToken, typeParameters, greaterThanToken) { + if (this.lessThanToken === lessThanToken && this.typeParameters === typeParameters && this.greaterThanToken === greaterThanToken) { + return this; + } + + return new TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, this.parsedInStrictMode()); + }; + + TypeParameterListSyntax.create = function (lessThanToken, greaterThanToken) { + return new TypeParameterListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false); + }; + + TypeParameterListSyntax.create1 = function () { + return new TypeParameterListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false); + }; + + TypeParameterListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeParameterListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeParameterListSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.typeParameters, this.greaterThanToken); + }; + + TypeParameterListSyntax.prototype.withTypeParameters = function (typeParameters) { + return this.update(this.lessThanToken, typeParameters, this.greaterThanToken); + }; + + TypeParameterListSyntax.prototype.withTypeParameter = function (typeParameter) { + return this.withTypeParameters(TypeScript.Syntax.separatedList([typeParameter])); + }; + + TypeParameterListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.typeParameters, greaterThanToken); + }; + + TypeParameterListSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeParameterListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeParameterListSyntax = TypeParameterListSyntax; + + var TypeParameterSyntax = (function (_super) { + __extends(TypeParameterSyntax, _super); + function TypeParameterSyntax(identifier, constraint, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.constraint = constraint; + } + TypeParameterSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeParameter(this); + }; + + TypeParameterSyntax.prototype.kind = function () { + return 238 /* TypeParameter */; + }; + + TypeParameterSyntax.prototype.childCount = function () { + return 2; + }; + + TypeParameterSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.constraint; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeParameterSyntax.prototype.update = function (identifier, constraint) { + if (this.identifier === identifier && this.constraint === constraint) { + return this; + } + + return new TypeParameterSyntax(identifier, constraint, this.parsedInStrictMode()); + }; + + TypeParameterSyntax.create = function (identifier) { + return new TypeParameterSyntax(identifier, null, false); + }; + + TypeParameterSyntax.create1 = function (identifier) { + return new TypeParameterSyntax(identifier, null, false); + }; + + TypeParameterSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeParameterSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeParameterSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.constraint); + }; + + TypeParameterSyntax.prototype.withConstraint = function (constraint) { + return this.update(this.identifier, constraint); + }; + + TypeParameterSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeParameterSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeParameterSyntax = TypeParameterSyntax; + + var ConstraintSyntax = (function (_super) { + __extends(ConstraintSyntax, _super); + function ConstraintSyntax(extendsKeyword, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.extendsKeyword = extendsKeyword; + this.type = type; + } + ConstraintSyntax.prototype.accept = function (visitor) { + return visitor.visitConstraint(this); + }; + + ConstraintSyntax.prototype.kind = function () { + return 239 /* Constraint */; + }; + + ConstraintSyntax.prototype.childCount = function () { + return 2; + }; + + ConstraintSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.extendsKeyword; + case 1: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstraintSyntax.prototype.update = function (extendsKeyword, type) { + if (this.extendsKeyword === extendsKeyword && this.type === type) { + return this; + } + + return new ConstraintSyntax(extendsKeyword, type, this.parsedInStrictMode()); + }; + + ConstraintSyntax.create1 = function (type) { + return new ConstraintSyntax(TypeScript.Syntax.token(48 /* ExtendsKeyword */), type, false); + }; + + ConstraintSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstraintSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstraintSyntax.prototype.withExtendsKeyword = function (extendsKeyword) { + return this.update(extendsKeyword, this.type); + }; + + ConstraintSyntax.prototype.withType = function (type) { + return this.update(this.extendsKeyword, type); + }; + + ConstraintSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstraintSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstraintSyntax = ConstraintSyntax; + + var ElseClauseSyntax = (function (_super) { + __extends(ElseClauseSyntax, _super); + function ElseClauseSyntax(elseKeyword, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.elseKeyword = elseKeyword; + this.statement = statement; + } + ElseClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitElseClause(this); + }; + + ElseClauseSyntax.prototype.kind = function () { + return 235 /* ElseClause */; + }; + + ElseClauseSyntax.prototype.childCount = function () { + return 2; + }; + + ElseClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.elseKeyword; + case 1: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ElseClauseSyntax.prototype.update = function (elseKeyword, statement) { + if (this.elseKeyword === elseKeyword && this.statement === statement) { + return this; + } + + return new ElseClauseSyntax(elseKeyword, statement, this.parsedInStrictMode()); + }; + + ElseClauseSyntax.create1 = function (statement) { + return new ElseClauseSyntax(TypeScript.Syntax.token(23 /* ElseKeyword */), statement, false); + }; + + ElseClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ElseClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ElseClauseSyntax.prototype.withElseKeyword = function (elseKeyword) { + return this.update(elseKeyword, this.statement); + }; + + ElseClauseSyntax.prototype.withStatement = function (statement) { + return this.update(this.elseKeyword, statement); + }; + + ElseClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ElseClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ElseClauseSyntax = ElseClauseSyntax; + + var IfStatementSyntax = (function (_super) { + __extends(IfStatementSyntax, _super); + function IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.ifKeyword = ifKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + this.elseClause = elseClause; + } + IfStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitIfStatement(this); + }; + + IfStatementSyntax.prototype.kind = function () { + return 147 /* IfStatement */; + }; + + IfStatementSyntax.prototype.childCount = function () { + return 6; + }; + + IfStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.ifKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + case 5: + return this.elseClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IfStatementSyntax.prototype.isStatement = function () { + return true; + }; + + IfStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + IfStatementSyntax.prototype.update = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + if (this.ifKeyword === ifKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement && this.elseClause === elseClause) { + return this; + } + + return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, this.parsedInStrictMode()); + }; + + IfStatementSyntax.create = function (ifKeyword, openParenToken, condition, closeParenToken, statement) { + return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, null, false); + }; + + IfStatementSyntax.create1 = function (condition, statement) { + return new IfStatementSyntax(TypeScript.Syntax.token(28 /* IfKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, null, false); + }; + + IfStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IfStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IfStatementSyntax.prototype.withIfKeyword = function (ifKeyword) { + return this.update(ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.ifKeyword, openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.ifKeyword, this.openParenToken, condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withElseClause = function (elseClause) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, elseClause); + }; + + IfStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + if (this.elseClause !== null && this.elseClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return IfStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IfStatementSyntax = IfStatementSyntax; + + var ExpressionStatementSyntax = (function (_super) { + __extends(ExpressionStatementSyntax, _super); + function ExpressionStatementSyntax(expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ExpressionStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitExpressionStatement(this); + }; + + ExpressionStatementSyntax.prototype.kind = function () { + return 149 /* ExpressionStatement */; + }; + + ExpressionStatementSyntax.prototype.childCount = function () { + return 2; + }; + + ExpressionStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExpressionStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ExpressionStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ExpressionStatementSyntax.prototype.update = function (expression, semicolonToken) { + if (this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ExpressionStatementSyntax(expression, semicolonToken, this.parsedInStrictMode()); + }; + + ExpressionStatementSyntax.create1 = function (expression) { + return new ExpressionStatementSyntax(expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ExpressionStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExpressionStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExpressionStatementSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.semicolonToken); + }; + + ExpressionStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.expression, semicolonToken); + }; + + ExpressionStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ExpressionStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExpressionStatementSyntax = ExpressionStatementSyntax; + + var ConstructorDeclarationSyntax = (function (_super) { + __extends(ConstructorDeclarationSyntax, _super); + function ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.constructorKeyword = constructorKeyword; + this.parameterList = parameterList; + this.block = block; + this.semicolonToken = semicolonToken; + } + ConstructorDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructorDeclaration(this); + }; + + ConstructorDeclarationSyntax.prototype.kind = function () { + return 137 /* ConstructorDeclaration */; + }; + + ConstructorDeclarationSyntax.prototype.childCount = function () { + return 5; + }; + + ConstructorDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.constructorKeyword; + case 2: + return this.parameterList; + case 3: + return this.block; + case 4: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructorDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + ConstructorDeclarationSyntax.prototype.update = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + if (this.modifiers === modifiers && this.constructorKeyword === constructorKeyword && this.parameterList === parameterList && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, this.parsedInStrictMode()); + }; + + ConstructorDeclarationSyntax.create = function (constructorKeyword, parameterList) { + return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, constructorKeyword, parameterList, null, null, false); + }; + + ConstructorDeclarationSyntax.create1 = function () { + return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(62 /* ConstructorKeyword */), ParameterListSyntax.create1(), null, null, false); + }; + + ConstructorDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructorDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructorDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.constructorKeyword, this.parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ConstructorDeclarationSyntax.prototype.withConstructorKeyword = function (constructorKeyword) { + return this.update(this.modifiers, constructorKeyword, this.parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.constructorKeyword, parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.constructorKeyword, this.parameterList, block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.constructorKeyword, this.parameterList, this.block, semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructorDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructorDeclarationSyntax = ConstructorDeclarationSyntax; + + var MemberFunctionDeclarationSyntax = (function (_super) { + __extends(MemberFunctionDeclarationSyntax, _super); + function MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + } + MemberFunctionDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberFunctionDeclaration(this); + }; + + MemberFunctionDeclarationSyntax.prototype.kind = function () { + return 135 /* MemberFunctionDeclaration */; + }; + + MemberFunctionDeclarationSyntax.prototype.childCount = function () { + return 5; + }; + + MemberFunctionDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.propertyName; + case 2: + return this.callSignature; + case 3: + return this.block; + case 4: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberFunctionDeclarationSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + MemberFunctionDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + MemberFunctionDeclarationSyntax.prototype.update = function (modifiers, propertyName, callSignature, block, semicolonToken) { + if (this.modifiers === modifiers && this.propertyName === propertyName && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, this.parsedInStrictMode()); + }; + + MemberFunctionDeclarationSyntax.create = function (propertyName, callSignature) { + return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, callSignature, null, null, false); + }; + + MemberFunctionDeclarationSyntax.create1 = function (propertyName) { + return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, CallSignatureSyntax.create1(), null, null, false); + }; + + MemberFunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberFunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberFunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.propertyName, this.callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + MemberFunctionDeclarationSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, propertyName, this.callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.modifiers, this.propertyName, callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.propertyName, this.callSignature, block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.propertyName, this.callSignature, this.block, semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return MemberFunctionDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberFunctionDeclarationSyntax = MemberFunctionDeclarationSyntax; + + var GetAccessorSyntax = (function (_super) { + __extends(GetAccessorSyntax, _super); + function GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.getKeyword = getKeyword; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + this.block = block; + } + GetAccessorSyntax.prototype.accept = function (visitor) { + return visitor.visitGetAccessor(this); + }; + + GetAccessorSyntax.prototype.kind = function () { + return 139 /* GetAccessor */; + }; + + GetAccessorSyntax.prototype.childCount = function () { + return 6; + }; + + GetAccessorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.getKeyword; + case 2: + return this.propertyName; + case 3: + return this.parameterList; + case 4: + return this.typeAnnotation; + case 5: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + GetAccessorSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + GetAccessorSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + GetAccessorSyntax.prototype.isClassElement = function () { + return true; + }; + + GetAccessorSyntax.prototype.update = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + if (this.modifiers === modifiers && this.getKeyword === getKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation && this.block === block) { + return this; + } + + return new GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, this.parsedInStrictMode()); + }; + + GetAccessorSyntax.create = function (getKeyword, propertyName, parameterList, block) { + return new GetAccessorSyntax(TypeScript.Syntax.emptyList, getKeyword, propertyName, parameterList, null, block, false); + }; + + GetAccessorSyntax.create1 = function (propertyName) { + return new GetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(64 /* GetKeyword */), propertyName, ParameterListSyntax.create1(), null, BlockSyntax.create1(), false); + }; + + GetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + GetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + GetAccessorSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + GetAccessorSyntax.prototype.withGetKeyword = function (getKeyword) { + return this.update(this.modifiers, getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, this.getKeyword, propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, block); + }; + + GetAccessorSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.parameterList.isTypeScriptSpecific()) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return GetAccessorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.GetAccessorSyntax = GetAccessorSyntax; + + var SetAccessorSyntax = (function (_super) { + __extends(SetAccessorSyntax, _super); + function SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.setKeyword = setKeyword; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.block = block; + } + SetAccessorSyntax.prototype.accept = function (visitor) { + return visitor.visitSetAccessor(this); + }; + + SetAccessorSyntax.prototype.kind = function () { + return 140 /* SetAccessor */; + }; + + SetAccessorSyntax.prototype.childCount = function () { + return 5; + }; + + SetAccessorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.setKeyword; + case 2: + return this.propertyName; + case 3: + return this.parameterList; + case 4: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SetAccessorSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + SetAccessorSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + SetAccessorSyntax.prototype.isClassElement = function () { + return true; + }; + + SetAccessorSyntax.prototype.update = function (modifiers, setKeyword, propertyName, parameterList, block) { + if (this.modifiers === modifiers && this.setKeyword === setKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.block === block) { + return this; + } + + return new SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, this.parsedInStrictMode()); + }; + + SetAccessorSyntax.create = function (setKeyword, propertyName, parameterList, block) { + return new SetAccessorSyntax(TypeScript.Syntax.emptyList, setKeyword, propertyName, parameterList, block, false); + }; + + SetAccessorSyntax.create1 = function (propertyName) { + return new SetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(68 /* SetKeyword */), propertyName, ParameterListSyntax.create1(), BlockSyntax.create1(), false); + }; + + SetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SetAccessorSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.setKeyword, this.propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + SetAccessorSyntax.prototype.withSetKeyword = function (setKeyword) { + return this.update(this.modifiers, setKeyword, this.propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, this.setKeyword, propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.setKeyword, this.propertyName, parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.setKeyword, this.propertyName, this.parameterList, block); + }; + + SetAccessorSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return SetAccessorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SetAccessorSyntax = SetAccessorSyntax; + + var MemberVariableDeclarationSyntax = (function (_super) { + __extends(MemberVariableDeclarationSyntax, _super); + function MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.variableDeclarator = variableDeclarator; + this.semicolonToken = semicolonToken; + } + MemberVariableDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberVariableDeclaration(this); + }; + + MemberVariableDeclarationSyntax.prototype.kind = function () { + return 136 /* MemberVariableDeclaration */; + }; + + MemberVariableDeclarationSyntax.prototype.childCount = function () { + return 3; + }; + + MemberVariableDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.variableDeclarator; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberVariableDeclarationSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + MemberVariableDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + MemberVariableDeclarationSyntax.prototype.update = function (modifiers, variableDeclarator, semicolonToken) { + if (this.modifiers === modifiers && this.variableDeclarator === variableDeclarator && this.semicolonToken === semicolonToken) { + return this; + } + + return new MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, this.parsedInStrictMode()); + }; + + MemberVariableDeclarationSyntax.create = function (variableDeclarator, semicolonToken) { + return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, semicolonToken, false); + }; + + MemberVariableDeclarationSyntax.create1 = function (variableDeclarator) { + return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + MemberVariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberVariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberVariableDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.variableDeclarator, this.semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + MemberVariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) { + return this.update(this.modifiers, variableDeclarator, this.semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.variableDeclarator, semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return MemberVariableDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberVariableDeclarationSyntax = MemberVariableDeclarationSyntax; + + var IndexMemberDeclarationSyntax = (function (_super) { + __extends(IndexMemberDeclarationSyntax, _super); + function IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.indexSignature = indexSignature; + this.semicolonToken = semicolonToken; + } + IndexMemberDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitIndexMemberDeclaration(this); + }; + + IndexMemberDeclarationSyntax.prototype.kind = function () { + return 138 /* IndexMemberDeclaration */; + }; + + IndexMemberDeclarationSyntax.prototype.childCount = function () { + return 3; + }; + + IndexMemberDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.indexSignature; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IndexMemberDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + IndexMemberDeclarationSyntax.prototype.update = function (modifiers, indexSignature, semicolonToken) { + if (this.modifiers === modifiers && this.indexSignature === indexSignature && this.semicolonToken === semicolonToken) { + return this; + } + + return new IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, this.parsedInStrictMode()); + }; + + IndexMemberDeclarationSyntax.create = function (indexSignature, semicolonToken) { + return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, semicolonToken, false); + }; + + IndexMemberDeclarationSyntax.create1 = function (indexSignature) { + return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + IndexMemberDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IndexMemberDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IndexMemberDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.indexSignature, this.semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + IndexMemberDeclarationSyntax.prototype.withIndexSignature = function (indexSignature) { + return this.update(this.modifiers, indexSignature, this.semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.indexSignature, semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return IndexMemberDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IndexMemberDeclarationSyntax = IndexMemberDeclarationSyntax; + + var ThrowStatementSyntax = (function (_super) { + __extends(ThrowStatementSyntax, _super); + function ThrowStatementSyntax(throwKeyword, expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.throwKeyword = throwKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ThrowStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitThrowStatement(this); + }; + + ThrowStatementSyntax.prototype.kind = function () { + return 157 /* ThrowStatement */; + }; + + ThrowStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ThrowStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.throwKeyword; + case 1: + return this.expression; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ThrowStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ThrowStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ThrowStatementSyntax.prototype.update = function (throwKeyword, expression, semicolonToken) { + if (this.throwKeyword === throwKeyword && this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ThrowStatementSyntax(throwKeyword, expression, semicolonToken, this.parsedInStrictMode()); + }; + + ThrowStatementSyntax.create1 = function (expression) { + return new ThrowStatementSyntax(TypeScript.Syntax.token(36 /* ThrowKeyword */), expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ThrowStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ThrowStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ThrowStatementSyntax.prototype.withThrowKeyword = function (throwKeyword) { + return this.update(throwKeyword, this.expression, this.semicolonToken); + }; + + ThrowStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.throwKeyword, expression, this.semicolonToken); + }; + + ThrowStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.throwKeyword, this.expression, semicolonToken); + }; + + ThrowStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ThrowStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ThrowStatementSyntax = ThrowStatementSyntax; + + var ReturnStatementSyntax = (function (_super) { + __extends(ReturnStatementSyntax, _super); + function ReturnStatementSyntax(returnKeyword, expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.returnKeyword = returnKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ReturnStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitReturnStatement(this); + }; + + ReturnStatementSyntax.prototype.kind = function () { + return 150 /* ReturnStatement */; + }; + + ReturnStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ReturnStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.returnKeyword; + case 1: + return this.expression; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ReturnStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ReturnStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ReturnStatementSyntax.prototype.update = function (returnKeyword, expression, semicolonToken) { + if (this.returnKeyword === returnKeyword && this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ReturnStatementSyntax(returnKeyword, expression, semicolonToken, this.parsedInStrictMode()); + }; + + ReturnStatementSyntax.create = function (returnKeyword, semicolonToken) { + return new ReturnStatementSyntax(returnKeyword, null, semicolonToken, false); + }; + + ReturnStatementSyntax.create1 = function () { + return new ReturnStatementSyntax(TypeScript.Syntax.token(33 /* ReturnKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ReturnStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ReturnStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ReturnStatementSyntax.prototype.withReturnKeyword = function (returnKeyword) { + return this.update(returnKeyword, this.expression, this.semicolonToken); + }; + + ReturnStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.returnKeyword, expression, this.semicolonToken); + }; + + ReturnStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.returnKeyword, this.expression, semicolonToken); + }; + + ReturnStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression !== null && this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ReturnStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ReturnStatementSyntax = ReturnStatementSyntax; + + var ObjectCreationExpressionSyntax = (function (_super) { + __extends(ObjectCreationExpressionSyntax, _super); + function ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.expression = expression; + this.argumentList = argumentList; + } + ObjectCreationExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectCreationExpression(this); + }; + + ObjectCreationExpressionSyntax.prototype.kind = function () { + return 216 /* ObjectCreationExpression */; + }; + + ObjectCreationExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectCreationExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.expression; + case 2: + return this.argumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectCreationExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.update = function (newKeyword, expression, argumentList) { + if (this.newKeyword === newKeyword && this.expression === expression && this.argumentList === argumentList) { + return this; + } + + return new ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, this.parsedInStrictMode()); + }; + + ObjectCreationExpressionSyntax.create = function (newKeyword, expression) { + return new ObjectCreationExpressionSyntax(newKeyword, expression, null, false); + }; + + ObjectCreationExpressionSyntax.create1 = function (expression) { + return new ObjectCreationExpressionSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), expression, null, false); + }; + + ObjectCreationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectCreationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectCreationExpressionSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.expression, this.argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.newKeyword, expression, this.argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.withArgumentList = function (argumentList) { + return this.update(this.newKeyword, this.expression, argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentList !== null && this.argumentList.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ObjectCreationExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectCreationExpressionSyntax = ObjectCreationExpressionSyntax; + + var SwitchStatementSyntax = (function (_super) { + __extends(SwitchStatementSyntax, _super); + function SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.switchKeyword = switchKeyword; + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.openBraceToken = openBraceToken; + this.switchClauses = switchClauses; + this.closeBraceToken = closeBraceToken; + } + SwitchStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitSwitchStatement(this); + }; + + SwitchStatementSyntax.prototype.kind = function () { + return 151 /* SwitchStatement */; + }; + + SwitchStatementSyntax.prototype.childCount = function () { + return 7; + }; + + SwitchStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.switchKeyword; + case 1: + return this.openParenToken; + case 2: + return this.expression; + case 3: + return this.closeParenToken; + case 4: + return this.openBraceToken; + case 5: + return this.switchClauses; + case 6: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SwitchStatementSyntax.prototype.isStatement = function () { + return true; + }; + + SwitchStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + SwitchStatementSyntax.prototype.update = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + if (this.switchKeyword === switchKeyword && this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken && this.openBraceToken === openBraceToken && this.switchClauses === switchClauses && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, this.parsedInStrictMode()); + }; + + SwitchStatementSyntax.create = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, closeBraceToken) { + return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + SwitchStatementSyntax.create1 = function (expression) { + return new SwitchStatementSyntax(TypeScript.Syntax.token(34 /* SwitchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + SwitchStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SwitchStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SwitchStatementSyntax.prototype.withSwitchKeyword = function (switchKeyword) { + return this.update(switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.switchKeyword, openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.switchKeyword, this.openParenToken, expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withSwitchClauses = function (switchClauses) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withSwitchClause = function (switchClause) { + return this.withSwitchClauses(TypeScript.Syntax.list([switchClause])); + }; + + SwitchStatementSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, closeBraceToken); + }; + + SwitchStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.switchClauses.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SwitchStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SwitchStatementSyntax = SwitchStatementSyntax; + + var CaseSwitchClauseSyntax = (function (_super) { + __extends(CaseSwitchClauseSyntax, _super); + function CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.caseKeyword = caseKeyword; + this.expression = expression; + this.colonToken = colonToken; + this.statements = statements; + } + CaseSwitchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitCaseSwitchClause(this); + }; + + CaseSwitchClauseSyntax.prototype.kind = function () { + return 233 /* CaseSwitchClause */; + }; + + CaseSwitchClauseSyntax.prototype.childCount = function () { + return 4; + }; + + CaseSwitchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.caseKeyword; + case 1: + return this.expression; + case 2: + return this.colonToken; + case 3: + return this.statements; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CaseSwitchClauseSyntax.prototype.isSwitchClause = function () { + return true; + }; + + CaseSwitchClauseSyntax.prototype.update = function (caseKeyword, expression, colonToken, statements) { + if (this.caseKeyword === caseKeyword && this.expression === expression && this.colonToken === colonToken && this.statements === statements) { + return this; + } + + return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, this.parsedInStrictMode()); + }; + + CaseSwitchClauseSyntax.create = function (caseKeyword, expression, colonToken) { + return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, TypeScript.Syntax.emptyList, false); + }; + + CaseSwitchClauseSyntax.create1 = function (expression) { + return new CaseSwitchClauseSyntax(TypeScript.Syntax.token(16 /* CaseKeyword */), expression, TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false); + }; + + CaseSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CaseSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CaseSwitchClauseSyntax.prototype.withCaseKeyword = function (caseKeyword) { + return this.update(caseKeyword, this.expression, this.colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withExpression = function (expression) { + return this.update(this.caseKeyword, expression, this.colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.caseKeyword, this.expression, colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withStatements = function (statements) { + return this.update(this.caseKeyword, this.expression, this.colonToken, statements); + }; + + CaseSwitchClauseSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + CaseSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return CaseSwitchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CaseSwitchClauseSyntax = CaseSwitchClauseSyntax; + + var DefaultSwitchClauseSyntax = (function (_super) { + __extends(DefaultSwitchClauseSyntax, _super); + function DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.defaultKeyword = defaultKeyword; + this.colonToken = colonToken; + this.statements = statements; + } + DefaultSwitchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitDefaultSwitchClause(this); + }; + + DefaultSwitchClauseSyntax.prototype.kind = function () { + return 234 /* DefaultSwitchClause */; + }; + + DefaultSwitchClauseSyntax.prototype.childCount = function () { + return 3; + }; + + DefaultSwitchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.defaultKeyword; + case 1: + return this.colonToken; + case 2: + return this.statements; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DefaultSwitchClauseSyntax.prototype.isSwitchClause = function () { + return true; + }; + + DefaultSwitchClauseSyntax.prototype.update = function (defaultKeyword, colonToken, statements) { + if (this.defaultKeyword === defaultKeyword && this.colonToken === colonToken && this.statements === statements) { + return this; + } + + return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, this.parsedInStrictMode()); + }; + + DefaultSwitchClauseSyntax.create = function (defaultKeyword, colonToken) { + return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, TypeScript.Syntax.emptyList, false); + }; + + DefaultSwitchClauseSyntax.create1 = function () { + return new DefaultSwitchClauseSyntax(TypeScript.Syntax.token(20 /* DefaultKeyword */), TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false); + }; + + DefaultSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DefaultSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DefaultSwitchClauseSyntax.prototype.withDefaultKeyword = function (defaultKeyword) { + return this.update(defaultKeyword, this.colonToken, this.statements); + }; + + DefaultSwitchClauseSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.defaultKeyword, colonToken, this.statements); + }; + + DefaultSwitchClauseSyntax.prototype.withStatements = function (statements) { + return this.update(this.defaultKeyword, this.colonToken, statements); + }; + + DefaultSwitchClauseSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + DefaultSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DefaultSwitchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DefaultSwitchClauseSyntax = DefaultSwitchClauseSyntax; + + var BreakStatementSyntax = (function (_super) { + __extends(BreakStatementSyntax, _super); + function BreakStatementSyntax(breakKeyword, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.breakKeyword = breakKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + BreakStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitBreakStatement(this); + }; + + BreakStatementSyntax.prototype.kind = function () { + return 152 /* BreakStatement */; + }; + + BreakStatementSyntax.prototype.childCount = function () { + return 3; + }; + + BreakStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.breakKeyword; + case 1: + return this.identifier; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BreakStatementSyntax.prototype.isStatement = function () { + return true; + }; + + BreakStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + BreakStatementSyntax.prototype.update = function (breakKeyword, identifier, semicolonToken) { + if (this.breakKeyword === breakKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new BreakStatementSyntax(breakKeyword, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + BreakStatementSyntax.create = function (breakKeyword, semicolonToken) { + return new BreakStatementSyntax(breakKeyword, null, semicolonToken, false); + }; + + BreakStatementSyntax.create1 = function () { + return new BreakStatementSyntax(TypeScript.Syntax.token(15 /* BreakKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + BreakStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BreakStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BreakStatementSyntax.prototype.withBreakKeyword = function (breakKeyword) { + return this.update(breakKeyword, this.identifier, this.semicolonToken); + }; + + BreakStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.breakKeyword, identifier, this.semicolonToken); + }; + + BreakStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.breakKeyword, this.identifier, semicolonToken); + }; + + BreakStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return BreakStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BreakStatementSyntax = BreakStatementSyntax; + + var ContinueStatementSyntax = (function (_super) { + __extends(ContinueStatementSyntax, _super); + function ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.continueKeyword = continueKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + ContinueStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitContinueStatement(this); + }; + + ContinueStatementSyntax.prototype.kind = function () { + return 153 /* ContinueStatement */; + }; + + ContinueStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ContinueStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.continueKeyword; + case 1: + return this.identifier; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ContinueStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ContinueStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ContinueStatementSyntax.prototype.update = function (continueKeyword, identifier, semicolonToken) { + if (this.continueKeyword === continueKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + ContinueStatementSyntax.create = function (continueKeyword, semicolonToken) { + return new ContinueStatementSyntax(continueKeyword, null, semicolonToken, false); + }; + + ContinueStatementSyntax.create1 = function () { + return new ContinueStatementSyntax(TypeScript.Syntax.token(18 /* ContinueKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ContinueStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ContinueStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ContinueStatementSyntax.prototype.withContinueKeyword = function (continueKeyword) { + return this.update(continueKeyword, this.identifier, this.semicolonToken); + }; + + ContinueStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.continueKeyword, identifier, this.semicolonToken); + }; + + ContinueStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.continueKeyword, this.identifier, semicolonToken); + }; + + ContinueStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return ContinueStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ContinueStatementSyntax = ContinueStatementSyntax; + + var ForStatementSyntax = (function (_super) { + __extends(ForStatementSyntax, _super); + function ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.initializer = initializer; + this.firstSemicolonToken = firstSemicolonToken; + this.condition = condition; + this.secondSemicolonToken = secondSemicolonToken; + this.incrementor = incrementor; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + ForStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitForStatement(this); + }; + + ForStatementSyntax.prototype.kind = function () { + return 154 /* ForStatement */; + }; + + ForStatementSyntax.prototype.childCount = function () { + return 10; + }; + + ForStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.forKeyword; + case 1: + return this.openParenToken; + case 2: + return this.variableDeclaration; + case 3: + return this.initializer; + case 4: + return this.firstSemicolonToken; + case 5: + return this.condition; + case 6: + return this.secondSemicolonToken; + case 7: + return this.incrementor; + case 8: + return this.closeParenToken; + case 9: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ForStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + ForStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ForStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ForStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.initializer === initializer && this.firstSemicolonToken === firstSemicolonToken && this.condition === condition && this.secondSemicolonToken === secondSemicolonToken && this.incrementor === incrementor && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, this.parsedInStrictMode()); + }; + + ForStatementSyntax.create = function (forKeyword, openParenToken, firstSemicolonToken, secondSemicolonToken, closeParenToken, statement) { + return new ForStatementSyntax(forKeyword, openParenToken, null, null, firstSemicolonToken, null, secondSemicolonToken, null, closeParenToken, statement, false); + }; + + ForStatementSyntax.create1 = function (statement) { + return new ForStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + ForStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ForStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ForStatementSyntax.prototype.withForKeyword = function (forKeyword) { + return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withInitializer = function (initializer) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withFirstSemicolonToken = function (firstSemicolonToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withSecondSemicolonToken = function (secondSemicolonToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withIncrementor = function (incrementor) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, statement); + }; + + ForStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + if (this.initializer !== null && this.initializer.isTypeScriptSpecific()) { + return true; + } + if (this.condition !== null && this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.incrementor !== null && this.incrementor.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ForStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ForStatementSyntax = ForStatementSyntax; + + var ForInStatementSyntax = (function (_super) { + __extends(ForInStatementSyntax, _super); + function ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.left = left; + this.inKeyword = inKeyword; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + ForInStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitForInStatement(this); + }; + + ForInStatementSyntax.prototype.kind = function () { + return 155 /* ForInStatement */; + }; + + ForInStatementSyntax.prototype.childCount = function () { + return 8; + }; + + ForInStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.forKeyword; + case 1: + return this.openParenToken; + case 2: + return this.variableDeclaration; + case 3: + return this.left; + case 4: + return this.inKeyword; + case 5: + return this.expression; + case 6: + return this.closeParenToken; + case 7: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ForInStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + ForInStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ForInStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ForInStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.left === left && this.inKeyword === inKeyword && this.expression === expression && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, this.parsedInStrictMode()); + }; + + ForInStatementSyntax.create = function (forKeyword, openParenToken, inKeyword, expression, closeParenToken, statement) { + return new ForInStatementSyntax(forKeyword, openParenToken, null, null, inKeyword, expression, closeParenToken, statement, false); + }; + + ForInStatementSyntax.create1 = function (expression, statement) { + return new ForInStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(29 /* InKeyword */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + ForInStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ForInStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ForInStatementSyntax.prototype.withForKeyword = function (forKeyword) { + return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withLeft = function (left) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withInKeyword = function (inKeyword) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, statement); + }; + + ForInStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + if (this.left !== null && this.left.isTypeScriptSpecific()) { + return true; + } + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ForInStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ForInStatementSyntax = ForInStatementSyntax; + + var WhileStatementSyntax = (function (_super) { + __extends(WhileStatementSyntax, _super); + function WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + WhileStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitWhileStatement(this); + }; + + WhileStatementSyntax.prototype.kind = function () { + return 158 /* WhileStatement */; + }; + + WhileStatementSyntax.prototype.childCount = function () { + return 5; + }; + + WhileStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.whileKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + WhileStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + WhileStatementSyntax.prototype.isStatement = function () { + return true; + }; + + WhileStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + WhileStatementSyntax.prototype.update = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + if (this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode()); + }; + + WhileStatementSyntax.create1 = function (condition, statement) { + return new WhileStatementSyntax(TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + WhileStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + WhileStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + WhileStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) { + return this.update(whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, statement); + }; + + WhileStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return WhileStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.WhileStatementSyntax = WhileStatementSyntax; + + var WithStatementSyntax = (function (_super) { + __extends(WithStatementSyntax, _super); + function WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.withKeyword = withKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + WithStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitWithStatement(this); + }; + + WithStatementSyntax.prototype.kind = function () { + return 163 /* WithStatement */; + }; + + WithStatementSyntax.prototype.childCount = function () { + return 5; + }; + + WithStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.withKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + WithStatementSyntax.prototype.isStatement = function () { + return true; + }; + + WithStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + WithStatementSyntax.prototype.update = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + if (this.withKeyword === withKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode()); + }; + + WithStatementSyntax.create1 = function (condition, statement) { + return new WithStatementSyntax(TypeScript.Syntax.token(43 /* WithKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + WithStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + WithStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + WithStatementSyntax.prototype.withWithKeyword = function (withKeyword) { + return this.update(withKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.withKeyword, openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.withKeyword, this.openParenToken, condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.withKeyword, this.openParenToken, this.condition, closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.withKeyword, this.openParenToken, this.condition, this.closeParenToken, statement); + }; + + WithStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return WithStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.WithStatementSyntax = WithStatementSyntax; + + var EnumDeclarationSyntax = (function (_super) { + __extends(EnumDeclarationSyntax, _super); + function EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.enumKeyword = enumKeyword; + this.identifier = identifier; + this.openBraceToken = openBraceToken; + this.enumElements = enumElements; + this.closeBraceToken = closeBraceToken; + } + EnumDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitEnumDeclaration(this); + }; + + EnumDeclarationSyntax.prototype.kind = function () { + return 132 /* EnumDeclaration */; + }; + + EnumDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + EnumDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.enumKeyword; + case 2: + return this.identifier; + case 3: + return this.openBraceToken; + case 4: + return this.enumElements; + case 5: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EnumDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + EnumDeclarationSyntax.prototype.update = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + if (this.modifiers === modifiers && this.enumKeyword === enumKeyword && this.identifier === identifier && this.openBraceToken === openBraceToken && this.enumElements === enumElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, this.parsedInStrictMode()); + }; + + EnumDeclarationSyntax.create = function (enumKeyword, identifier, openBraceToken, closeBraceToken) { + return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, enumKeyword, identifier, openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + EnumDeclarationSyntax.create1 = function (identifier) { + return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(46 /* EnumKeyword */), identifier, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + EnumDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EnumDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EnumDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + EnumDeclarationSyntax.prototype.withEnumKeyword = function (enumKeyword) { + return this.update(this.modifiers, enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.enumKeyword, identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withEnumElements = function (enumElements) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withEnumElement = function (enumElement) { + return this.withEnumElements(TypeScript.Syntax.separatedList([enumElement])); + }; + + EnumDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return EnumDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EnumDeclarationSyntax = EnumDeclarationSyntax; + + var EnumElementSyntax = (function (_super) { + __extends(EnumElementSyntax, _super); + function EnumElementSyntax(propertyName, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.equalsValueClause = equalsValueClause; + } + EnumElementSyntax.prototype.accept = function (visitor) { + return visitor.visitEnumElement(this); + }; + + EnumElementSyntax.prototype.kind = function () { + return 243 /* EnumElement */; + }; + + EnumElementSyntax.prototype.childCount = function () { + return 2; + }; + + EnumElementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EnumElementSyntax.prototype.update = function (propertyName, equalsValueClause) { + if (this.propertyName === propertyName && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new EnumElementSyntax(propertyName, equalsValueClause, this.parsedInStrictMode()); + }; + + EnumElementSyntax.create = function (propertyName) { + return new EnumElementSyntax(propertyName, null, false); + }; + + EnumElementSyntax.create1 = function (propertyName) { + return new EnumElementSyntax(propertyName, null, false); + }; + + EnumElementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EnumElementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EnumElementSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.equalsValueClause); + }; + + EnumElementSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.propertyName, equalsValueClause); + }; + + EnumElementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return EnumElementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EnumElementSyntax = EnumElementSyntax; + + var CastExpressionSyntax = (function (_super) { + __extends(CastExpressionSyntax, _super); + function CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.type = type; + this.greaterThanToken = greaterThanToken; + this.expression = expression; + } + CastExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitCastExpression(this); + }; + + CastExpressionSyntax.prototype.kind = function () { + return 220 /* CastExpression */; + }; + + CastExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + CastExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.type; + case 2: + return this.greaterThanToken; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CastExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + CastExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + CastExpressionSyntax.prototype.update = function (lessThanToken, type, greaterThanToken, expression) { + if (this.lessThanToken === lessThanToken && this.type === type && this.greaterThanToken === greaterThanToken && this.expression === expression) { + return this; + } + + return new CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, this.parsedInStrictMode()); + }; + + CastExpressionSyntax.create1 = function (type, expression) { + return new CastExpressionSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), type, TypeScript.Syntax.token(81 /* GreaterThanToken */), expression, false); + }; + + CastExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CastExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CastExpressionSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.type, this.greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withType = function (type) { + return this.update(this.lessThanToken, type, this.greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.type, greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.lessThanToken, this.type, this.greaterThanToken, expression); + }; + + CastExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return CastExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CastExpressionSyntax = CastExpressionSyntax; + + var ObjectLiteralExpressionSyntax = (function (_super) { + __extends(ObjectLiteralExpressionSyntax, _super); + function ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.propertyAssignments = propertyAssignments; + this.closeBraceToken = closeBraceToken; + } + ObjectLiteralExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectLiteralExpression(this); + }; + + ObjectLiteralExpressionSyntax.prototype.kind = function () { + return 215 /* ObjectLiteralExpression */; + }; + + ObjectLiteralExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectLiteralExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.propertyAssignments; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectLiteralExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.update = function (openBraceToken, propertyAssignments, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.propertyAssignments === propertyAssignments && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, this.parsedInStrictMode()); + }; + + ObjectLiteralExpressionSyntax.create = function (openBraceToken, closeBraceToken) { + return new ObjectLiteralExpressionSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + ObjectLiteralExpressionSyntax.create1 = function () { + return new ObjectLiteralExpressionSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ObjectLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectLiteralExpressionSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.propertyAssignments, this.closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.withPropertyAssignments = function (propertyAssignments) { + return this.update(this.openBraceToken, propertyAssignments, this.closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.withPropertyAssignment = function (propertyAssignment) { + return this.withPropertyAssignments(TypeScript.Syntax.separatedList([propertyAssignment])); + }; + + ObjectLiteralExpressionSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.propertyAssignments, closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.propertyAssignments.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ObjectLiteralExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectLiteralExpressionSyntax = ObjectLiteralExpressionSyntax; + + var SimplePropertyAssignmentSyntax = (function (_super) { + __extends(SimplePropertyAssignmentSyntax, _super); + function SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.colonToken = colonToken; + this.expression = expression; + } + SimplePropertyAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitSimplePropertyAssignment(this); + }; + + SimplePropertyAssignmentSyntax.prototype.kind = function () { + return 240 /* SimplePropertyAssignment */; + }; + + SimplePropertyAssignmentSyntax.prototype.childCount = function () { + return 3; + }; + + SimplePropertyAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.colonToken; + case 2: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SimplePropertyAssignmentSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + SimplePropertyAssignmentSyntax.prototype.update = function (propertyName, colonToken, expression) { + if (this.propertyName === propertyName && this.colonToken === colonToken && this.expression === expression) { + return this; + } + + return new SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, this.parsedInStrictMode()); + }; + + SimplePropertyAssignmentSyntax.create1 = function (propertyName, expression) { + return new SimplePropertyAssignmentSyntax(propertyName, TypeScript.Syntax.token(106 /* ColonToken */), expression, false); + }; + + SimplePropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SimplePropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SimplePropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.colonToken, this.expression); + }; + + SimplePropertyAssignmentSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.propertyName, colonToken, this.expression); + }; + + SimplePropertyAssignmentSyntax.prototype.withExpression = function (expression) { + return this.update(this.propertyName, this.colonToken, expression); + }; + + SimplePropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SimplePropertyAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SimplePropertyAssignmentSyntax = SimplePropertyAssignmentSyntax; + + var FunctionPropertyAssignmentSyntax = (function (_super) { + __extends(FunctionPropertyAssignmentSyntax, _super); + function FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + } + FunctionPropertyAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionPropertyAssignment(this); + }; + + FunctionPropertyAssignmentSyntax.prototype.kind = function () { + return 241 /* FunctionPropertyAssignment */; + }; + + FunctionPropertyAssignmentSyntax.prototype.childCount = function () { + return 3; + }; + + FunctionPropertyAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.callSignature; + case 2: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionPropertyAssignmentSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + FunctionPropertyAssignmentSyntax.prototype.update = function (propertyName, callSignature, block) { + if (this.propertyName === propertyName && this.callSignature === callSignature && this.block === block) { + return this; + } + + return new FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, this.parsedInStrictMode()); + }; + + FunctionPropertyAssignmentSyntax.create1 = function (propertyName) { + return new FunctionPropertyAssignmentSyntax(propertyName, CallSignatureSyntax.create1(), BlockSyntax.create1(), false); + }; + + FunctionPropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionPropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionPropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.callSignature, this.block); + }; + + FunctionPropertyAssignmentSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.propertyName, callSignature, this.block); + }; + + FunctionPropertyAssignmentSyntax.prototype.withBlock = function (block) { + return this.update(this.propertyName, this.callSignature, block); + }; + + FunctionPropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionPropertyAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionPropertyAssignmentSyntax = FunctionPropertyAssignmentSyntax; + + var FunctionExpressionSyntax = (function (_super) { + __extends(FunctionExpressionSyntax, _super); + function FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + } + FunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionExpression(this); + }; + + FunctionExpressionSyntax.prototype.kind = function () { + return 222 /* FunctionExpression */; + }; + + FunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + FunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.functionKeyword; + case 1: + return this.identifier; + case 2: + return this.callSignature; + case 3: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.update = function (functionKeyword, identifier, callSignature, block) { + if (this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block) { + return this; + } + + return new FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, this.parsedInStrictMode()); + }; + + FunctionExpressionSyntax.create = function (functionKeyword, callSignature, block) { + return new FunctionExpressionSyntax(functionKeyword, null, callSignature, block, false); + }; + + FunctionExpressionSyntax.create1 = function () { + return new FunctionExpressionSyntax(TypeScript.Syntax.token(27 /* FunctionKeyword */), null, CallSignatureSyntax.create1(), BlockSyntax.create1(), false); + }; + + FunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionExpressionSyntax.prototype.withFunctionKeyword = function (functionKeyword) { + return this.update(functionKeyword, this.identifier, this.callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.functionKeyword, identifier, this.callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.functionKeyword, this.identifier, callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.functionKeyword, this.identifier, this.callSignature, block); + }; + + FunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionExpressionSyntax = FunctionExpressionSyntax; + + var EmptyStatementSyntax = (function (_super) { + __extends(EmptyStatementSyntax, _super); + function EmptyStatementSyntax(semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.semicolonToken = semicolonToken; + } + EmptyStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitEmptyStatement(this); + }; + + EmptyStatementSyntax.prototype.kind = function () { + return 156 /* EmptyStatement */; + }; + + EmptyStatementSyntax.prototype.childCount = function () { + return 1; + }; + + EmptyStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EmptyStatementSyntax.prototype.isStatement = function () { + return true; + }; + + EmptyStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + EmptyStatementSyntax.prototype.update = function (semicolonToken) { + if (this.semicolonToken === semicolonToken) { + return this; + } + + return new EmptyStatementSyntax(semicolonToken, this.parsedInStrictMode()); + }; + + EmptyStatementSyntax.create1 = function () { + return new EmptyStatementSyntax(TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + EmptyStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EmptyStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EmptyStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(semicolonToken); + }; + + EmptyStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return EmptyStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EmptyStatementSyntax = EmptyStatementSyntax; + + var TryStatementSyntax = (function (_super) { + __extends(TryStatementSyntax, _super); + function TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.tryKeyword = tryKeyword; + this.block = block; + this.catchClause = catchClause; + this.finallyClause = finallyClause; + } + TryStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitTryStatement(this); + }; + + TryStatementSyntax.prototype.kind = function () { + return 159 /* TryStatement */; + }; + + TryStatementSyntax.prototype.childCount = function () { + return 4; + }; + + TryStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.tryKeyword; + case 1: + return this.block; + case 2: + return this.catchClause; + case 3: + return this.finallyClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TryStatementSyntax.prototype.isStatement = function () { + return true; + }; + + TryStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + TryStatementSyntax.prototype.update = function (tryKeyword, block, catchClause, finallyClause) { + if (this.tryKeyword === tryKeyword && this.block === block && this.catchClause === catchClause && this.finallyClause === finallyClause) { + return this; + } + + return new TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, this.parsedInStrictMode()); + }; + + TryStatementSyntax.create = function (tryKeyword, block) { + return new TryStatementSyntax(tryKeyword, block, null, null, false); + }; + + TryStatementSyntax.create1 = function () { + return new TryStatementSyntax(TypeScript.Syntax.token(38 /* TryKeyword */), BlockSyntax.create1(), null, null, false); + }; + + TryStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TryStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TryStatementSyntax.prototype.withTryKeyword = function (tryKeyword) { + return this.update(tryKeyword, this.block, this.catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withBlock = function (block) { + return this.update(this.tryKeyword, block, this.catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withCatchClause = function (catchClause) { + return this.update(this.tryKeyword, this.block, catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withFinallyClause = function (finallyClause) { + return this.update(this.tryKeyword, this.block, this.catchClause, finallyClause); + }; + + TryStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.block.isTypeScriptSpecific()) { + return true; + } + if (this.catchClause !== null && this.catchClause.isTypeScriptSpecific()) { + return true; + } + if (this.finallyClause !== null && this.finallyClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return TryStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TryStatementSyntax = TryStatementSyntax; + + var CatchClauseSyntax = (function (_super) { + __extends(CatchClauseSyntax, _super); + function CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.catchKeyword = catchKeyword; + this.openParenToken = openParenToken; + this.identifier = identifier; + this.typeAnnotation = typeAnnotation; + this.closeParenToken = closeParenToken; + this.block = block; + } + CatchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitCatchClause(this); + }; + + CatchClauseSyntax.prototype.kind = function () { + return 236 /* CatchClause */; + }; + + CatchClauseSyntax.prototype.childCount = function () { + return 6; + }; + + CatchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.catchKeyword; + case 1: + return this.openParenToken; + case 2: + return this.identifier; + case 3: + return this.typeAnnotation; + case 4: + return this.closeParenToken; + case 5: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CatchClauseSyntax.prototype.update = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + if (this.catchKeyword === catchKeyword && this.openParenToken === openParenToken && this.identifier === identifier && this.typeAnnotation === typeAnnotation && this.closeParenToken === closeParenToken && this.block === block) { + return this; + } + + return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, this.parsedInStrictMode()); + }; + + CatchClauseSyntax.create = function (catchKeyword, openParenToken, identifier, closeParenToken, block) { + return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, null, closeParenToken, block, false); + }; + + CatchClauseSyntax.create1 = function (identifier) { + return new CatchClauseSyntax(TypeScript.Syntax.token(17 /* CatchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), identifier, null, TypeScript.Syntax.token(73 /* CloseParenToken */), BlockSyntax.create1(), false); + }; + + CatchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CatchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CatchClauseSyntax.prototype.withCatchKeyword = function (catchKeyword) { + return this.update(catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.catchKeyword, openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.catchKeyword, this.openParenToken, identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withBlock = function (block) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, block); + }; + + CatchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeAnnotation !== null && this.typeAnnotation.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return CatchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CatchClauseSyntax = CatchClauseSyntax; + + var FinallyClauseSyntax = (function (_super) { + __extends(FinallyClauseSyntax, _super); + function FinallyClauseSyntax(finallyKeyword, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.finallyKeyword = finallyKeyword; + this.block = block; + } + FinallyClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitFinallyClause(this); + }; + + FinallyClauseSyntax.prototype.kind = function () { + return 237 /* FinallyClause */; + }; + + FinallyClauseSyntax.prototype.childCount = function () { + return 2; + }; + + FinallyClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.finallyKeyword; + case 1: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FinallyClauseSyntax.prototype.update = function (finallyKeyword, block) { + if (this.finallyKeyword === finallyKeyword && this.block === block) { + return this; + } + + return new FinallyClauseSyntax(finallyKeyword, block, this.parsedInStrictMode()); + }; + + FinallyClauseSyntax.create1 = function () { + return new FinallyClauseSyntax(TypeScript.Syntax.token(25 /* FinallyKeyword */), BlockSyntax.create1(), false); + }; + + FinallyClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FinallyClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FinallyClauseSyntax.prototype.withFinallyKeyword = function (finallyKeyword) { + return this.update(finallyKeyword, this.block); + }; + + FinallyClauseSyntax.prototype.withBlock = function (block) { + return this.update(this.finallyKeyword, block); + }; + + FinallyClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FinallyClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FinallyClauseSyntax = FinallyClauseSyntax; + + var LabeledStatementSyntax = (function (_super) { + __extends(LabeledStatementSyntax, _super); + function LabeledStatementSyntax(identifier, colonToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.colonToken = colonToken; + this.statement = statement; + } + LabeledStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitLabeledStatement(this); + }; + + LabeledStatementSyntax.prototype.kind = function () { + return 160 /* LabeledStatement */; + }; + + LabeledStatementSyntax.prototype.childCount = function () { + return 3; + }; + + LabeledStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.colonToken; + case 2: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + LabeledStatementSyntax.prototype.isStatement = function () { + return true; + }; + + LabeledStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + LabeledStatementSyntax.prototype.update = function (identifier, colonToken, statement) { + if (this.identifier === identifier && this.colonToken === colonToken && this.statement === statement) { + return this; + } + + return new LabeledStatementSyntax(identifier, colonToken, statement, this.parsedInStrictMode()); + }; + + LabeledStatementSyntax.create1 = function (identifier, statement) { + return new LabeledStatementSyntax(identifier, TypeScript.Syntax.token(106 /* ColonToken */), statement, false); + }; + + LabeledStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + LabeledStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + LabeledStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.colonToken, this.statement); + }; + + LabeledStatementSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.identifier, colonToken, this.statement); + }; + + LabeledStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.identifier, this.colonToken, statement); + }; + + LabeledStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return LabeledStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.LabeledStatementSyntax = LabeledStatementSyntax; + + var DoStatementSyntax = (function (_super) { + __extends(DoStatementSyntax, _super); + function DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.doKeyword = doKeyword; + this.statement = statement; + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.semicolonToken = semicolonToken; + } + DoStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitDoStatement(this); + }; + + DoStatementSyntax.prototype.kind = function () { + return 161 /* DoStatement */; + }; + + DoStatementSyntax.prototype.childCount = function () { + return 7; + }; + + DoStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.doKeyword; + case 1: + return this.statement; + case 2: + return this.whileKeyword; + case 3: + return this.openParenToken; + case 4: + return this.condition; + case 5: + return this.closeParenToken; + case 6: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DoStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + DoStatementSyntax.prototype.isStatement = function () { + return true; + }; + + DoStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + DoStatementSyntax.prototype.update = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + if (this.doKeyword === doKeyword && this.statement === statement && this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.semicolonToken === semicolonToken) { + return this; + } + + return new DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, this.parsedInStrictMode()); + }; + + DoStatementSyntax.create1 = function (statement, condition) { + return new DoStatementSyntax(TypeScript.Syntax.token(22 /* DoKeyword */), statement, TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + DoStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DoStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DoStatementSyntax.prototype.withDoKeyword = function (doKeyword) { + return this.update(doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.doKeyword, statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) { + return this.update(this.doKeyword, this.statement, whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, semicolonToken); + }; + + DoStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + if (this.condition.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DoStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DoStatementSyntax = DoStatementSyntax; + + var TypeOfExpressionSyntax = (function (_super) { + __extends(TypeOfExpressionSyntax, _super); + function TypeOfExpressionSyntax(typeOfKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeOfKeyword = typeOfKeyword; + this.expression = expression; + } + TypeOfExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeOfExpression(this); + }; + + TypeOfExpressionSyntax.prototype.kind = function () { + return 171 /* TypeOfExpression */; + }; + + TypeOfExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + TypeOfExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeOfKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeOfExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + TypeOfExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + TypeOfExpressionSyntax.prototype.update = function (typeOfKeyword, expression) { + if (this.typeOfKeyword === typeOfKeyword && this.expression === expression) { + return this; + } + + return new TypeOfExpressionSyntax(typeOfKeyword, expression, this.parsedInStrictMode()); + }; + + TypeOfExpressionSyntax.create1 = function (expression) { + return new TypeOfExpressionSyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), expression, false); + }; + + TypeOfExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeOfExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeOfExpressionSyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) { + return this.update(typeOfKeyword, this.expression); + }; + + TypeOfExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.typeOfKeyword, expression); + }; + + TypeOfExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return TypeOfExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeOfExpressionSyntax = TypeOfExpressionSyntax; + + var DeleteExpressionSyntax = (function (_super) { + __extends(DeleteExpressionSyntax, _super); + function DeleteExpressionSyntax(deleteKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.deleteKeyword = deleteKeyword; + this.expression = expression; + } + DeleteExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitDeleteExpression(this); + }; + + DeleteExpressionSyntax.prototype.kind = function () { + return 170 /* DeleteExpression */; + }; + + DeleteExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + DeleteExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.deleteKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DeleteExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + DeleteExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + DeleteExpressionSyntax.prototype.update = function (deleteKeyword, expression) { + if (this.deleteKeyword === deleteKeyword && this.expression === expression) { + return this; + } + + return new DeleteExpressionSyntax(deleteKeyword, expression, this.parsedInStrictMode()); + }; + + DeleteExpressionSyntax.create1 = function (expression) { + return new DeleteExpressionSyntax(TypeScript.Syntax.token(21 /* DeleteKeyword */), expression, false); + }; + + DeleteExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DeleteExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DeleteExpressionSyntax.prototype.withDeleteKeyword = function (deleteKeyword) { + return this.update(deleteKeyword, this.expression); + }; + + DeleteExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.deleteKeyword, expression); + }; + + DeleteExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DeleteExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DeleteExpressionSyntax = DeleteExpressionSyntax; + + var VoidExpressionSyntax = (function (_super) { + __extends(VoidExpressionSyntax, _super); + function VoidExpressionSyntax(voidKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.voidKeyword = voidKeyword; + this.expression = expression; + } + VoidExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitVoidExpression(this); + }; + + VoidExpressionSyntax.prototype.kind = function () { + return 172 /* VoidExpression */; + }; + + VoidExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + VoidExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.voidKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VoidExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + VoidExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + VoidExpressionSyntax.prototype.update = function (voidKeyword, expression) { + if (this.voidKeyword === voidKeyword && this.expression === expression) { + return this; + } + + return new VoidExpressionSyntax(voidKeyword, expression, this.parsedInStrictMode()); + }; + + VoidExpressionSyntax.create1 = function (expression) { + return new VoidExpressionSyntax(TypeScript.Syntax.token(41 /* VoidKeyword */), expression, false); + }; + + VoidExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VoidExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VoidExpressionSyntax.prototype.withVoidKeyword = function (voidKeyword) { + return this.update(voidKeyword, this.expression); + }; + + VoidExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.voidKeyword, expression); + }; + + VoidExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VoidExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VoidExpressionSyntax = VoidExpressionSyntax; + + var DebuggerStatementSyntax = (function (_super) { + __extends(DebuggerStatementSyntax, _super); + function DebuggerStatementSyntax(debuggerKeyword, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.debuggerKeyword = debuggerKeyword; + this.semicolonToken = semicolonToken; + } + DebuggerStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitDebuggerStatement(this); + }; + + DebuggerStatementSyntax.prototype.kind = function () { + return 162 /* DebuggerStatement */; + }; + + DebuggerStatementSyntax.prototype.childCount = function () { + return 2; + }; + + DebuggerStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.debuggerKeyword; + case 1: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DebuggerStatementSyntax.prototype.isStatement = function () { + return true; + }; + + DebuggerStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + DebuggerStatementSyntax.prototype.update = function (debuggerKeyword, semicolonToken) { + if (this.debuggerKeyword === debuggerKeyword && this.semicolonToken === semicolonToken) { + return this; + } + + return new DebuggerStatementSyntax(debuggerKeyword, semicolonToken, this.parsedInStrictMode()); + }; + + DebuggerStatementSyntax.create1 = function () { + return new DebuggerStatementSyntax(TypeScript.Syntax.token(19 /* DebuggerKeyword */), TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + DebuggerStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DebuggerStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DebuggerStatementSyntax.prototype.withDebuggerKeyword = function (debuggerKeyword) { + return this.update(debuggerKeyword, this.semicolonToken); + }; + + DebuggerStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.debuggerKeyword, semicolonToken); + }; + + DebuggerStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return DebuggerStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DebuggerStatementSyntax = DebuggerStatementSyntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxRewriter = (function () { + function SyntaxRewriter() { + } + SyntaxRewriter.prototype.visitToken = function (token) { + return token; + }; + + SyntaxRewriter.prototype.visitNode = function (node) { + return node.accept(this); + }; + + SyntaxRewriter.prototype.visitNodeOrToken = function (node) { + return node.isToken() ? this.visitToken(node) : this.visitNode(node); + }; + + SyntaxRewriter.prototype.visitList = function (list) { + var newItems = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + var newItem = this.visitNodeOrToken(item); + + if (item !== newItem && newItems === null) { + newItems = []; + for (var j = 0; j < i; j++) { + newItems.push(list.childAt(j)); + } + } + + if (newItems) { + newItems.push(newItem); + } + } + + return newItems === null ? list : TypeScript.Syntax.list(newItems); + }; + + SyntaxRewriter.prototype.visitSeparatedList = function (list) { + var newItems = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + var newItem = item.isToken() ? this.visitToken(item) : this.visitNode(item); + + if (item !== newItem && newItems === null) { + newItems = []; + for (var j = 0; j < i; j++) { + newItems.push(list.childAt(j)); + } + } + + if (newItems) { + newItems.push(newItem); + } + } + + return newItems === null ? list : TypeScript.Syntax.separatedList(newItems); + }; + + SyntaxRewriter.prototype.visitSourceUnit = function (node) { + return node.update(this.visitList(node.moduleElements), this.visitToken(node.endOfFileToken)); + }; + + SyntaxRewriter.prototype.visitExternalModuleReference = function (node) { + return node.update(this.visitToken(node.requireKeyword), this.visitToken(node.openParenToken), this.visitToken(node.stringLiteral), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitModuleNameModuleReference = function (node) { + return node.update(this.visitNodeOrToken(node.moduleName)); + }; + + SyntaxRewriter.prototype.visitImportDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.importKeyword), this.visitToken(node.identifier), this.visitToken(node.equalsToken), this.visitNodeOrToken(node.moduleReference), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitExportAssignment = function (node) { + return node.update(this.visitToken(node.exportKeyword), this.visitToken(node.equalsToken), this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitClassDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.classKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitToken(node.openBraceToken), this.visitList(node.classElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitInterfaceDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.interfaceKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitNode(node.body)); + }; + + SyntaxRewriter.prototype.visitHeritageClause = function (node) { + return node.update(node.kind(), this.visitToken(node.extendsOrImplementsKeyword), this.visitSeparatedList(node.typeNames)); + }; + + SyntaxRewriter.prototype.visitModuleDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.moduleKeyword), node.name === null ? null : this.visitNodeOrToken(node.name), node.stringLiteral === null ? null : this.visitToken(node.stringLiteral), this.visitToken(node.openBraceToken), this.visitList(node.moduleElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitFunctionDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.functionKeyword), this.visitToken(node.identifier), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitVariableStatement = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclaration), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitVariableDeclaration = function (node) { + return node.update(this.visitToken(node.varKeyword), this.visitSeparatedList(node.variableDeclarators)); + }; + + SyntaxRewriter.prototype.visitVariableDeclarator = function (node) { + return node.update(this.visitToken(node.propertyName), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitEqualsValueClause = function (node) { + return node.update(this.visitToken(node.equalsToken), this.visitNodeOrToken(node.value)); + }; + + SyntaxRewriter.prototype.visitPrefixUnaryExpression = function (node) { + return node.update(node.kind(), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.operand)); + }; + + SyntaxRewriter.prototype.visitArrayLiteralExpression = function (node) { + return node.update(this.visitToken(node.openBracketToken), this.visitSeparatedList(node.expressions), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitOmittedExpression = function (node) { + return node; + }; + + SyntaxRewriter.prototype.visitParenthesizedExpression = function (node) { + return node.update(this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitSimpleArrowFunctionExpression = function (node) { + return node.update(this.visitToken(node.identifier), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + return node.update(this.visitNode(node.callSignature), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitQualifiedName = function (node) { + return node.update(this.visitNodeOrToken(node.left), this.visitToken(node.dotToken), this.visitToken(node.right)); + }; + + SyntaxRewriter.prototype.visitTypeArgumentList = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeArguments), this.visitToken(node.greaterThanToken)); + }; + + SyntaxRewriter.prototype.visitConstructorType = function (node) { + return node.update(this.visitToken(node.newKeyword), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitFunctionType = function (node) { + return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitObjectType = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.typeMembers), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitArrayType = function (node) { + return node.update(this.visitNodeOrToken(node.type), this.visitToken(node.openBracketToken), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitGenericType = function (node) { + return node.update(this.visitNodeOrToken(node.name), this.visitNode(node.typeArgumentList)); + }; + + SyntaxRewriter.prototype.visitTypeQuery = function (node) { + return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.name)); + }; + + SyntaxRewriter.prototype.visitTypeAnnotation = function (node) { + return node.update(this.visitToken(node.colonToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitBlock = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitList(node.statements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitParameter = function (node) { + return node.update(node.dotDotDotToken === null ? null : this.visitToken(node.dotDotDotToken), this.visitList(node.modifiers), this.visitToken(node.identifier), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitMemberAccessExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.dotToken), this.visitToken(node.name)); + }; + + SyntaxRewriter.prototype.visitPostfixUnaryExpression = function (node) { + return node.update(node.kind(), this.visitNodeOrToken(node.operand), this.visitToken(node.operatorToken)); + }; + + SyntaxRewriter.prototype.visitElementAccessExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.openBracketToken), this.visitNodeOrToken(node.argumentExpression), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitInvocationExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitNode(node.argumentList)); + }; + + SyntaxRewriter.prototype.visitArgumentList = function (node) { + return node.update(node.typeArgumentList === null ? null : this.visitNode(node.typeArgumentList), this.visitToken(node.openParenToken), this.visitSeparatedList(node.arguments), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitBinaryExpression = function (node) { + return node.update(node.kind(), this.visitNodeOrToken(node.left), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.right)); + }; + + SyntaxRewriter.prototype.visitConditionalExpression = function (node) { + return node.update(this.visitNodeOrToken(node.condition), this.visitToken(node.questionToken), this.visitNodeOrToken(node.whenTrue), this.visitToken(node.colonToken), this.visitNodeOrToken(node.whenFalse)); + }; + + SyntaxRewriter.prototype.visitConstructSignature = function (node) { + return node.update(this.visitToken(node.newKeyword), this.visitNode(node.callSignature)); + }; + + SyntaxRewriter.prototype.visitMethodSignature = function (node) { + return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), this.visitNode(node.callSignature)); + }; + + SyntaxRewriter.prototype.visitIndexSignature = function (node) { + return node.update(this.visitToken(node.openBracketToken), this.visitNode(node.parameter), this.visitToken(node.closeBracketToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitPropertySignature = function (node) { + return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitCallSignature = function (node) { + return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitParameterList = function (node) { + return node.update(this.visitToken(node.openParenToken), this.visitSeparatedList(node.parameters), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitTypeParameterList = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeParameters), this.visitToken(node.greaterThanToken)); + }; + + SyntaxRewriter.prototype.visitTypeParameter = function (node) { + return node.update(this.visitToken(node.identifier), node.constraint === null ? null : this.visitNode(node.constraint)); + }; + + SyntaxRewriter.prototype.visitConstraint = function (node) { + return node.update(this.visitToken(node.extendsKeyword), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitElseClause = function (node) { + return node.update(this.visitToken(node.elseKeyword), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitIfStatement = function (node) { + return node.update(this.visitToken(node.ifKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement), node.elseClause === null ? null : this.visitNode(node.elseClause)); + }; + + SyntaxRewriter.prototype.visitExpressionStatement = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitConstructorDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.constructorKeyword), this.visitNode(node.parameterList), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitMemberFunctionDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.propertyName), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitGetAccessor = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.getKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitSetAccessor = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.setKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitMemberVariableDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclarator), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitIndexMemberDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.indexSignature), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitThrowStatement = function (node) { + return node.update(this.visitToken(node.throwKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitReturnStatement = function (node) { + return node.update(this.visitToken(node.returnKeyword), node.expression === null ? null : this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitObjectCreationExpression = function (node) { + return node.update(this.visitToken(node.newKeyword), this.visitNodeOrToken(node.expression), node.argumentList === null ? null : this.visitNode(node.argumentList)); + }; + + SyntaxRewriter.prototype.visitSwitchStatement = function (node) { + return node.update(this.visitToken(node.switchKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitToken(node.openBraceToken), this.visitList(node.switchClauses), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitCaseSwitchClause = function (node) { + return node.update(this.visitToken(node.caseKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.colonToken), this.visitList(node.statements)); + }; + + SyntaxRewriter.prototype.visitDefaultSwitchClause = function (node) { + return node.update(this.visitToken(node.defaultKeyword), this.visitToken(node.colonToken), this.visitList(node.statements)); + }; + + SyntaxRewriter.prototype.visitBreakStatement = function (node) { + return node.update(this.visitToken(node.breakKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitContinueStatement = function (node) { + return node.update(this.visitToken(node.continueKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitForStatement = function (node) { + return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.initializer === null ? null : this.visitNodeOrToken(node.initializer), this.visitToken(node.firstSemicolonToken), node.condition === null ? null : this.visitNodeOrToken(node.condition), this.visitToken(node.secondSemicolonToken), node.incrementor === null ? null : this.visitNodeOrToken(node.incrementor), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitForInStatement = function (node) { + return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.left === null ? null : this.visitNodeOrToken(node.left), this.visitToken(node.inKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitWhileStatement = function (node) { + return node.update(this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitWithStatement = function (node) { + return node.update(this.visitToken(node.withKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitEnumDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.enumKeyword), this.visitToken(node.identifier), this.visitToken(node.openBraceToken), this.visitSeparatedList(node.enumElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitEnumElement = function (node) { + return node.update(this.visitToken(node.propertyName), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitCastExpression = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitNodeOrToken(node.type), this.visitToken(node.greaterThanToken), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitObjectLiteralExpression = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.propertyAssignments), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitSimplePropertyAssignment = function (node) { + return node.update(this.visitToken(node.propertyName), this.visitToken(node.colonToken), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitFunctionPropertyAssignment = function (node) { + return node.update(this.visitToken(node.propertyName), this.visitNode(node.callSignature), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitFunctionExpression = function (node) { + return node.update(this.visitToken(node.functionKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitNode(node.callSignature), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitEmptyStatement = function (node) { + return node.update(this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitTryStatement = function (node) { + return node.update(this.visitToken(node.tryKeyword), this.visitNode(node.block), node.catchClause === null ? null : this.visitNode(node.catchClause), node.finallyClause === null ? null : this.visitNode(node.finallyClause)); + }; + + SyntaxRewriter.prototype.visitCatchClause = function (node) { + return node.update(this.visitToken(node.catchKeyword), this.visitToken(node.openParenToken), this.visitToken(node.identifier), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitToken(node.closeParenToken), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitFinallyClause = function (node) { + return node.update(this.visitToken(node.finallyKeyword), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitLabeledStatement = function (node) { + return node.update(this.visitToken(node.identifier), this.visitToken(node.colonToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitDoStatement = function (node) { + return node.update(this.visitToken(node.doKeyword), this.visitNodeOrToken(node.statement), this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitTypeOfExpression = function (node) { + return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitDeleteExpression = function (node) { + return node.update(this.visitToken(node.deleteKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitVoidExpression = function (node) { + return node.update(this.visitToken(node.voidKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitDebuggerStatement = function (node) { + return node.update(this.visitToken(node.debuggerKeyword), this.visitToken(node.semicolonToken)); + }; + return SyntaxRewriter; + })(); + TypeScript.SyntaxRewriter = SyntaxRewriter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxDedenter = (function (_super) { + __extends(SyntaxDedenter, _super); + function SyntaxDedenter(dedentFirstToken, dedentationAmount, minimumIndent, options) { + _super.call(this); + this.dedentationAmount = dedentationAmount; + this.minimumIndent = minimumIndent; + this.options = options; + this.lastTriviaWasNewLine = dedentFirstToken; + } + SyntaxDedenter.prototype.abort = function () { + this.lastTriviaWasNewLine = false; + this.dedentationAmount = 0; + }; + + SyntaxDedenter.prototype.isAborted = function () { + return this.dedentationAmount === 0; + }; + + SyntaxDedenter.prototype.visitToken = function (token) { + if (token.width() === 0) { + return token; + } + + var result = token; + if (this.lastTriviaWasNewLine) { + result = token.withLeadingTrivia(this.dedentTriviaList(token.leadingTrivia())); + } + + if (this.isAborted()) { + return token; + } + + this.lastTriviaWasNewLine = token.hasTrailingNewLine(); + return result; + }; + + SyntaxDedenter.prototype.dedentTriviaList = function (triviaList) { + var result = []; + var dedentNextWhitespace = true; + + for (var i = 0, n = triviaList.count(); i < n && !this.isAborted(); i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + var dedentThisTrivia = dedentNextWhitespace; + dedentNextWhitespace = false; + + if (dedentThisTrivia) { + if (trivia.kind() === 4 /* WhitespaceTrivia */) { + var hasFollowingNewLine = (i < triviaList.count() - 1) && triviaList.syntaxTriviaAt(i + 1).kind() === 5 /* NewLineTrivia */; + result.push(this.dedentWhitespace(trivia, hasFollowingNewLine)); + continue; + } else if (trivia.kind() !== 5 /* NewLineTrivia */) { + this.abort(); + break; + } + } + + if (trivia.kind() === 6 /* MultiLineCommentTrivia */) { + result.push(this.dedentMultiLineComment(trivia)); + continue; + } + + result.push(trivia); + if (trivia.kind() === 5 /* NewLineTrivia */) { + dedentNextWhitespace = true; + } + } + + if (dedentNextWhitespace) { + this.abort(); + } + + if (this.isAborted()) { + return triviaList; + } + + return TypeScript.Syntax.triviaList(result); + }; + + SyntaxDedenter.prototype.dedentSegment = function (segment, hasFollowingNewLineTrivia) { + var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment); + + if (firstNonWhitespacePosition === segment.length) { + if (hasFollowingNewLineTrivia) { + return ""; + } + } else if (TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) { + return segment.substring(firstNonWhitespacePosition); + } + + var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options); + + var newFirstNonWhitespaceColumn = TypeScript.MathPrototype.min(firstNonWhitespaceColumn, TypeScript.MathPrototype.max(firstNonWhitespaceColumn - this.dedentationAmount, this.minimumIndent)); + + if (newFirstNonWhitespaceColumn === firstNonWhitespaceColumn) { + this.abort(); + return segment; + } + + this.dedentationAmount = firstNonWhitespaceColumn - newFirstNonWhitespaceColumn; + TypeScript.Debug.assert(this.dedentationAmount >= 0); + + var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options); + + return indentationString + segment.substring(firstNonWhitespacePosition); + }; + + SyntaxDedenter.prototype.dedentWhitespace = function (trivia, hasFollowingNewLineTrivia) { + var newIndentation = this.dedentSegment(trivia.fullText(), hasFollowingNewLineTrivia); + return TypeScript.Syntax.whitespace(newIndentation); + }; + + SyntaxDedenter.prototype.dedentMultiLineComment = function (trivia) { + var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + if (segments.length === 1) { + return trivia; + } + + for (var i = 1; i < segments.length; i++) { + var segment = segments[i]; + segments[i] = this.dedentSegment(segment, false); + } + + var result = segments.join(""); + + return TypeScript.Syntax.multiLineComment(result); + }; + + SyntaxDedenter.dedentNode = function (node, dedentFirstToken, dedentAmount, minimumIndent, options) { + var dedenter = new SyntaxDedenter(dedentFirstToken, dedentAmount, minimumIndent, options); + var result = node.accept(dedenter); + + if (dedenter.isAborted()) { + return node; + } + + return result; + }; + return SyntaxDedenter; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxDedenter = SyntaxDedenter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxIndenter = (function (_super) { + __extends(SyntaxIndenter, _super); + function SyntaxIndenter(indentFirstToken, indentationAmount, options) { + _super.call(this); + this.indentationAmount = indentationAmount; + this.options = options; + this.lastTriviaWasNewLine = indentFirstToken; + this.indentationTrivia = TypeScript.Indentation.indentationTrivia(this.indentationAmount, this.options); + } + SyntaxIndenter.prototype.visitToken = function (token) { + if (token.width() === 0) { + return token; + } + + var result = token; + if (this.lastTriviaWasNewLine) { + result = token.withLeadingTrivia(this.indentTriviaList(token.leadingTrivia())); + } + + this.lastTriviaWasNewLine = token.hasTrailingNewLine(); + return result; + }; + + SyntaxIndenter.prototype.indentTriviaList = function (triviaList) { + var result = []; + + var indentNextTrivia = true; + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + var indentThisTrivia = indentNextTrivia; + indentNextTrivia = false; + + switch (trivia.kind()) { + case 6 /* MultiLineCommentTrivia */: + this.indentMultiLineComment(trivia, indentThisTrivia, result); + continue; + + case 7 /* SingleLineCommentTrivia */: + case 8 /* SkippedTokenTrivia */: + this.indentSingleLineOrSkippedText(trivia, indentThisTrivia, result); + continue; + + case 4 /* WhitespaceTrivia */: + this.indentWhitespace(trivia, indentThisTrivia, result); + continue; + + case 5 /* NewLineTrivia */: + result.push(trivia); + indentNextTrivia = true; + continue; + + default: + throw TypeScript.Errors.invalidOperation(); + } + } + + if (indentNextTrivia) { + result.push(this.indentationTrivia); + } + + return TypeScript.Syntax.triviaList(result); + }; + + SyntaxIndenter.prototype.indentSegment = function (segment) { + var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment); + + if (firstNonWhitespacePosition < segment.length && TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) { + return segment; + } + + var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options); + + var newFirstNonWhitespaceColumn = firstNonWhitespaceColumn + this.indentationAmount; + + var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options); + + return indentationString + segment.substring(firstNonWhitespacePosition); + }; + + SyntaxIndenter.prototype.indentWhitespace = function (trivia, indentThisTrivia, result) { + if (!indentThisTrivia) { + result.push(trivia); + return; + } + + var newIndentation = this.indentSegment(trivia.fullText()); + result.push(TypeScript.Syntax.whitespace(newIndentation)); + }; + + SyntaxIndenter.prototype.indentSingleLineOrSkippedText = function (trivia, indentThisTrivia, result) { + if (indentThisTrivia) { + result.push(this.indentationTrivia); + } + + result.push(trivia); + }; + + SyntaxIndenter.prototype.indentMultiLineComment = function (trivia, indentThisTrivia, result) { + if (indentThisTrivia) { + result.push(this.indentationTrivia); + } + + var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + + for (var i = 1; i < segments.length; i++) { + segments[i] = this.indentSegment(segments[i]); + } + + var newText = segments.join(""); + result.push(TypeScript.Syntax.multiLineComment(newText)); + }; + + SyntaxIndenter.indentNode = function (node, indentFirstToken, indentAmount, options) { + var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options); + return node.accept(indenter); + }; + + SyntaxIndenter.indentNodes = function (nodes, indentFirstToken, indentAmount, options) { + var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options); + var result = TypeScript.ArrayUtilities.select(nodes, function (n) { + return n.accept(indenter); + }); + + return result; + }; + return SyntaxIndenter; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxIndenter = SyntaxIndenter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var VariableWidthTokenWithNoTrivia = (function () { + function VariableWidthTokenWithNoTrivia(sourceText, fullStart, kind, textOrWidth) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._textOrWidth = textOrWidth; + } + VariableWidthTokenWithNoTrivia.prototype.clone = function () { + return new VariableWidthTokenWithNoTrivia(this._sourceText, this._fullStart, this.tokenKind, this._textOrWidth); + }; + + VariableWidthTokenWithNoTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithNoTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithNoTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithNoTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithNoTrivia.prototype.fullWidth = function () { + return this.width(); + }; + VariableWidthTokenWithNoTrivia.prototype.start = function () { + return this._fullStart; + }; + VariableWidthTokenWithNoTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithNoTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithNoTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithNoTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithNoTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithNoTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithNoTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithNoTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithNoTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithNoTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithNoTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithNoTrivia; + })(); + Syntax.VariableWidthTokenWithNoTrivia = VariableWidthTokenWithNoTrivia; + + var VariableWidthTokenWithLeadingTrivia = (function () { + function VariableWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, textOrWidth) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._textOrWidth = textOrWidth; + } + VariableWidthTokenWithLeadingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithLeadingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._textOrWidth); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithLeadingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width(); + }; + VariableWidthTokenWithLeadingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithLeadingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithLeadingTrivia; + })(); + Syntax.VariableWidthTokenWithLeadingTrivia = VariableWidthTokenWithLeadingTrivia; + + var VariableWidthTokenWithTrailingTrivia = (function () { + function VariableWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, textOrWidth, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._textOrWidth = textOrWidth; + this._trailingTriviaInfo = trailingTriviaInfo; + } + VariableWidthTokenWithTrailingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._textOrWidth, this._trailingTriviaInfo); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.fullWidth = function () { + return this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.start = function () { + return this._fullStart; + }; + VariableWidthTokenWithTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithTrailingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithTrailingTrivia; + })(); + Syntax.VariableWidthTokenWithTrailingTrivia = VariableWidthTokenWithTrailingTrivia; + + var VariableWidthTokenWithLeadingAndTrailingTrivia = (function () { + function VariableWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, textOrWidth, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._textOrWidth = textOrWidth; + this._trailingTriviaInfo = trailingTriviaInfo; + } + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithLeadingAndTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._textOrWidth, this._trailingTriviaInfo); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithLeadingAndTrailingTrivia; + })(); + Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia = VariableWidthTokenWithLeadingAndTrailingTrivia; + + var FixedWidthTokenWithNoTrivia = (function () { + function FixedWidthTokenWithNoTrivia(kind) { + this.tokenKind = kind; + } + FixedWidthTokenWithNoTrivia.prototype.clone = function () { + return new FixedWidthTokenWithNoTrivia(this.tokenKind); + }; + + FixedWidthTokenWithNoTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithNoTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithNoTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithNoTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithNoTrivia.prototype.fullWidth = function () { + return this.width(); + }; + FixedWidthTokenWithNoTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithNoTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithNoTrivia.prototype.fullText = function () { + return this.text(); + }; + + FixedWidthTokenWithNoTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithNoTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithNoTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithNoTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithNoTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithNoTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithNoTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithNoTrivia; + })(); + Syntax.FixedWidthTokenWithNoTrivia = FixedWidthTokenWithNoTrivia; + + var FixedWidthTokenWithLeadingTrivia = (function () { + function FixedWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + } + FixedWidthTokenWithLeadingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithLeadingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithLeadingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width(); + }; + FixedWidthTokenWithLeadingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithLeadingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithLeadingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithLeadingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithLeadingTrivia; + })(); + Syntax.FixedWidthTokenWithLeadingTrivia = FixedWidthTokenWithLeadingTrivia; + + var FixedWidthTokenWithTrailingTrivia = (function () { + function FixedWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._trailingTriviaInfo = trailingTriviaInfo; + } + FixedWidthTokenWithTrailingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._trailingTriviaInfo); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.fullWidth = function () { + return this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.start = function () { + return this._fullStart; + }; + FixedWidthTokenWithTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithTrailingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithTrailingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithTrailingTrivia; + })(); + Syntax.FixedWidthTokenWithTrailingTrivia = FixedWidthTokenWithTrailingTrivia; + + var FixedWidthTokenWithLeadingAndTrailingTrivia = (function () { + function FixedWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._trailingTriviaInfo = trailingTriviaInfo; + } + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithLeadingAndTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithLeadingAndTrailingTrivia; + })(); + Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia = FixedWidthTokenWithLeadingAndTrailingTrivia; + + function collectTokenTextElements(token, elements) { + token.leadingTrivia().collectTextElements(elements); + elements.push(token.text()); + token.trailingTrivia().collectTextElements(elements); + } + + function fixedWidthToken(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new FixedWidthTokenWithNoTrivia(kind); + } else { + return new FixedWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new FixedWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo); + } else { + return new FixedWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo); + } + } + Syntax.fixedWidthToken = fixedWidthToken; + + function variableWidthToken(sourceText, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new VariableWidthTokenWithNoTrivia(sourceText, fullStart, kind, width); + } else { + return new VariableWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, width, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new VariableWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, width); + } else { + return new VariableWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo); + } + } + Syntax.variableWidthToken = variableWidthToken; + + function getTriviaWidth(value) { + return value >>> 2 /* TriviaFullWidthShift */; + } + + function hasTriviaComment(value) { + return (value & 2 /* TriviaCommentMask */) !== 0; + } + + function hasTriviaNewLine(value) { + return (value & 1 /* TriviaNewLineMask */) !== 0; + } + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + function isExpression(token) { + switch (token.tokenKind) { + case 11 /* IdentifierName */: + case 12 /* RegularExpressionLiteral */: + case 13 /* NumericLiteral */: + case 14 /* StringLiteral */: + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 50 /* SuperKeyword */: + return true; + } + + return false; + } + Syntax.isExpression = isExpression; + + function realizeToken(token) { + return new RealizedToken(token.tokenKind, token.leadingTrivia(), token.text(), token.value(), token.valueText(), token.trailingTrivia()); + } + Syntax.realizeToken = realizeToken; + + function convertToIdentifierName(token) { + TypeScript.Debug.assert(TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)); + return new RealizedToken(11 /* IdentifierName */, token.leadingTrivia(), token.text(), token.text(), token.text(), token.trailingTrivia()); + } + Syntax.convertToIdentifierName = convertToIdentifierName; + + function tokenToJSON(token) { + var result = {}; + + for (var name in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind[name] === token.kind()) { + result.kind = name; + break; + } + } + + result.width = token.width(); + if (token.fullWidth() !== token.width()) { + result.fullWidth = token.fullWidth(); + } + + result.text = token.text(); + + var value = token.value(); + if (value !== null) { + result.value = value; + result.valueText = token.valueText(); + } + + if (token.hasLeadingTrivia()) { + result.hasLeadingTrivia = true; + } + + if (token.hasLeadingComment()) { + result.hasLeadingComment = true; + } + + if (token.hasLeadingNewLine()) { + result.hasLeadingNewLine = true; + } + + if (token.hasLeadingSkippedText()) { + result.hasLeadingSkippedText = true; + } + + if (token.hasTrailingTrivia()) { + result.hasTrailingTrivia = true; + } + + if (token.hasTrailingComment()) { + result.hasTrailingComment = true; + } + + if (token.hasTrailingNewLine()) { + result.hasTrailingNewLine = true; + } + + if (token.hasTrailingSkippedText()) { + result.hasTrailingSkippedText = true; + } + + var trivia = token.leadingTrivia(); + if (trivia.count() > 0) { + result.leadingTrivia = trivia; + } + + trivia = token.trailingTrivia(); + if (trivia.count() > 0) { + result.trailingTrivia = trivia; + } + + return result; + } + Syntax.tokenToJSON = tokenToJSON; + + function value(token) { + return value1(token.tokenKind, token.text()); + } + Syntax.value = value; + + function hexValue(text, start, length) { + var intChar = 0; + for (var i = 0; i < length; i++) { + var ch2 = text.charCodeAt(start + i); + if (!TypeScript.CharacterInfo.isHexDigit(ch2)) { + break; + } + + intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2); + } + + return intChar; + } + + var characterArray = []; + + function convertEscapes(text) { + characterArray.length = 0; + var result = ""; + + for (var i = 0, n = text.length; i < n; i++) { + var ch = text.charCodeAt(i); + + if (ch === 92 /* backslash */) { + i++; + if (i < n) { + ch = text.charCodeAt(i); + switch (ch) { + case 48 /* _0 */: + characterArray.push(0 /* nullCharacter */); + continue; + + case 98 /* b */: + characterArray.push(8 /* backspace */); + continue; + + case 102 /* f */: + characterArray.push(12 /* formFeed */); + continue; + + case 110 /* n */: + characterArray.push(10 /* lineFeed */); + continue; + + case 114 /* r */: + characterArray.push(13 /* carriageReturn */); + continue; + + case 116 /* t */: + characterArray.push(9 /* tab */); + continue; + + case 118 /* v */: + characterArray.push(11 /* verticalTab */); + continue; + + case 120 /* x */: + characterArray.push(hexValue(text, i + 1, 2)); + i += 2; + continue; + + case 117 /* u */: + characterArray.push(hexValue(text, i + 1, 4)); + i += 4; + continue; + + case 13 /* carriageReturn */: + var nextIndex = i + 1; + if (nextIndex < text.length && text.charCodeAt(nextIndex) == 10 /* lineFeed */) { + i++; + } + continue; + + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + continue; + + default: + } + } + } + + characterArray.push(ch); + + if (i && !(i % 1024)) { + result = result.concat(String.fromCharCode.apply(null, characterArray)); + characterArray.length = 0; + } + } + + if (characterArray.length) { + result = result.concat(String.fromCharCode.apply(null, characterArray)); + } + + return result; + } + + function massageEscapes(text) { + return text.indexOf("\\") >= 0 ? convertEscapes(text) : text; + } + Syntax.massageEscapes = massageEscapes; + + function value1(kind, text) { + if (kind === 11 /* IdentifierName */) { + return massageEscapes(text); + } + + switch (kind) { + case 37 /* TrueKeyword */: + return true; + case 24 /* FalseKeyword */: + return false; + case 32 /* NullKeyword */: + return null; + } + + if (TypeScript.SyntaxFacts.isAnyKeyword(kind) || TypeScript.SyntaxFacts.isAnyPunctuation(kind)) { + return TypeScript.SyntaxFacts.getText(kind); + } + + if (kind === 13 /* NumericLiteral */) { + return TypeScript.IntegerUtilities.isHexInteger(text) ? parseInt(text, 16) : parseFloat(text); + } else if (kind === 14 /* StringLiteral */) { + if (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) { + return massageEscapes(text.substr(1, text.length - 2)); + } else { + return massageEscapes(text.substr(1)); + } + } else if (kind === 12 /* RegularExpressionLiteral */) { + return regularExpressionValue(text); + } else if (kind === 10 /* EndOfFileToken */ || kind === 9 /* ErrorToken */) { + return null; + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + + function regularExpressionValue(text) { + try { + var lastSlash = text.lastIndexOf("/"); + var body = text.substring(1, lastSlash); + var flags = text.substring(lastSlash + 1); + return new RegExp(body, flags); + } catch (e) { + return null; + } + } + + function valueText1(kind, text) { + var value = value1(kind, text); + return value === null ? "" : value.toString(); + } + + function valueText(token) { + var value = token.value(); + return value === null ? "" : value.toString(); + } + Syntax.valueText = valueText; + + var EmptyToken = (function () { + function EmptyToken(kind) { + this.tokenKind = kind; + } + EmptyToken.prototype.clone = function () { + return new EmptyToken(this.tokenKind); + }; + + EmptyToken.prototype.kind = function () { + return this.tokenKind; + }; + + EmptyToken.prototype.isToken = function () { + return true; + }; + EmptyToken.prototype.isNode = function () { + return false; + }; + EmptyToken.prototype.isList = function () { + return false; + }; + EmptyToken.prototype.isSeparatedList = function () { + return false; + }; + + EmptyToken.prototype.childCount = function () { + return 0; + }; + + EmptyToken.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptyToken.prototype.toJSON = function (key) { + return tokenToJSON(this); + }; + EmptyToken.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + + EmptyToken.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + EmptyToken.prototype.firstToken = function () { + return this; + }; + EmptyToken.prototype.lastToken = function () { + return this; + }; + EmptyToken.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptyToken.prototype.isIncrementallyUnusable = function () { + return true; + }; + + EmptyToken.prototype.fullWidth = function () { + return 0; + }; + EmptyToken.prototype.width = function () { + return 0; + }; + EmptyToken.prototype.text = function () { + return ""; + }; + EmptyToken.prototype.fullText = function () { + return ""; + }; + EmptyToken.prototype.value = function () { + return null; + }; + EmptyToken.prototype.valueText = function () { + return ""; + }; + + EmptyToken.prototype.hasLeadingTrivia = function () { + return false; + }; + EmptyToken.prototype.hasLeadingComment = function () { + return false; + }; + EmptyToken.prototype.hasLeadingNewLine = function () { + return false; + }; + EmptyToken.prototype.hasLeadingSkippedText = function () { + return false; + }; + EmptyToken.prototype.leadingTriviaWidth = function () { + return 0; + }; + EmptyToken.prototype.hasTrailingTrivia = function () { + return false; + }; + EmptyToken.prototype.hasTrailingComment = function () { + return false; + }; + EmptyToken.prototype.hasTrailingNewLine = function () { + return false; + }; + EmptyToken.prototype.hasTrailingSkippedText = function () { + return false; + }; + EmptyToken.prototype.hasSkippedToken = function () { + return false; + }; + + EmptyToken.prototype.trailingTriviaWidth = function () { + return 0; + }; + EmptyToken.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + EmptyToken.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + EmptyToken.prototype.realize = function () { + return realizeToken(this); + }; + EmptyToken.prototype.collectTextElements = function (elements) { + }; + + EmptyToken.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + EmptyToken.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + EmptyToken.prototype.isExpression = function () { + return isExpression(this); + }; + + EmptyToken.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return EmptyToken; + })(); + + function emptyToken(kind) { + return new EmptyToken(kind); + } + Syntax.emptyToken = emptyToken; + + var RealizedToken = (function () { + function RealizedToken(tokenKind, leadingTrivia, text, value, valueText, trailingTrivia) { + this.tokenKind = tokenKind; + this._leadingTrivia = leadingTrivia; + this._text = text; + this._value = value; + this._valueText = valueText; + this._trailingTrivia = trailingTrivia; + } + RealizedToken.prototype.clone = function () { + return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia); + }; + + RealizedToken.prototype.kind = function () { + return this.tokenKind; + }; + RealizedToken.prototype.toJSON = function (key) { + return tokenToJSON(this); + }; + RealizedToken.prototype.firstToken = function () { + return this; + }; + RealizedToken.prototype.lastToken = function () { + return this; + }; + RealizedToken.prototype.isTypeScriptSpecific = function () { + return false; + }; + + RealizedToken.prototype.isIncrementallyUnusable = function () { + return true; + }; + + RealizedToken.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + + RealizedToken.prototype.childCount = function () { + return 0; + }; + + RealizedToken.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + RealizedToken.prototype.isToken = function () { + return true; + }; + RealizedToken.prototype.isNode = function () { + return false; + }; + RealizedToken.prototype.isList = function () { + return false; + }; + RealizedToken.prototype.isSeparatedList = function () { + return false; + }; + RealizedToken.prototype.isTrivia = function () { + return false; + }; + RealizedToken.prototype.isTriviaList = function () { + return false; + }; + + RealizedToken.prototype.fullWidth = function () { + return this._leadingTrivia.fullWidth() + this.width() + this._trailingTrivia.fullWidth(); + }; + RealizedToken.prototype.width = function () { + return this.text().length; + }; + + RealizedToken.prototype.text = function () { + return this._text; + }; + RealizedToken.prototype.fullText = function () { + return this._leadingTrivia.fullText() + this.text() + this._trailingTrivia.fullText(); + }; + + RealizedToken.prototype.value = function () { + return this._value; + }; + RealizedToken.prototype.valueText = function () { + return this._valueText; + }; + + RealizedToken.prototype.hasLeadingTrivia = function () { + return this._leadingTrivia.count() > 0; + }; + RealizedToken.prototype.hasLeadingComment = function () { + return this._leadingTrivia.hasComment(); + }; + RealizedToken.prototype.hasLeadingNewLine = function () { + return this._leadingTrivia.hasNewLine(); + }; + RealizedToken.prototype.hasLeadingSkippedText = function () { + return this._leadingTrivia.hasSkippedToken(); + }; + RealizedToken.prototype.leadingTriviaWidth = function () { + return this._leadingTrivia.fullWidth(); + }; + + RealizedToken.prototype.hasTrailingTrivia = function () { + return this._trailingTrivia.count() > 0; + }; + RealizedToken.prototype.hasTrailingComment = function () { + return this._trailingTrivia.hasComment(); + }; + RealizedToken.prototype.hasTrailingNewLine = function () { + return this._trailingTrivia.hasNewLine(); + }; + RealizedToken.prototype.hasTrailingSkippedText = function () { + return this._trailingTrivia.hasSkippedToken(); + }; + RealizedToken.prototype.trailingTriviaWidth = function () { + return this._trailingTrivia.fullWidth(); + }; + + RealizedToken.prototype.hasSkippedToken = function () { + return this.hasLeadingSkippedText() || this.hasTrailingSkippedText(); + }; + + RealizedToken.prototype.leadingTrivia = function () { + return this._leadingTrivia; + }; + RealizedToken.prototype.trailingTrivia = function () { + return this._trailingTrivia; + }; + + RealizedToken.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + RealizedToken.prototype.collectTextElements = function (elements) { + this.leadingTrivia().collectTextElements(elements); + elements.push(this.text()); + this.trailingTrivia().collectTextElements(elements); + }; + + RealizedToken.prototype.withLeadingTrivia = function (leadingTrivia) { + return new RealizedToken(this.tokenKind, leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia); + }; + + RealizedToken.prototype.withTrailingTrivia = function (trailingTrivia) { + return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, trailingTrivia); + }; + + RealizedToken.prototype.isExpression = function () { + return isExpression(this); + }; + + RealizedToken.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return RealizedToken; + })(); + + function token(kind, info) { + if (typeof info === "undefined") { info = null; } + var text = (info !== null && info.text !== undefined) ? info.text : TypeScript.SyntaxFacts.getText(kind); + + return new RealizedToken(kind, TypeScript.Syntax.triviaList(info === null ? null : info.leadingTrivia), text, value1(kind, text), valueText1(kind, text), TypeScript.Syntax.triviaList(info === null ? null : info.trailingTrivia)); + } + Syntax.token = token; + + function identifier(text, info) { + if (typeof info === "undefined") { info = null; } + info = info || {}; + info.text = text; + return token(11 /* IdentifierName */, info); + } + Syntax.identifier = identifier; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTokenReplacer = (function (_super) { + __extends(SyntaxTokenReplacer, _super); + function SyntaxTokenReplacer(token1, token2) { + _super.call(this); + this.token1 = token1; + this.token2 = token2; + } + SyntaxTokenReplacer.prototype.visitToken = function (token) { + if (token === this.token1) { + var result = this.token2; + this.token1 = null; + this.token2 = null; + + return result; + } + + return token; + }; + + SyntaxTokenReplacer.prototype.visitNode = function (node) { + if (this.token1 === null) { + return node; + } + + return _super.prototype.visitNode.call(this, node); + }; + + SyntaxTokenReplacer.prototype.visitList = function (list) { + if (this.token1 === null) { + return list; + } + + return _super.prototype.visitList.call(this, list); + }; + + SyntaxTokenReplacer.prototype.visitSeparatedList = function (list) { + if (this.token1 === null) { + return list; + } + + return _super.prototype.visitSeparatedList.call(this, list); + }; + return SyntaxTokenReplacer; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxTokenReplacer = SyntaxTokenReplacer; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var AbstractTrivia = (function () { + function AbstractTrivia(_kind) { + this._kind = _kind; + } + AbstractTrivia.prototype.fullWidth = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.fullText = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.toJSON = function (key) { + var result = {}; + + for (var name in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind[name] === this._kind) { + result.kind = name; + break; + } + } + + if (this.isSkippedToken()) { + result.skippedToken = this.skippedToken(); + } else { + result.text = this.fullText(); + } + return result; + }; + + AbstractTrivia.prototype.kind = function () { + return this._kind; + }; + + AbstractTrivia.prototype.isWhitespace = function () { + return this.kind() === 4 /* WhitespaceTrivia */; + }; + + AbstractTrivia.prototype.isComment = function () { + return this.kind() === 7 /* SingleLineCommentTrivia */ || this.kind() === 6 /* MultiLineCommentTrivia */; + }; + + AbstractTrivia.prototype.isNewLine = function () { + return this.kind() === 5 /* NewLineTrivia */; + }; + + AbstractTrivia.prototype.isSkippedToken = function () { + return this.kind() === 8 /* SkippedTokenTrivia */; + }; + + AbstractTrivia.prototype.collectTextElements = function (elements) { + elements.push(this.fullText()); + }; + return AbstractTrivia; + })(); + + var NormalTrivia = (function (_super) { + __extends(NormalTrivia, _super); + function NormalTrivia(kind, _text) { + _super.call(this, kind); + this._text = _text; + } + NormalTrivia.prototype.fullWidth = function () { + return this.fullText().length; + }; + + NormalTrivia.prototype.fullText = function () { + return this._text; + }; + + NormalTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.invalidOperation(); + }; + return NormalTrivia; + })(AbstractTrivia); + + var SkippedTokenTrivia = (function (_super) { + __extends(SkippedTokenTrivia, _super); + function SkippedTokenTrivia(_skippedToken) { + _super.call(this, 8 /* SkippedTokenTrivia */); + this._skippedToken = _skippedToken; + } + SkippedTokenTrivia.prototype.fullWidth = function () { + return this.fullText().length; + }; + + SkippedTokenTrivia.prototype.fullText = function () { + return this.skippedToken().fullText(); + }; + + SkippedTokenTrivia.prototype.skippedToken = function () { + return this._skippedToken; + }; + return SkippedTokenTrivia; + })(AbstractTrivia); + + var DeferredTrivia = (function (_super) { + __extends(DeferredTrivia, _super); + function DeferredTrivia(kind, _text, _fullStart, _fullWidth) { + _super.call(this, kind); + this._text = _text; + this._fullStart = _fullStart; + this._fullWidth = _fullWidth; + this._fullText = null; + } + DeferredTrivia.prototype.fullWidth = function () { + return this._fullWidth; + }; + + DeferredTrivia.prototype.fullText = function () { + if (!this._fullText) { + this._fullText = this._text.substr(this._fullStart, this._fullWidth, false); + this._text = null; + } + + return this._fullText; + }; + + DeferredTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.invalidOperation(); + }; + return DeferredTrivia; + })(AbstractTrivia); + + function deferredTrivia(kind, text, fullStart, fullWidth) { + return new DeferredTrivia(kind, text, fullStart, fullWidth); + } + Syntax.deferredTrivia = deferredTrivia; + + function trivia(kind, text) { + return new NormalTrivia(kind, text); + } + Syntax.trivia = trivia; + + function skippedTokenTrivia(token) { + TypeScript.Debug.assert(!token.hasLeadingTrivia()); + TypeScript.Debug.assert(!token.hasTrailingTrivia()); + TypeScript.Debug.assert(token.fullWidth() > 0); + return new SkippedTokenTrivia(token); + } + Syntax.skippedTokenTrivia = skippedTokenTrivia; + + function spaces(count) { + return trivia(4 /* WhitespaceTrivia */, TypeScript.StringUtilities.repeat(" ", count)); + } + Syntax.spaces = spaces; + + function whitespace(text) { + return trivia(4 /* WhitespaceTrivia */, text); + } + Syntax.whitespace = whitespace; + + function multiLineComment(text) { + return trivia(6 /* MultiLineCommentTrivia */, text); + } + Syntax.multiLineComment = multiLineComment; + + function singleLineComment(text) { + return trivia(7 /* SingleLineCommentTrivia */, text); + } + Syntax.singleLineComment = singleLineComment; + + Syntax.spaceTrivia = spaces(1); + Syntax.lineFeedTrivia = trivia(5 /* NewLineTrivia */, "\n"); + Syntax.carriageReturnTrivia = trivia(5 /* NewLineTrivia */, "\r"); + Syntax.carriageReturnLineFeedTrivia = trivia(5 /* NewLineTrivia */, "\r\n"); + + function splitMultiLineCommentTriviaIntoMultipleLines(trivia) { + var result = []; + + var triviaText = trivia.fullText(); + var currentIndex = 0; + + for (var i = 0; i < triviaText.length; i++) { + var ch = triviaText.charCodeAt(i); + + var isCarriageReturnLineFeed = false; + switch (ch) { + case 13 /* carriageReturn */: + if (i < triviaText.length - 1 && triviaText.charCodeAt(i + 1) === 10 /* lineFeed */) { + i++; + } + + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + result.push(triviaText.substring(currentIndex, i + 1)); + + currentIndex = i + 1; + continue; + } + } + + result.push(triviaText.substring(currentIndex)); + return result; + } + Syntax.splitMultiLineCommentTriviaIntoMultipleLines = splitMultiLineCommentTriviaIntoMultipleLines; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + Syntax.emptyTriviaList = { + kind: function () { + return 3 /* TriviaList */; + }, + count: function () { + return 0; + }, + syntaxTriviaAt: function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }, + last: function () { + throw TypeScript.Errors.argumentOutOfRange("index"); + }, + fullWidth: function () { + return 0; + }, + fullText: function () { + return ""; + }, + hasComment: function () { + return false; + }, + hasNewLine: function () { + return false; + }, + hasSkippedToken: function () { + return false; + }, + toJSON: function (key) { + return []; + }, + collectTextElements: function (elements) { + }, + toArray: function () { + return []; + }, + concat: function (trivia) { + return trivia; + } + }; + + function concatTrivia(list1, list2) { + if (list1.count() === 0) { + return list2; + } + + if (list2.count() === 0) { + return list1; + } + + var trivia = list1.toArray(); + trivia.push.apply(trivia, list2.toArray()); + + return triviaList(trivia); + } + + function isComment(trivia) { + return trivia.kind() === 6 /* MultiLineCommentTrivia */ || trivia.kind() === 7 /* SingleLineCommentTrivia */; + } + + var SingletonSyntaxTriviaList = (function () { + function SingletonSyntaxTriviaList(item) { + this.item = item; + } + SingletonSyntaxTriviaList.prototype.kind = function () { + return 3 /* TriviaList */; + }; + + SingletonSyntaxTriviaList.prototype.count = function () { + return 1; + }; + + SingletonSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSyntaxTriviaList.prototype.last = function () { + return this.item; + }; + + SingletonSyntaxTriviaList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSyntaxTriviaList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSyntaxTriviaList.prototype.hasComment = function () { + return isComment(this.item); + }; + + SingletonSyntaxTriviaList.prototype.hasNewLine = function () { + return this.item.kind() === 5 /* NewLineTrivia */; + }; + + SingletonSyntaxTriviaList.prototype.hasSkippedToken = function () { + return this.item.kind() === 8 /* SkippedTokenTrivia */; + }; + + SingletonSyntaxTriviaList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSyntaxTriviaList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSyntaxTriviaList.prototype.toArray = function () { + return [this.item]; + }; + + SingletonSyntaxTriviaList.prototype.concat = function (trivia) { + return concatTrivia(this, trivia); + }; + return SingletonSyntaxTriviaList; + })(); + + var NormalSyntaxTriviaList = (function () { + function NormalSyntaxTriviaList(trivia) { + this.trivia = trivia; + } + NormalSyntaxTriviaList.prototype.kind = function () { + return 3 /* TriviaList */; + }; + + NormalSyntaxTriviaList.prototype.count = function () { + return this.trivia.length; + }; + + NormalSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) { + if (index < 0 || index >= this.trivia.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.trivia[index]; + }; + + NormalSyntaxTriviaList.prototype.last = function () { + return this.trivia[this.trivia.length - 1]; + }; + + NormalSyntaxTriviaList.prototype.fullWidth = function () { + return TypeScript.ArrayUtilities.sum(this.trivia, function (t) { + return t.fullWidth(); + }); + }; + + NormalSyntaxTriviaList.prototype.fullText = function () { + var result = ""; + + for (var i = 0, n = this.trivia.length; i < n; i++) { + result += this.trivia[i].fullText(); + } + + return result; + }; + + NormalSyntaxTriviaList.prototype.hasComment = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (isComment(this.trivia[i])) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.hasNewLine = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (this.trivia[i].kind() === 5 /* NewLineTrivia */) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.hasSkippedToken = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (this.trivia[i].kind() === 8 /* SkippedTokenTrivia */) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.toJSON = function (key) { + return this.trivia; + }; + + NormalSyntaxTriviaList.prototype.collectTextElements = function (elements) { + for (var i = 0; i < this.trivia.length; i++) { + this.trivia[i].collectTextElements(elements); + } + }; + + NormalSyntaxTriviaList.prototype.toArray = function () { + return this.trivia.slice(0); + }; + + NormalSyntaxTriviaList.prototype.concat = function (trivia) { + return concatTrivia(this, trivia); + }; + return NormalSyntaxTriviaList; + })(); + + function triviaList(trivia) { + if (trivia === undefined || trivia === null || trivia.length === 0) { + return Syntax.emptyTriviaList; + } + + if (trivia.length === 1) { + return new SingletonSyntaxTriviaList(trivia[0]); + } + + return new NormalSyntaxTriviaList(trivia); + } + Syntax.triviaList = triviaList; + + Syntax.spaceTriviaList = triviaList([TypeScript.Syntax.spaceTrivia]); + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxUtilities = (function () { + function SyntaxUtilities() { + } + SyntaxUtilities.isAngleBracket = function (positionedElement) { + var element = positionedElement.element(); + var parent = positionedElement.parentElement(); + if (parent !== null && (element.kind() === 80 /* LessThanToken */ || element.kind() === 81 /* GreaterThanToken */)) { + switch (parent.kind()) { + case 228 /* TypeArgumentList */: + case 229 /* TypeParameterList */: + case 220 /* CastExpression */: + return true; + } + } + + return false; + }; + + SyntaxUtilities.getToken = function (list, kind) { + for (var i = 0, n = list.childCount(); i < n; i++) { + var token = list.childAt(i); + if (token.tokenKind === kind) { + return token; + } + } + + return null; + }; + + SyntaxUtilities.containsToken = function (list, kind) { + return SyntaxUtilities.getToken(list, kind) !== null; + }; + + SyntaxUtilities.hasExportKeyword = function (moduleElement) { + return SyntaxUtilities.getExportKeyword(moduleElement) !== null; + }; + + SyntaxUtilities.getExportKeyword = function (moduleElement) { + switch (moduleElement.kind()) { + case 130 /* ModuleDeclaration */: + case 131 /* ClassDeclaration */: + case 129 /* FunctionDeclaration */: + case 148 /* VariableStatement */: + case 132 /* EnumDeclaration */: + case 128 /* InterfaceDeclaration */: + case 133 /* ImportDeclaration */: + return SyntaxUtilities.getToken(moduleElement.modifiers, 47 /* ExportKeyword */); + default: + return null; + } + }; + + SyntaxUtilities.isAmbientDeclarationSyntax = function (positionNode) { + if (!positionNode) { + return false; + } + + var node = positionNode.node(); + switch (node.kind()) { + case 130 /* ModuleDeclaration */: + case 131 /* ClassDeclaration */: + case 129 /* FunctionDeclaration */: + case 148 /* VariableStatement */: + case 132 /* EnumDeclaration */: + if (SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + return true; + } + + case 133 /* ImportDeclaration */: + case 137 /* ConstructorDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + case 136 /* MemberVariableDeclaration */: + if (node.isClassElement() || node.isModuleElement()) { + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode()); + } + + case 243 /* EnumElement */: + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode().containingNode()); + + default: + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode()); + } + }; + return SyntaxUtilities; + })(); + TypeScript.SyntaxUtilities = SyntaxUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxVisitor = (function () { + function SyntaxVisitor() { + } + SyntaxVisitor.prototype.defaultVisit = function (node) { + return null; + }; + + SyntaxVisitor.prototype.visitToken = function (token) { + return this.defaultVisit(token); + }; + + SyntaxVisitor.prototype.visitSourceUnit = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExternalModuleReference = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitModuleNameModuleReference = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitImportDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExportAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitClassDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitInterfaceDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitHeritageClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitModuleDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableDeclarator = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEqualsValueClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPrefixUnaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArrayLiteralExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitOmittedExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParenthesizedExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitQualifiedName = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeArgumentList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructorType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArrayType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitGenericType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeQuery = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeAnnotation = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBlock = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParameter = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberAccessExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPostfixUnaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitElementAccessExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitInvocationExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArgumentList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBinaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConditionalExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMethodSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIndexSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPropertySignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCallSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParameterList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeParameterList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeParameter = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstraint = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitElseClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIfStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExpressionStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructorDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitGetAccessor = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSetAccessor = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberVariableDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIndexMemberDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitThrowStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitReturnStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectCreationExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSwitchStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCaseSwitchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDefaultSwitchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBreakStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitContinueStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitForStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitForInStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitWhileStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitWithStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEnumDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEnumElement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCastExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectLiteralExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSimplePropertyAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEmptyStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTryStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCatchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFinallyClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitLabeledStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDoStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeOfExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDeleteExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVoidExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDebuggerStatement = function (node) { + return this.defaultVisit(node); + }; + return SyntaxVisitor; + })(); + TypeScript.SyntaxVisitor = SyntaxVisitor; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxWalker = (function () { + function SyntaxWalker() { + } + SyntaxWalker.prototype.visitToken = function (token) { + }; + + SyntaxWalker.prototype.visitNode = function (node) { + node.accept(this); + }; + + SyntaxWalker.prototype.visitNodeOrToken = function (nodeOrToken) { + if (nodeOrToken.isToken()) { + this.visitToken(nodeOrToken); + } else { + this.visitNode(nodeOrToken); + } + }; + + SyntaxWalker.prototype.visitOptionalToken = function (token) { + if (token === null) { + return; + } + + this.visitToken(token); + }; + + SyntaxWalker.prototype.visitOptionalNode = function (node) { + if (node === null) { + return; + } + + this.visitNode(node); + }; + + SyntaxWalker.prototype.visitOptionalNodeOrToken = function (nodeOrToken) { + if (nodeOrToken === null) { + return; + } + + this.visitNodeOrToken(nodeOrToken); + }; + + SyntaxWalker.prototype.visitList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + this.visitNodeOrToken(list.childAt(i)); + } + }; + + SyntaxWalker.prototype.visitSeparatedList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + this.visitNodeOrToken(item); + } + }; + + SyntaxWalker.prototype.visitSourceUnit = function (node) { + this.visitList(node.moduleElements); + this.visitToken(node.endOfFileToken); + }; + + SyntaxWalker.prototype.visitExternalModuleReference = function (node) { + this.visitToken(node.requireKeyword); + this.visitToken(node.openParenToken); + this.visitToken(node.stringLiteral); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitModuleNameModuleReference = function (node) { + this.visitNodeOrToken(node.moduleName); + }; + + SyntaxWalker.prototype.visitImportDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.importKeyword); + this.visitToken(node.identifier); + this.visitToken(node.equalsToken); + this.visitNodeOrToken(node.moduleReference); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitExportAssignment = function (node) { + this.visitToken(node.exportKeyword); + this.visitToken(node.equalsToken); + this.visitToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitClassDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.classKeyword); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeParameterList); + this.visitList(node.heritageClauses); + this.visitToken(node.openBraceToken); + this.visitList(node.classElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.interfaceKeyword); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeParameterList); + this.visitList(node.heritageClauses); + this.visitNode(node.body); + }; + + SyntaxWalker.prototype.visitHeritageClause = function (node) { + this.visitToken(node.extendsOrImplementsKeyword); + this.visitSeparatedList(node.typeNames); + }; + + SyntaxWalker.prototype.visitModuleDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.moduleKeyword); + this.visitOptionalNodeOrToken(node.name); + this.visitOptionalToken(node.stringLiteral); + this.visitToken(node.openBraceToken); + this.visitList(node.moduleElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitFunctionDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.functionKeyword); + this.visitToken(node.identifier); + this.visitNode(node.callSignature); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitVariableStatement = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.variableDeclaration); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitVariableDeclaration = function (node) { + this.visitToken(node.varKeyword); + this.visitSeparatedList(node.variableDeclarators); + }; + + SyntaxWalker.prototype.visitVariableDeclarator = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalNode(node.typeAnnotation); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitEqualsValueClause = function (node) { + this.visitToken(node.equalsToken); + this.visitNodeOrToken(node.value); + }; + + SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) { + this.visitToken(node.operatorToken); + this.visitNodeOrToken(node.operand); + }; + + SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) { + this.visitToken(node.openBracketToken); + this.visitSeparatedList(node.expressions); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitOmittedExpression = function (node) { + }; + + SyntaxWalker.prototype.visitParenthesizedExpression = function (node) { + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitSimpleArrowFunctionExpression = function (node) { + this.visitToken(node.identifier); + this.visitToken(node.equalsGreaterThanToken); + this.visitOptionalNode(node.block); + this.visitOptionalNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + this.visitNode(node.callSignature); + this.visitToken(node.equalsGreaterThanToken); + this.visitOptionalNode(node.block); + this.visitOptionalNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitQualifiedName = function (node) { + this.visitNodeOrToken(node.left); + this.visitToken(node.dotToken); + this.visitToken(node.right); + }; + + SyntaxWalker.prototype.visitTypeArgumentList = function (node) { + this.visitToken(node.lessThanToken); + this.visitSeparatedList(node.typeArguments); + this.visitToken(node.greaterThanToken); + }; + + SyntaxWalker.prototype.visitConstructorType = function (node) { + this.visitToken(node.newKeyword); + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitToken(node.equalsGreaterThanToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitFunctionType = function (node) { + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitToken(node.equalsGreaterThanToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitObjectType = function (node) { + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.typeMembers); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitArrayType = function (node) { + this.visitNodeOrToken(node.type); + this.visitToken(node.openBracketToken); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitGenericType = function (node) { + this.visitNodeOrToken(node.name); + this.visitNode(node.typeArgumentList); + }; + + SyntaxWalker.prototype.visitTypeQuery = function (node) { + this.visitToken(node.typeOfKeyword); + this.visitNodeOrToken(node.name); + }; + + SyntaxWalker.prototype.visitTypeAnnotation = function (node) { + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitBlock = function (node) { + this.visitToken(node.openBraceToken); + this.visitList(node.statements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitParameter = function (node) { + this.visitOptionalToken(node.dotDotDotToken); + this.visitList(node.modifiers); + this.visitToken(node.identifier); + this.visitOptionalToken(node.questionToken); + this.visitOptionalNode(node.typeAnnotation); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitMemberAccessExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.dotToken); + this.visitToken(node.name); + }; + + SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) { + this.visitNodeOrToken(node.operand); + this.visitToken(node.operatorToken); + }; + + SyntaxWalker.prototype.visitElementAccessExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.openBracketToken); + this.visitNodeOrToken(node.argumentExpression); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitInvocationExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitNode(node.argumentList); + }; + + SyntaxWalker.prototype.visitArgumentList = function (node) { + this.visitOptionalNode(node.typeArgumentList); + this.visitToken(node.openParenToken); + this.visitSeparatedList(node.arguments); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitBinaryExpression = function (node) { + this.visitNodeOrToken(node.left); + this.visitToken(node.operatorToken); + this.visitNodeOrToken(node.right); + }; + + SyntaxWalker.prototype.visitConditionalExpression = function (node) { + this.visitNodeOrToken(node.condition); + this.visitToken(node.questionToken); + this.visitNodeOrToken(node.whenTrue); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.whenFalse); + }; + + SyntaxWalker.prototype.visitConstructSignature = function (node) { + this.visitToken(node.newKeyword); + this.visitNode(node.callSignature); + }; + + SyntaxWalker.prototype.visitMethodSignature = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalToken(node.questionToken); + this.visitNode(node.callSignature); + }; + + SyntaxWalker.prototype.visitIndexSignature = function (node) { + this.visitToken(node.openBracketToken); + this.visitNode(node.parameter); + this.visitToken(node.closeBracketToken); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitPropertySignature = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalToken(node.questionToken); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitCallSignature = function (node) { + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitParameterList = function (node) { + this.visitToken(node.openParenToken); + this.visitSeparatedList(node.parameters); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitTypeParameterList = function (node) { + this.visitToken(node.lessThanToken); + this.visitSeparatedList(node.typeParameters); + this.visitToken(node.greaterThanToken); + }; + + SyntaxWalker.prototype.visitTypeParameter = function (node) { + this.visitToken(node.identifier); + this.visitOptionalNode(node.constraint); + }; + + SyntaxWalker.prototype.visitConstraint = function (node) { + this.visitToken(node.extendsKeyword); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitElseClause = function (node) { + this.visitToken(node.elseKeyword); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitIfStatement = function (node) { + this.visitToken(node.ifKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + this.visitOptionalNode(node.elseClause); + }; + + SyntaxWalker.prototype.visitExpressionStatement = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitConstructorDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.constructorKeyword); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitMemberFunctionDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.propertyName); + this.visitNode(node.callSignature); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitGetAccessor = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.getKeyword); + this.visitToken(node.propertyName); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.typeAnnotation); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitSetAccessor = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.setKeyword); + this.visitToken(node.propertyName); + this.visitNode(node.parameterList); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitMemberVariableDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.variableDeclarator); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitIndexMemberDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.indexSignature); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitThrowStatement = function (node) { + this.visitToken(node.throwKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitReturnStatement = function (node) { + this.visitToken(node.returnKeyword); + this.visitOptionalNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitObjectCreationExpression = function (node) { + this.visitToken(node.newKeyword); + this.visitNodeOrToken(node.expression); + this.visitOptionalNode(node.argumentList); + }; + + SyntaxWalker.prototype.visitSwitchStatement = function (node) { + this.visitToken(node.switchKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + this.visitToken(node.openBraceToken); + this.visitList(node.switchClauses); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitCaseSwitchClause = function (node) { + this.visitToken(node.caseKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.colonToken); + this.visitList(node.statements); + }; + + SyntaxWalker.prototype.visitDefaultSwitchClause = function (node) { + this.visitToken(node.defaultKeyword); + this.visitToken(node.colonToken); + this.visitList(node.statements); + }; + + SyntaxWalker.prototype.visitBreakStatement = function (node) { + this.visitToken(node.breakKeyword); + this.visitOptionalToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitContinueStatement = function (node) { + this.visitToken(node.continueKeyword); + this.visitOptionalToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitForStatement = function (node) { + this.visitToken(node.forKeyword); + this.visitToken(node.openParenToken); + this.visitOptionalNode(node.variableDeclaration); + this.visitOptionalNodeOrToken(node.initializer); + this.visitToken(node.firstSemicolonToken); + this.visitOptionalNodeOrToken(node.condition); + this.visitToken(node.secondSemicolonToken); + this.visitOptionalNodeOrToken(node.incrementor); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitForInStatement = function (node) { + this.visitToken(node.forKeyword); + this.visitToken(node.openParenToken); + this.visitOptionalNode(node.variableDeclaration); + this.visitOptionalNodeOrToken(node.left); + this.visitToken(node.inKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitWhileStatement = function (node) { + this.visitToken(node.whileKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitWithStatement = function (node) { + this.visitToken(node.withKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitEnumDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.enumKeyword); + this.visitToken(node.identifier); + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.enumElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitEnumElement = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitCastExpression = function (node) { + this.visitToken(node.lessThanToken); + this.visitNodeOrToken(node.type); + this.visitToken(node.greaterThanToken); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) { + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.propertyAssignments); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitSimplePropertyAssignment = function (node) { + this.visitToken(node.propertyName); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitFunctionPropertyAssignment = function (node) { + this.visitToken(node.propertyName); + this.visitNode(node.callSignature); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitFunctionExpression = function (node) { + this.visitToken(node.functionKeyword); + this.visitOptionalToken(node.identifier); + this.visitNode(node.callSignature); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitEmptyStatement = function (node) { + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitTryStatement = function (node) { + this.visitToken(node.tryKeyword); + this.visitNode(node.block); + this.visitOptionalNode(node.catchClause); + this.visitOptionalNode(node.finallyClause); + }; + + SyntaxWalker.prototype.visitCatchClause = function (node) { + this.visitToken(node.catchKeyword); + this.visitToken(node.openParenToken); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeAnnotation); + this.visitToken(node.closeParenToken); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitFinallyClause = function (node) { + this.visitToken(node.finallyKeyword); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitLabeledStatement = function (node) { + this.visitToken(node.identifier); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitDoStatement = function (node) { + this.visitToken(node.doKeyword); + this.visitNodeOrToken(node.statement); + this.visitToken(node.whileKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitTypeOfExpression = function (node) { + this.visitToken(node.typeOfKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitDeleteExpression = function (node) { + this.visitToken(node.deleteKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitVoidExpression = function (node) { + this.visitToken(node.voidKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitDebuggerStatement = function (node) { + this.visitToken(node.debuggerKeyword); + this.visitToken(node.semicolonToken); + }; + return SyntaxWalker; + })(); + TypeScript.SyntaxWalker = SyntaxWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PositionTrackingWalker = (function (_super) { + __extends(PositionTrackingWalker, _super); + function PositionTrackingWalker() { + _super.apply(this, arguments); + this._position = 0; + } + PositionTrackingWalker.prototype.visitToken = function (token) { + this._position += token.fullWidth(); + }; + + PositionTrackingWalker.prototype.position = function () { + return this._position; + }; + + PositionTrackingWalker.prototype.skip = function (element) { + this._position += element.fullWidth(); + }; + return PositionTrackingWalker; + })(TypeScript.SyntaxWalker); + TypeScript.PositionTrackingWalker = PositionTrackingWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxInformationMap = (function (_super) { + __extends(SyntaxInformationMap, _super); + function SyntaxInformationMap(trackParents, trackPreviousToken) { + _super.call(this); + this.trackParents = trackParents; + this.trackPreviousToken = trackPreviousToken; + this.tokenToInformation = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this.elementToPosition = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this._previousToken = null; + this._previousTokenInformation = null; + this._currentPosition = 0; + this._elementToParent = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this._parentStack = []; + this._parentStack.push(null); + } + SyntaxInformationMap.create = function (node, trackParents, trackPreviousToken) { + var map = new SyntaxInformationMap(trackParents, trackPreviousToken); + map.visitNode(node); + return map; + }; + + SyntaxInformationMap.prototype.visitNode = function (node) { + this.trackParents && this._elementToParent.add(node, TypeScript.ArrayUtilities.last(this._parentStack)); + this.elementToPosition.add(node, this._currentPosition); + + this.trackParents && this._parentStack.push(node); + _super.prototype.visitNode.call(this, node); + this.trackParents && this._parentStack.pop(); + }; + + SyntaxInformationMap.prototype.visitToken = function (token) { + this.trackParents && this._elementToParent.add(token, TypeScript.ArrayUtilities.last(this._parentStack)); + + if (this.trackPreviousToken) { + var tokenInformation = { + previousToken: this._previousToken, + nextToken: null + }; + + if (this._previousTokenInformation !== null) { + this._previousTokenInformation.nextToken = token; + } + + this._previousToken = token; + this._previousTokenInformation = tokenInformation; + + this.tokenToInformation.add(token, tokenInformation); + } + + this.elementToPosition.add(token, this._currentPosition); + this._currentPosition += token.fullWidth(); + }; + + SyntaxInformationMap.prototype.parent = function (element) { + return this._elementToParent.get(element); + }; + + SyntaxInformationMap.prototype.fullStart = function (element) { + return this.elementToPosition.get(element); + }; + + SyntaxInformationMap.prototype.start = function (element) { + return this.fullStart(element) + element.leadingTriviaWidth(); + }; + + SyntaxInformationMap.prototype.end = function (element) { + return this.start(element) + element.width(); + }; + + SyntaxInformationMap.prototype.previousToken = function (token) { + return this.tokenInformation(token).previousToken; + }; + + SyntaxInformationMap.prototype.tokenInformation = function (token) { + return this.tokenToInformation.get(token); + }; + + SyntaxInformationMap.prototype.firstTokenInLineContainingToken = function (token) { + var current = token; + while (true) { + var information = this.tokenInformation(current); + if (this.isFirstTokenInLineWorker(information)) { + break; + } + + current = information.previousToken; + } + + return current; + }; + + SyntaxInformationMap.prototype.isFirstTokenInLine = function (token) { + var information = this.tokenInformation(token); + return this.isFirstTokenInLineWorker(information); + }; + + SyntaxInformationMap.prototype.isFirstTokenInLineWorker = function (information) { + return information.previousToken === null || information.previousToken.hasTrailingNewLine(); + }; + return SyntaxInformationMap; + })(TypeScript.SyntaxWalker); + TypeScript.SyntaxInformationMap = SyntaxInformationMap; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxNodeInvariantsChecker = (function (_super) { + __extends(SyntaxNodeInvariantsChecker, _super); + function SyntaxNodeInvariantsChecker() { + _super.apply(this, arguments); + this.tokenTable = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + } + SyntaxNodeInvariantsChecker.checkInvariants = function (node) { + node.accept(new SyntaxNodeInvariantsChecker()); + }; + + SyntaxNodeInvariantsChecker.prototype.visitToken = function (token) { + this.tokenTable.add(token, token); + }; + return SyntaxNodeInvariantsChecker; + })(TypeScript.SyntaxWalker); + TypeScript.SyntaxNodeInvariantsChecker = SyntaxNodeInvariantsChecker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var DepthLimitedWalker = (function (_super) { + __extends(DepthLimitedWalker, _super); + function DepthLimitedWalker(maximumDepth) { + _super.call(this); + this._depth = 0; + this._maximumDepth = 0; + this._maximumDepth = maximumDepth; + } + DepthLimitedWalker.prototype.visitNode = function (node) { + if (this._depth < this._maximumDepth) { + this._depth++; + _super.prototype.visitNode.call(this, node); + this._depth--; + } else { + this.skip(node); + } + }; + return DepthLimitedWalker; + })(TypeScript.PositionTrackingWalker); + TypeScript.DepthLimitedWalker = DepthLimitedWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Parser) { + + + var ExpressionPrecedence; + (function (ExpressionPrecedence) { + ExpressionPrecedence[ExpressionPrecedence["CommaExpressionPrecedence"] = 1] = "CommaExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["AssignmentExpressionPrecedence"] = 2] = "AssignmentExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["ConditionalExpressionPrecedence"] = 3] = "ConditionalExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["ArrowFunctionPrecedence"] = 4] = "ArrowFunctionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["LogicalOrExpressionPrecedence"] = 5] = "LogicalOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["LogicalAndExpressionPrecedence"] = 6] = "LogicalAndExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseOrExpressionPrecedence"] = 7] = "BitwiseOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseExclusiveOrExpressionPrecedence"] = 8] = "BitwiseExclusiveOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseAndExpressionPrecedence"] = 9] = "BitwiseAndExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["EqualityExpressionPrecedence"] = 10] = "EqualityExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["RelationalExpressionPrecedence"] = 11] = "RelationalExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["ShiftExpressionPrecdence"] = 12] = "ShiftExpressionPrecdence"; + ExpressionPrecedence[ExpressionPrecedence["AdditiveExpressionPrecedence"] = 13] = "AdditiveExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["MultiplicativeExpressionPrecedence"] = 14] = "MultiplicativeExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["UnaryExpressionPrecedence"] = 15] = "UnaryExpressionPrecedence"; + })(ExpressionPrecedence || (ExpressionPrecedence = {})); + + var ListParsingState; + (function (ListParsingState) { + ListParsingState[ListParsingState["SourceUnit_ModuleElements"] = 1 << 0] = "SourceUnit_ModuleElements"; + ListParsingState[ListParsingState["ClassDeclaration_ClassElements"] = 1 << 1] = "ClassDeclaration_ClassElements"; + ListParsingState[ListParsingState["ModuleDeclaration_ModuleElements"] = 1 << 2] = "ModuleDeclaration_ModuleElements"; + ListParsingState[ListParsingState["SwitchStatement_SwitchClauses"] = 1 << 3] = "SwitchStatement_SwitchClauses"; + ListParsingState[ListParsingState["SwitchClause_Statements"] = 1 << 4] = "SwitchClause_Statements"; + ListParsingState[ListParsingState["Block_Statements"] = 1 << 5] = "Block_Statements"; + ListParsingState[ListParsingState["TryBlock_Statements"] = 1 << 6] = "TryBlock_Statements"; + ListParsingState[ListParsingState["CatchBlock_Statements"] = 1 << 7] = "CatchBlock_Statements"; + ListParsingState[ListParsingState["EnumDeclaration_EnumElements"] = 1 << 8] = "EnumDeclaration_EnumElements"; + ListParsingState[ListParsingState["ObjectType_TypeMembers"] = 1 << 9] = "ObjectType_TypeMembers"; + ListParsingState[ListParsingState["ClassOrInterfaceDeclaration_HeritageClauses"] = 1 << 10] = "ClassOrInterfaceDeclaration_HeritageClauses"; + ListParsingState[ListParsingState["HeritageClause_TypeNameList"] = 1 << 11] = "HeritageClause_TypeNameList"; + ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_AllowIn"] = 1 << 12] = "VariableDeclaration_VariableDeclarators_AllowIn"; + ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_DisallowIn"] = 1 << 13] = "VariableDeclaration_VariableDeclarators_DisallowIn"; + ListParsingState[ListParsingState["ArgumentList_AssignmentExpressions"] = 1 << 14] = "ArgumentList_AssignmentExpressions"; + ListParsingState[ListParsingState["ObjectLiteralExpression_PropertyAssignments"] = 1 << 15] = "ObjectLiteralExpression_PropertyAssignments"; + ListParsingState[ListParsingState["ArrayLiteralExpression_AssignmentExpressions"] = 1 << 16] = "ArrayLiteralExpression_AssignmentExpressions"; + ListParsingState[ListParsingState["ParameterList_Parameters"] = 1 << 17] = "ParameterList_Parameters"; + ListParsingState[ListParsingState["TypeArgumentList_Types"] = 1 << 18] = "TypeArgumentList_Types"; + ListParsingState[ListParsingState["TypeParameterList_TypeParameters"] = 1 << 19] = "TypeParameterList_TypeParameters"; + + ListParsingState[ListParsingState["FirstListParsingState"] = ListParsingState.SourceUnit_ModuleElements] = "FirstListParsingState"; + ListParsingState[ListParsingState["LastListParsingState"] = ListParsingState.TypeArgumentList_Types] = "LastListParsingState"; + })(ListParsingState || (ListParsingState = {})); + + var SyntaxCursor = (function () { + function SyntaxCursor(sourceUnit) { + this._elements = []; + this._index = 0; + this._pinCount = 0; + sourceUnit.insertChildrenInto(this._elements, 0); + } + SyntaxCursor.prototype.isFinished = function () { + return this._index === this._elements.length; + }; + + SyntaxCursor.prototype.currentElement = function () { + if (this.isFinished()) { + return null; + } + + return this._elements[this._index]; + }; + + SyntaxCursor.prototype.currentNode = function () { + var element = this.currentElement(); + return element !== null && element.isNode() ? element : null; + }; + + SyntaxCursor.prototype.moveToFirstChild = function () { + if (this.isFinished()) { + return; + } + + var element = this._elements[this._index]; + if (element.isToken()) { + return; + } + + var node = element; + + this._elements.splice(this._index, 1); + + node.insertChildrenInto(this._elements, this._index); + }; + + SyntaxCursor.prototype.moveToNextSibling = function () { + if (this.isFinished()) { + return; + } + + if (this._pinCount > 0) { + this._index++; + return; + } + + this._elements.shift(); + }; + + SyntaxCursor.prototype.getAndPinCursorIndex = function () { + this._pinCount++; + return this._index; + }; + + SyntaxCursor.prototype.releaseAndUnpinCursorIndex = function (index) { + this._pinCount--; + if (this._pinCount === 0) { + } + }; + + SyntaxCursor.prototype.rewindToPinnedCursorIndex = function (index) { + this._index = index; + }; + + SyntaxCursor.prototype.pinCount = function () { + return this._pinCount; + }; + + SyntaxCursor.prototype.moveToFirstToken = function () { + var element; + + while (!this.isFinished()) { + element = this.currentElement(); + if (element.isNode()) { + this.moveToFirstChild(); + continue; + } + + return; + } + }; + + SyntaxCursor.prototype.currentToken = function () { + this.moveToFirstToken(); + if (this.isFinished()) { + return null; + } + + var element = this.currentElement(); + + return element; + }; + + SyntaxCursor.prototype.peekToken = function (n) { + this.moveToFirstToken(); + var pin = this.getAndPinCursorIndex(); + + for (var i = 0; i < n; i++) { + this.moveToNextSibling(); + this.moveToFirstToken(); + } + + var result = this.currentToken(); + this.rewindToPinnedCursorIndex(pin); + this.releaseAndUnpinCursorIndex(pin); + + return result; + }; + return SyntaxCursor; + })(); + + + + var NormalParserSource = (function () { + function NormalParserSource(fileName, text, languageVersion) { + this._previousToken = null; + this._absolutePosition = 0; + this._tokenDiagnostics = []; + this.rewindPointPool = []; + this.rewindPointPoolCount = 0; + this.slidingWindow = new TypeScript.SlidingWindow(this, TypeScript.ArrayUtilities.createArray(32, null), null); + this.scanner = new TypeScript.Scanner(fileName, text, languageVersion); + } + NormalParserSource.prototype.currentNode = function () { + return null; + }; + + NormalParserSource.prototype.moveToNextNode = function () { + throw TypeScript.Errors.invalidOperation(); + }; + + NormalParserSource.prototype.absolutePosition = function () { + return this._absolutePosition; + }; + + NormalParserSource.prototype.previousToken = function () { + return this._previousToken; + }; + + NormalParserSource.prototype.tokenDiagnostics = function () { + return this._tokenDiagnostics; + }; + + NormalParserSource.prototype.getOrCreateRewindPoint = function () { + if (this.rewindPointPoolCount === 0) { + return {}; + } + + this.rewindPointPoolCount--; + var result = this.rewindPointPool[this.rewindPointPoolCount]; + this.rewindPointPool[this.rewindPointPoolCount] = null; + return result; + }; + + NormalParserSource.prototype.getRewindPoint = function () { + var slidingWindowIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + var rewindPoint = this.getOrCreateRewindPoint(); + + rewindPoint.slidingWindowIndex = slidingWindowIndex; + rewindPoint.previousToken = this._previousToken; + rewindPoint.absolutePosition = this._absolutePosition; + + rewindPoint.pinCount = this.slidingWindow.pinCount(); + + return rewindPoint; + }; + + NormalParserSource.prototype.isPinned = function () { + return this.slidingWindow.pinCount() > 0; + }; + + NormalParserSource.prototype.rewind = function (rewindPoint) { + this.slidingWindow.rewindToPinnedIndex(rewindPoint.slidingWindowIndex); + + this._previousToken = rewindPoint.previousToken; + this._absolutePosition = rewindPoint.absolutePosition; + }; + + NormalParserSource.prototype.releaseRewindPoint = function (rewindPoint) { + this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint.absoluteIndex); + + this.rewindPointPool[this.rewindPointPoolCount] = rewindPoint; + this.rewindPointPoolCount++; + }; + + NormalParserSource.prototype.fetchMoreItems = function (allowRegularExpression, sourceIndex, window, destinationIndex, spaceAvailable) { + window[destinationIndex] = this.scanner.scan(this._tokenDiagnostics, allowRegularExpression); + return 1; + }; + + NormalParserSource.prototype.peekToken = function (n) { + return this.slidingWindow.peekItemN(n); + }; + + NormalParserSource.prototype.moveToNextToken = function () { + var currentToken = this.currentToken(); + this._absolutePosition += currentToken.fullWidth(); + this._previousToken = currentToken; + + this.slidingWindow.moveToNextItem(); + }; + + NormalParserSource.prototype.currentToken = function () { + return this.slidingWindow.currentItem(false); + }; + + NormalParserSource.prototype.removeDiagnosticsOnOrAfterPosition = function (position) { + var tokenDiagnosticsLength = this._tokenDiagnostics.length; + while (tokenDiagnosticsLength > 0) { + var diagnostic = this._tokenDiagnostics[tokenDiagnosticsLength - 1]; + if (diagnostic.start() >= position) { + tokenDiagnosticsLength--; + } else { + break; + } + } + + this._tokenDiagnostics.length = tokenDiagnosticsLength; + }; + + NormalParserSource.prototype.resetToPosition = function (absolutePosition, previousToken) { + this._absolutePosition = absolutePosition; + this._previousToken = previousToken; + + this.removeDiagnosticsOnOrAfterPosition(absolutePosition); + + this.slidingWindow.disgardAllItemsFromCurrentIndexOnwards(); + + this.scanner.setAbsoluteIndex(absolutePosition); + }; + + NormalParserSource.prototype.currentTokenAllowingRegularExpression = function () { + this.resetToPosition(this._absolutePosition, this._previousToken); + + var token = this.slidingWindow.currentItem(true); + + return token; + }; + return NormalParserSource; + })(); + + var IncrementalParserSource = (function () { + function IncrementalParserSource(oldSyntaxTree, textChangeRange, newText) { + this._changeDelta = 0; + var oldSourceUnit = oldSyntaxTree.sourceUnit(); + this._oldSourceUnitCursor = new SyntaxCursor(oldSourceUnit); + + this._changeRange = IncrementalParserSource.extendToAffectedRange(textChangeRange, oldSourceUnit); + + if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) { + TypeScript.Debug.assert((oldSourceUnit.fullWidth() - this._changeRange.span().length() + this._changeRange.newLength()) === newText.length()); + } + + this._normalParserSource = new NormalParserSource(oldSyntaxTree.fileName(), newText, oldSyntaxTree.parseOptions().languageVersion()); + } + IncrementalParserSource.extendToAffectedRange = function (changeRange, sourceUnit) { + var maxLookahead = 1; + + var start = changeRange.span().start(); + + for (var i = 0; start > 0 && i <= maxLookahead; i++) { + var token = sourceUnit.findToken(start); + + var position = token.fullStart(); + + start = TypeScript.MathPrototype.max(0, position - 1); + } + + var finalSpan = TypeScript.TextSpan.fromBounds(start, changeRange.span().end()); + var finalLength = changeRange.newLength() + (changeRange.span().start() - start); + + return new TypeScript.TextChangeRange(finalSpan, finalLength); + }; + + IncrementalParserSource.prototype.absolutePosition = function () { + return this._normalParserSource.absolutePosition(); + }; + + IncrementalParserSource.prototype.previousToken = function () { + return this._normalParserSource.previousToken(); + }; + + IncrementalParserSource.prototype.tokenDiagnostics = function () { + return this._normalParserSource.tokenDiagnostics(); + }; + + IncrementalParserSource.prototype.getRewindPoint = function () { + var rewindPoint = this._normalParserSource.getRewindPoint(); + var oldSourceUnitCursorIndex = this._oldSourceUnitCursor.getAndPinCursorIndex(); + + rewindPoint.changeDelta = this._changeDelta; + rewindPoint.changeRange = this._changeRange; + rewindPoint.oldSourceUnitCursorIndex = oldSourceUnitCursorIndex; + + return rewindPoint; + }; + + IncrementalParserSource.prototype.rewind = function (rewindPoint) { + this._changeRange = rewindPoint.changeRange; + this._changeDelta = rewindPoint.changeDelta; + this._oldSourceUnitCursor.rewindToPinnedCursorIndex(rewindPoint.oldSourceUnitCursorIndex); + + this._normalParserSource.rewind(rewindPoint); + }; + + IncrementalParserSource.prototype.releaseRewindPoint = function (rewindPoint) { + this._oldSourceUnitCursor.releaseAndUnpinCursorIndex(rewindPoint.oldSourceUnitCursorIndex); + this._normalParserSource.releaseRewindPoint(rewindPoint); + }; + + IncrementalParserSource.prototype.canReadFromOldSourceUnit = function () { + if (this._normalParserSource.isPinned()) { + return false; + } + + if (this._changeRange !== null && this._changeRange.newSpan().intersectsWithPosition(this.absolutePosition())) { + return false; + } + + this.syncCursorToNewTextIfBehind(); + + return this._changeDelta === 0 && !this._oldSourceUnitCursor.isFinished(); + }; + + IncrementalParserSource.prototype.currentNode = function () { + if (this.canReadFromOldSourceUnit()) { + return this.tryGetNodeFromOldSourceUnit(); + } + + return null; + }; + + IncrementalParserSource.prototype.currentToken = function () { + if (this.canReadFromOldSourceUnit()) { + var token = this.tryGetTokenFromOldSourceUnit(); + if (token !== null) { + return token; + } + } + + return this._normalParserSource.currentToken(); + }; + + IncrementalParserSource.prototype.currentTokenAllowingRegularExpression = function () { + return this._normalParserSource.currentTokenAllowingRegularExpression(); + }; + + IncrementalParserSource.prototype.syncCursorToNewTextIfBehind = function () { + while (true) { + if (this._oldSourceUnitCursor.isFinished()) { + break; + } + + if (this._changeDelta >= 0) { + break; + } + + var currentElement = this._oldSourceUnitCursor.currentElement(); + + if (currentElement.isNode() && (currentElement.fullWidth() > Math.abs(this._changeDelta))) { + this._oldSourceUnitCursor.moveToFirstChild(); + } else { + this._oldSourceUnitCursor.moveToNextSibling(); + + this._changeDelta += currentElement.fullWidth(); + } + } + }; + + IncrementalParserSource.prototype.intersectsWithChangeRangeSpanInOriginalText = function (start, length) { + return this._changeRange !== null && this._changeRange.span().intersectsWith(start, length); + }; + + IncrementalParserSource.prototype.tryGetNodeFromOldSourceUnit = function () { + while (true) { + var node = this._oldSourceUnitCursor.currentNode(); + if (node === null) { + return null; + } + + if (!this.intersectsWithChangeRangeSpanInOriginalText(this.absolutePosition(), node.fullWidth())) { + if (!node.isIncrementallyUnusable()) { + return node; + } + } + + this._oldSourceUnitCursor.moveToFirstChild(); + } + }; + + IncrementalParserSource.prototype.canReuseTokenFromOldSourceUnit = function (position, token) { + if (token !== null) { + if (!this.intersectsWithChangeRangeSpanInOriginalText(position, token.fullWidth())) { + if (!token.isIncrementallyUnusable()) { + return true; + } + } + } + + return false; + }; + + IncrementalParserSource.prototype.tryGetTokenFromOldSourceUnit = function () { + var token = this._oldSourceUnitCursor.currentToken(); + + return this.canReuseTokenFromOldSourceUnit(this.absolutePosition(), token) ? token : null; + }; + + IncrementalParserSource.prototype.peekToken = function (n) { + if (this.canReadFromOldSourceUnit()) { + var token = this.tryPeekTokenFromOldSourceUnit(n); + if (token !== null) { + return token; + } + } + + return this._normalParserSource.peekToken(n); + }; + + IncrementalParserSource.prototype.tryPeekTokenFromOldSourceUnit = function (n) { + var currentPosition = this.absolutePosition(); + for (var i = 0; i < n; i++) { + var interimToken = this._oldSourceUnitCursor.peekToken(i); + if (!this.canReuseTokenFromOldSourceUnit(currentPosition, interimToken)) { + return null; + } + + currentPosition += interimToken.fullWidth(); + } + + var token = this._oldSourceUnitCursor.peekToken(n); + return this.canReuseTokenFromOldSourceUnit(currentPosition, token) ? token : null; + }; + + IncrementalParserSource.prototype.moveToNextNode = function () { + var currentElement = this._oldSourceUnitCursor.currentElement(); + var currentNode = this._oldSourceUnitCursor.currentNode(); + + this._oldSourceUnitCursor.moveToNextSibling(); + + var absolutePosition = this.absolutePosition() + currentNode.fullWidth(); + var previousToken = currentNode.lastToken(); + this._normalParserSource.resetToPosition(absolutePosition, previousToken); + + if (this._changeRange !== null) { + } + }; + + IncrementalParserSource.prototype.moveToNextToken = function () { + var currentToken = this.currentToken(); + + if (this._oldSourceUnitCursor.currentToken() === currentToken) { + this._oldSourceUnitCursor.moveToNextSibling(); + + var absolutePosition = this.absolutePosition() + currentToken.fullWidth(); + var previousToken = currentToken; + this._normalParserSource.resetToPosition(absolutePosition, previousToken); + + if (this._changeRange !== null) { + } + } else { + this._changeDelta -= currentToken.fullWidth(); + + this._normalParserSource.moveToNextToken(); + + if (this._changeRange !== null) { + var changeRangeSpanInNewText = this._changeRange.newSpan(); + if (this.absolutePosition() >= changeRangeSpanInNewText.end()) { + this._changeDelta += this._changeRange.newLength() - this._changeRange.span().length(); + this._changeRange = null; + } + } + } + }; + return IncrementalParserSource; + })(); + + var ParserImpl = (function () { + function ParserImpl(fileName, lineMap, source, parseOptions, newText_forDebuggingPurposesOnly) { + this.newText_forDebuggingPurposesOnly = newText_forDebuggingPurposesOnly; + this.listParsingState = 0; + this.isInStrictMode = false; + this.diagnostics = []; + this.factory = TypeScript.Syntax.normalModeFactory; + this.mergeTokensStorage = []; + this.arrayPool = []; + this.fileName = fileName; + this.lineMap = lineMap; + this.source = source; + this.parseOptions = parseOptions; + } + ParserImpl.prototype.getRewindPoint = function () { + var rewindPoint = this.source.getRewindPoint(); + + rewindPoint.diagnosticsCount = this.diagnostics.length; + + rewindPoint.isInStrictMode = this.isInStrictMode; + rewindPoint.listParsingState = this.listParsingState; + + return rewindPoint; + }; + + ParserImpl.prototype.rewind = function (rewindPoint) { + this.source.rewind(rewindPoint); + + this.diagnostics.length = rewindPoint.diagnosticsCount; + }; + + ParserImpl.prototype.releaseRewindPoint = function (rewindPoint) { + this.source.releaseRewindPoint(rewindPoint); + }; + + ParserImpl.prototype.currentTokenStart = function () { + return this.source.absolutePosition() + this.currentToken().leadingTriviaWidth(); + }; + + ParserImpl.prototype.previousTokenStart = function () { + if (this.previousToken() === null) { + return 0; + } + + return this.source.absolutePosition() - this.previousToken().fullWidth() + this.previousToken().leadingTriviaWidth(); + }; + + ParserImpl.prototype.previousTokenEnd = function () { + if (this.previousToken() === null) { + return 0; + } + + return this.previousTokenStart() + this.previousToken().width(); + }; + + ParserImpl.prototype.currentNode = function () { + var node = this.source.currentNode(); + + if (node === null || node.parsedInStrictMode() !== this.isInStrictMode) { + return null; + } + + return node; + }; + + ParserImpl.prototype.currentToken = function () { + return this.source.currentToken(); + }; + + ParserImpl.prototype.currentTokenAllowingRegularExpression = function () { + return this.source.currentTokenAllowingRegularExpression(); + }; + + ParserImpl.prototype.peekToken = function (n) { + return this.source.peekToken(n); + }; + + ParserImpl.prototype.eatAnyToken = function () { + var token = this.currentToken(); + this.moveToNextToken(); + return token; + }; + + ParserImpl.prototype.moveToNextToken = function () { + this.source.moveToNextToken(); + }; + + ParserImpl.prototype.previousToken = function () { + return this.source.previousToken(); + }; + + ParserImpl.prototype.eatNode = function () { + var node = this.source.currentNode(); + this.source.moveToNextNode(); + return node; + }; + + ParserImpl.prototype.eatToken = function (kind) { + var token = this.currentToken(); + if (token.tokenKind === kind) { + this.moveToNextToken(); + return token; + } + + return this.createMissingToken(kind, token); + }; + + ParserImpl.prototype.tryEatToken = function (kind) { + if (this.currentToken().tokenKind === kind) { + return this.eatToken(kind); + } + + return null; + }; + + ParserImpl.prototype.eatKeyword = function (kind) { + var token = this.currentToken(); + if (token.tokenKind === kind) { + this.moveToNextToken(); + return token; + } + + return this.createMissingToken(kind, token); + }; + + ParserImpl.prototype.isIdentifier = function (token) { + var tokenKind = token.tokenKind; + + if (tokenKind === 11 /* IdentifierName */) { + return true; + } + + if (tokenKind >= 51 /* FirstFutureReservedStrictKeyword */) { + if (tokenKind <= 59 /* LastFutureReservedStrictKeyword */) { + return !this.isInStrictMode; + } + + return tokenKind <= 69 /* LastTypeScriptKeyword */; + } + + return false; + }; + + ParserImpl.prototype.eatIdentifierNameToken = function () { + var token = this.currentToken(); + + if (token.tokenKind === 11 /* IdentifierName */) { + this.moveToNextToken(); + return token; + } + + if (TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)) { + this.moveToNextToken(); + return TypeScript.Syntax.convertToIdentifierName(token); + } + + return this.createMissingToken(11 /* IdentifierName */, token); + }; + + ParserImpl.prototype.eatIdentifierToken = function () { + var token = this.currentToken(); + if (this.isIdentifier(token)) { + this.moveToNextToken(); + + if (token.tokenKind === 11 /* IdentifierName */) { + return token; + } + + return TypeScript.Syntax.convertToIdentifierName(token); + } + + return this.createMissingToken(11 /* IdentifierName */, token); + }; + + ParserImpl.prototype.canEatAutomaticSemicolon = function (allowWithoutNewLine) { + var token = this.currentToken(); + + if (token.tokenKind === 10 /* EndOfFileToken */) { + return true; + } + + if (token.tokenKind === 71 /* CloseBraceToken */) { + return true; + } + + if (allowWithoutNewLine) { + return true; + } + + if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) { + return true; + } + + return false; + }; + + ParserImpl.prototype.canEatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) { + var token = this.currentToken(); + + if (token.tokenKind === 78 /* SemicolonToken */) { + return true; + } + + return this.canEatAutomaticSemicolon(allowWithoutNewline); + }; + + ParserImpl.prototype.eatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) { + var token = this.currentToken(); + + if (token.tokenKind === 78 /* SemicolonToken */) { + return this.eatToken(78 /* SemicolonToken */); + } + + if (this.canEatAutomaticSemicolon(allowWithoutNewline)) { + var semicolonToken = TypeScript.Syntax.emptyToken(78 /* SemicolonToken */); + + if (!this.parseOptions.allowAutomaticSemicolonInsertion()) { + this.addDiagnostic(new TypeScript.Diagnostic(this.fileName, this.lineMap, this.previousTokenEnd(), 0, TypeScript.DiagnosticCode.Automatic_semicolon_insertion_not_allowed, null)); + } + + return semicolonToken; + } + + return this.eatToken(78 /* SemicolonToken */); + }; + + ParserImpl.prototype.isKeyword = function (kind) { + if (kind >= 15 /* FirstKeyword */) { + if (kind <= 50 /* LastFutureReservedKeyword */) { + return true; + } + + if (this.isInStrictMode) { + return kind <= 59 /* LastFutureReservedStrictKeyword */; + } + } + + return false; + }; + + ParserImpl.prototype.createMissingToken = function (expectedKind, actual) { + var diagnostic = this.getExpectedTokenDiagnostic(expectedKind, actual); + this.addDiagnostic(diagnostic); + + return TypeScript.Syntax.emptyToken(expectedKind); + }; + + ParserImpl.prototype.getExpectedTokenDiagnostic = function (expectedKind, actual) { + var token = this.currentToken(); + + if (TypeScript.SyntaxFacts.isAnyKeyword(expectedKind) || TypeScript.SyntaxFacts.isAnyPunctuation(expectedKind)) { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(expectedKind)]); + } else { + if (actual !== null && TypeScript.SyntaxFacts.isAnyKeyword(actual.tokenKind)) { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected_0_is_a_keyword, [TypeScript.SyntaxFacts.getText(actual.tokenKind)]); + } else { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected, null); + } + } + }; + + ParserImpl.getPrecedence = function (expressionKind) { + switch (expressionKind) { + case 173 /* CommaExpression */: + return 1 /* CommaExpressionPrecedence */; + + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + return 2 /* AssignmentExpressionPrecedence */; + + case 186 /* ConditionalExpression */: + return 3 /* ConditionalExpressionPrecedence */; + + case 187 /* LogicalOrExpression */: + return 5 /* LogicalOrExpressionPrecedence */; + + case 188 /* LogicalAndExpression */: + return 6 /* LogicalAndExpressionPrecedence */; + + case 189 /* BitwiseOrExpression */: + return 7 /* BitwiseOrExpressionPrecedence */; + + case 190 /* BitwiseExclusiveOrExpression */: + return 8 /* BitwiseExclusiveOrExpressionPrecedence */; + + case 191 /* BitwiseAndExpression */: + return 9 /* BitwiseAndExpressionPrecedence */; + + case 192 /* EqualsWithTypeConversionExpression */: + case 193 /* NotEqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + return 10 /* EqualityExpressionPrecedence */; + + case 196 /* LessThanExpression */: + case 197 /* GreaterThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 200 /* InstanceOfExpression */: + case 201 /* InExpression */: + return 11 /* RelationalExpressionPrecedence */; + + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + return 12 /* ShiftExpressionPrecdence */; + + case 208 /* AddExpression */: + case 209 /* SubtractExpression */: + return 13 /* AdditiveExpressionPrecedence */; + + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + return 14 /* MultiplicativeExpressionPrecedence */; + + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + case 166 /* BitwiseNotExpression */: + case 167 /* LogicalNotExpression */: + case 170 /* DeleteExpression */: + case 171 /* TypeOfExpression */: + case 172 /* VoidExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return 15 /* UnaryExpressionPrecedence */; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + ParserImpl.prototype.addSkippedTokenAfterNodeOrToken = function (nodeOrToken, skippedToken) { + if (nodeOrToken.isToken()) { + return this.addSkippedTokenAfterToken(nodeOrToken, skippedToken); + } else if (nodeOrToken.isNode()) { + return this.addSkippedTokenAfterNode(nodeOrToken, skippedToken); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.addSkippedTokenAfterNode = function (node, skippedToken) { + var oldToken = node.lastToken(); + var newToken = this.addSkippedTokenAfterToken(oldToken, skippedToken); + + return node.replaceToken(oldToken, newToken); + }; + + ParserImpl.prototype.addSkippedTokensBeforeNode = function (node, skippedTokens) { + if (skippedTokens.length > 0) { + var oldToken = node.firstToken(); + var newToken = this.addSkippedTokensBeforeToken(oldToken, skippedTokens); + + return node.replaceToken(oldToken, newToken); + } + + return node; + }; + + ParserImpl.prototype.addSkippedTokensBeforeToken = function (token, skippedTokens) { + var leadingTrivia = []; + for (var i = 0, n = skippedTokens.length; i < n; i++) { + this.addSkippedTokenToTriviaArray(leadingTrivia, skippedTokens[i]); + } + + this.addTriviaTo(token.leadingTrivia(), leadingTrivia); + + this.returnArray(skippedTokens); + return token.withLeadingTrivia(TypeScript.Syntax.triviaList(leadingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokensAfterToken = function (token, skippedTokens) { + if (skippedTokens.length === 0) { + this.returnArray(skippedTokens); + return token; + } + + var trailingTrivia = token.trailingTrivia().toArray(); + + for (var i = 0, n = skippedTokens.length; i < n; i++) { + this.addSkippedTokenToTriviaArray(trailingTrivia, skippedTokens[i]); + } + + this.returnArray(skippedTokens); + return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokenAfterToken = function (token, skippedToken) { + var trailingTrivia = token.trailingTrivia().toArray(); + this.addSkippedTokenToTriviaArray(trailingTrivia, skippedToken); + + return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokenToTriviaArray = function (array, skippedToken) { + this.addTriviaTo(skippedToken.leadingTrivia(), array); + + var trimmedToken = skippedToken.withLeadingTrivia(TypeScript.Syntax.emptyTriviaList).withTrailingTrivia(TypeScript.Syntax.emptyTriviaList); + array.push(TypeScript.Syntax.skippedTokenTrivia(trimmedToken)); + + this.addTriviaTo(skippedToken.trailingTrivia(), array); + }; + + ParserImpl.prototype.addTriviaTo = function (list, array) { + for (var i = 0, n = list.count(); i < n; i++) { + array.push(list.syntaxTriviaAt(i)); + } + }; + + ParserImpl.prototype.parseSyntaxTree = function (isDeclaration) { + var sourceUnit = this.parseSourceUnit(); + + var allDiagnostics = this.source.tokenDiagnostics().concat(this.diagnostics); + allDiagnostics.sort(function (a, b) { + return a.start() - b.start(); + }); + + return new TypeScript.SyntaxTree(sourceUnit, isDeclaration, allDiagnostics, this.fileName, this.lineMap, this.parseOptions); + }; + + ParserImpl.prototype.setStrictMode = function (isInStrictMode) { + this.isInStrictMode = isInStrictMode; + this.factory = isInStrictMode ? TypeScript.Syntax.strictModeFactory : TypeScript.Syntax.normalModeFactory; + }; + + ParserImpl.prototype.parseSourceUnit = function () { + var savedIsInStrictMode = this.isInStrictMode; + + var result = this.parseSyntaxList(1 /* SourceUnit_ModuleElements */, ParserImpl.updateStrictModeState); + var moduleElements = result.list; + + this.setStrictMode(savedIsInStrictMode); + + var sourceUnit = this.factory.sourceUnit(moduleElements, this.currentToken()); + sourceUnit = this.addSkippedTokensBeforeNode(sourceUnit, result.skippedTokens); + + if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) { + TypeScript.Debug.assert(sourceUnit.fullWidth() === this.newText_forDebuggingPurposesOnly.length()); + + if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) { + TypeScript.Debug.assert(sourceUnit.fullText() === this.newText_forDebuggingPurposesOnly.substr(0, this.newText_forDebuggingPurposesOnly.length(), false)); + } + } + + return sourceUnit; + }; + + ParserImpl.updateStrictModeState = function (parser, items) { + if (!parser.isInStrictMode) { + for (var i = 0; i < items.length; i++) { + var item = items[i]; + if (!TypeScript.SyntaxFacts.isDirectivePrologueElement(item)) { + return; + } + } + + parser.setStrictMode(TypeScript.SyntaxFacts.isUseStrictDirective(items[items.length - 1])); + } + }; + + ParserImpl.prototype.isModuleElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isModuleElement()) { + return true; + } + + var modifierCount = this.modifierCount(); + return this.isImportDeclaration(modifierCount) || this.isExportAssignment() || this.isModuleDeclaration(modifierCount) || this.isInterfaceDeclaration(modifierCount) || this.isClassDeclaration(modifierCount) || this.isEnumDeclaration(modifierCount) || this.isStatement(inErrorRecovery); + }; + + ParserImpl.prototype.parseModuleElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isModuleElement()) { + return this.eatNode(); + } + + var modifierCount = this.modifierCount(); + if (this.isImportDeclaration(modifierCount)) { + return this.parseImportDeclaration(); + } else if (this.isExportAssignment()) { + return this.parseExportAssignment(); + } else if (this.isModuleDeclaration(modifierCount)) { + return this.parseModuleDeclaration(); + } else if (this.isInterfaceDeclaration(modifierCount)) { + return this.parseInterfaceDeclaration(); + } else if (this.isClassDeclaration(modifierCount)) { + return this.parseClassDeclaration(); + } else if (this.isEnumDeclaration(modifierCount)) { + return this.parseEnumDeclaration(); + } else if (this.isStatement(inErrorRecovery)) { + return this.parseStatement(inErrorRecovery); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isImportDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 49 /* ImportKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 49 /* ImportKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseImportDeclaration = function () { + var modifiers = this.parseModifiers(); + var importKeyword = this.eatKeyword(49 /* ImportKeyword */); + var identifier = this.eatIdentifierToken(); + var equalsToken = this.eatToken(107 /* EqualsToken */); + var moduleReference = this.parseModuleReference(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.importDeclaration(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken); + }; + + ParserImpl.prototype.isExportAssignment = function () { + return this.currentToken().tokenKind === 47 /* ExportKeyword */ && this.peekToken(1).tokenKind === 107 /* EqualsToken */; + }; + + ParserImpl.prototype.parseExportAssignment = function () { + var exportKeyword = this.eatKeyword(47 /* ExportKeyword */); + var equalsToken = this.eatToken(107 /* EqualsToken */); + var identifier = this.eatIdentifierToken(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.exportAssignment(exportKeyword, equalsToken, identifier, semicolonToken); + }; + + ParserImpl.prototype.parseModuleReference = function () { + if (this.isExternalModuleReference()) { + return this.parseExternalModuleReference(); + } else { + return this.parseModuleNameModuleReference(); + } + }; + + ParserImpl.prototype.isExternalModuleReference = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 66 /* RequireKeyword */) { + return this.peekToken(1).tokenKind === 72 /* OpenParenToken */; + } + + return false; + }; + + ParserImpl.prototype.parseExternalModuleReference = function () { + var requireKeyword = this.eatKeyword(66 /* RequireKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var stringLiteral = this.eatToken(14 /* StringLiteral */); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.externalModuleReference(requireKeyword, openParenToken, stringLiteral, closeParenToken); + }; + + ParserImpl.prototype.parseModuleNameModuleReference = function () { + var name = this.parseName(); + return this.factory.moduleNameModuleReference(name); + }; + + ParserImpl.prototype.parseIdentifierName = function () { + var identifierName = this.eatIdentifierNameToken(); + return identifierName; + }; + + ParserImpl.prototype.tryParseTypeArgumentList = function (inExpression) { + if (this.currentToken().kind() !== 80 /* LessThanToken */) { + return null; + } + + var lessThanToken; + var greaterThanToken; + var result; + var typeArguments; + + if (!inExpression) { + lessThanToken = this.eatToken(80 /* LessThanToken */); + + result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */); + typeArguments = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + return this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken); + } + + var rewindPoint = this.getRewindPoint(); + + lessThanToken = this.eatToken(80 /* LessThanToken */); + + result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */); + typeArguments = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + if (greaterThanToken.fullWidth() === 0 || !this.canFollowTypeArgumentListInExpression(this.currentToken().kind())) { + this.rewind(rewindPoint); + + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + var typeArgumentList = this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken); + + return typeArgumentList; + } + }; + + ParserImpl.prototype.canFollowTypeArgumentListInExpression = function (kind) { + switch (kind) { + case 72 /* OpenParenToken */: + case 76 /* DotToken */: + + case 73 /* CloseParenToken */: + case 75 /* CloseBracketToken */: + case 106 /* ColonToken */: + case 78 /* SemicolonToken */: + case 79 /* CommaToken */: + case 105 /* QuestionToken */: + case 84 /* EqualsEqualsToken */: + case 87 /* EqualsEqualsEqualsToken */: + case 86 /* ExclamationEqualsToken */: + case 88 /* ExclamationEqualsEqualsToken */: + case 103 /* AmpersandAmpersandToken */: + case 104 /* BarBarToken */: + case 100 /* CaretToken */: + case 98 /* AmpersandToken */: + case 99 /* BarToken */: + case 71 /* CloseBraceToken */: + case 10 /* EndOfFileToken */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.parseName = function () { + var shouldContinue = this.isIdentifier(this.currentToken()); + var current = this.eatIdentifierToken(); + + while (shouldContinue && this.currentToken().tokenKind === 76 /* DotToken */) { + var dotToken = this.eatToken(76 /* DotToken */); + + var currentToken = this.currentToken(); + var identifierName; + + if (TypeScript.SyntaxFacts.isAnyKeyword(currentToken.tokenKind) && this.previousToken().hasTrailingNewLine() && !currentToken.hasTrailingNewLine() && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.peekToken(1))) { + identifierName = this.createMissingToken(11 /* IdentifierName */, currentToken); + } else { + identifierName = this.eatIdentifierNameToken(); + } + + current = this.factory.qualifiedName(current, dotToken, identifierName); + + shouldContinue = identifierName.fullWidth() > 0; + } + + return current; + }; + + ParserImpl.prototype.isEnumDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 46 /* EnumKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 46 /* EnumKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseEnumDeclaration = function () { + var modifiers = this.parseModifiers(); + var enumKeyword = this.eatKeyword(46 /* EnumKeyword */); + var identifier = this.eatIdentifierToken(); + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + var enumElements = TypeScript.Syntax.emptySeparatedList; + + if (openBraceToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(256 /* EnumDeclaration_EnumElements */); + enumElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.enumDeclaration(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken); + }; + + ParserImpl.prototype.isEnumElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) { + return true; + } + + return this.isPropertyName(this.currentToken(), inErrorRecovery); + }; + + ParserImpl.prototype.parseEnumElement = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) { + return this.eatNode(); + } + + var propertyName = this.eatPropertyName(); + var equalsValueClause = null; + if (this.isEqualsValueClause(false)) { + equalsValueClause = this.parseEqualsValueClause(true); + } + + return this.factory.enumElement(propertyName, equalsValueClause); + }; + + ParserImpl.isModifier = function (token) { + switch (token.tokenKind) { + case 57 /* PublicKeyword */: + case 55 /* PrivateKeyword */: + case 58 /* StaticKeyword */: + case 47 /* ExportKeyword */: + case 63 /* DeclareKeyword */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.modifierCount = function () { + var modifierCount = 0; + while (true) { + if (ParserImpl.isModifier(this.peekToken(modifierCount))) { + modifierCount++; + continue; + } + + break; + } + + return modifierCount; + }; + + ParserImpl.prototype.parseModifiers = function () { + var tokens = this.getArray(); + + while (true) { + if (ParserImpl.isModifier(this.currentToken())) { + tokens.push(this.eatAnyToken()); + continue; + } + + break; + } + + var result = TypeScript.Syntax.list(tokens); + + this.returnZeroOrOneLengthArray(tokens); + + return result; + }; + + ParserImpl.prototype.isClassDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 44 /* ClassKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 44 /* ClassKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseHeritageClauses = function () { + var heritageClauses = TypeScript.Syntax.emptyList; + + if (this.isHeritageClause()) { + var result = this.parseSyntaxList(1024 /* ClassOrInterfaceDeclaration_HeritageClauses */); + heritageClauses = result.list; + TypeScript.Debug.assert(result.skippedTokens.length === 0); + } + + return heritageClauses; + }; + + ParserImpl.prototype.parseClassDeclaration = function () { + var modifiers = this.parseModifiers(); + + var classKeyword = this.eatKeyword(44 /* ClassKeyword */); + var identifier = this.eatIdentifierToken(); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var heritageClauses = this.parseHeritageClauses(); + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + var classElements = TypeScript.Syntax.emptyList; + + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(2 /* ClassDeclaration_ClassElements */); + + classElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.classDeclaration(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken); + }; + + ParserImpl.isPublicOrPrivateKeyword = function (token) { + return token.tokenKind === 57 /* PublicKeyword */ || token.tokenKind === 55 /* PrivateKeyword */; + }; + + ParserImpl.prototype.isAccessor = function (inErrorRecovery) { + var index = this.modifierCount(); + + if (this.peekToken(index).tokenKind !== 64 /* GetKeyword */ && this.peekToken(index).tokenKind !== 68 /* SetKeyword */) { + return false; + } + + index++; + return this.isPropertyName(this.peekToken(index), inErrorRecovery); + }; + + ParserImpl.prototype.parseAccessor = function (checkForStrictMode) { + var modifiers = this.parseModifiers(); + + if (this.currentToken().tokenKind === 64 /* GetKeyword */) { + return this.parseGetMemberAccessorDeclaration(modifiers, checkForStrictMode); + } else if (this.currentToken().tokenKind === 68 /* SetKeyword */) { + return this.parseSetMemberAccessorDeclaration(modifiers, checkForStrictMode); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseGetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) { + var getKeyword = this.eatKeyword(64 /* GetKeyword */); + var propertyName = this.eatPropertyName(); + var parameterList = this.parseParameterList(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + var block = this.parseBlock(false, checkForStrictMode); + + return this.factory.getAccessor(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block); + }; + + ParserImpl.prototype.parseSetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) { + var setKeyword = this.eatKeyword(68 /* SetKeyword */); + var propertyName = this.eatPropertyName(); + var parameterList = this.parseParameterList(); + var block = this.parseBlock(false, checkForStrictMode); + + return this.factory.setAccessor(modifiers, setKeyword, propertyName, parameterList, block); + }; + + ParserImpl.prototype.isClassElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isClassElement()) { + return true; + } + + return this.isConstructorDeclaration() || this.isMemberFunctionDeclaration(inErrorRecovery) || this.isAccessor(inErrorRecovery) || this.isMemberVariableDeclaration(inErrorRecovery) || this.isIndexMemberDeclaration(); + }; + + ParserImpl.prototype.parseClassElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isClassElement()) { + return this.eatNode(); + } + + if (this.isConstructorDeclaration()) { + return this.parseConstructorDeclaration(); + } else if (this.isMemberFunctionDeclaration(inErrorRecovery)) { + return this.parseMemberFunctionDeclaration(); + } else if (this.isAccessor(inErrorRecovery)) { + return this.parseAccessor(false); + } else if (this.isMemberVariableDeclaration(inErrorRecovery)) { + return this.parseMemberVariableDeclaration(); + } else if (this.isIndexMemberDeclaration()) { + return this.parseIndexMemberDeclaration(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isConstructorDeclaration = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 62 /* ConstructorKeyword */ && this.peekToken(index + 1).tokenKind === 72 /* OpenParenToken */; + }; + + ParserImpl.prototype.parseConstructorDeclaration = function () { + var modifiers = this.parseModifiers(); + var constructorKeyword = this.eatKeyword(62 /* ConstructorKeyword */); + var parameterList = this.parseParameterList(); + + var semicolonToken = null; + var block = null; + + if (this.isBlock()) { + block = this.parseBlock(false, true); + } else { + semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.constructorDeclaration(modifiers, constructorKeyword, parameterList, block, semicolonToken); + }; + + ParserImpl.prototype.isMemberFunctionDeclaration = function (inErrorRecovery) { + var index = 0; + + while (true) { + var token = this.peekToken(index); + if (this.isPropertyName(token, inErrorRecovery) && this.isCallSignature(index + 1)) { + return true; + } + + if (ParserImpl.isModifier(token)) { + index++; + continue; + } + + return false; + } + }; + + ParserImpl.prototype.parseMemberFunctionDeclaration = function () { + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (this.isPropertyName(currentToken, false) && this.isCallSignature(1)) { + break; + } + + TypeScript.Debug.assert(ParserImpl.isModifier(currentToken)); + modifierArray.push(this.eatAnyToken()); + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var propertyName = this.eatPropertyName(); + var callSignature = this.parseCallSignature(false); + + var parseBlockEvenWithNoOpenBrace = false; + var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature); + if (newCallSignature !== callSignature) { + parseBlockEvenWithNoOpenBrace = true; + callSignature = newCallSignature; + } + + var block = null; + var semicolon = null; + + if (parseBlockEvenWithNoOpenBrace || this.isBlock()) { + block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true); + } else { + semicolon = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.memberFunctionDeclaration(modifiers, propertyName, callSignature, block, semicolon); + }; + + ParserImpl.prototype.isDefinitelyMemberVariablePropertyName = function (index) { + if (TypeScript.SyntaxFacts.isAnyKeyword(this.peekToken(index).tokenKind)) { + switch (this.peekToken(index + 1).tokenKind) { + case 78 /* SemicolonToken */: + case 107 /* EqualsToken */: + case 106 /* ColonToken */: + case 71 /* CloseBraceToken */: + case 10 /* EndOfFileToken */: + return true; + default: + return false; + } + } else { + return true; + } + }; + + ParserImpl.prototype.isMemberVariableDeclaration = function (inErrorRecovery) { + var index = 0; + + while (true) { + var token = this.peekToken(index); + if (this.isPropertyName(token, inErrorRecovery) && this.isDefinitelyMemberVariablePropertyName(index)) { + return true; + } + + if (ParserImpl.isModifier(this.peekToken(index))) { + index++; + continue; + } + + return false; + } + }; + + ParserImpl.prototype.parseMemberVariableDeclaration = function () { + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (this.isPropertyName(currentToken, false) && this.isDefinitelyMemberVariablePropertyName(0)) { + break; + } + + TypeScript.Debug.assert(ParserImpl.isModifier(currentToken)); + modifierArray.push(this.eatAnyToken()); + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var variableDeclarator = this.parseVariableDeclarator(true, true); + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.memberVariableDeclaration(modifiers, variableDeclarator, semicolon); + }; + + ParserImpl.prototype.isIndexMemberDeclaration = function () { + var index = this.modifierCount(); + return this.isIndexSignature(index); + }; + + ParserImpl.prototype.parseIndexMemberDeclaration = function () { + var modifiers = this.parseModifiers(); + var indexSignature = this.parseIndexSignature(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.indexMemberDeclaration(modifiers, indexSignature, semicolonToken); + }; + + ParserImpl.prototype.tryAddUnexpectedEqualsGreaterThanToken = function (callSignature) { + var token0 = this.currentToken(); + + var hasEqualsGreaterThanToken = token0.tokenKind === 85 /* EqualsGreaterThanToken */; + if (hasEqualsGreaterThanToken) { + if (callSignature.lastToken()) { + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [TypeScript.SyntaxFacts.getText(70 /* OpenBraceToken */)]); + this.addDiagnostic(diagnostic); + + var token = this.eatAnyToken(); + return this.addSkippedTokenAfterNode(callSignature, token0); + } + } + + return callSignature; + }; + + ParserImpl.prototype.isFunctionDeclaration = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 27 /* FunctionKeyword */; + }; + + ParserImpl.prototype.parseFunctionDeclaration = function () { + var modifiers = this.parseModifiers(); + var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */); + var identifier = this.eatIdentifierToken(); + var callSignature = this.parseCallSignature(false); + + var parseBlockEvenWithNoOpenBrace = false; + var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature); + if (newCallSignature !== callSignature) { + parseBlockEvenWithNoOpenBrace = true; + callSignature = newCallSignature; + } + + var semicolonToken = null; + var block = null; + + if (parseBlockEvenWithNoOpenBrace || this.isBlock()) { + block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true); + } else { + semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.functionDeclaration(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken); + }; + + ParserImpl.prototype.isModuleDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 65 /* ModuleKeyword */) { + return true; + } + + if (this.currentToken().tokenKind === 65 /* ModuleKeyword */) { + var token1 = this.peekToken(1); + return this.isIdentifier(token1) || token1.tokenKind === 14 /* StringLiteral */; + } + + return false; + }; + + ParserImpl.prototype.parseModuleDeclaration = function () { + var modifiers = this.parseModifiers(); + var moduleKeyword = this.eatKeyword(65 /* ModuleKeyword */); + + var moduleName = null; + var stringLiteral = null; + + if (this.currentToken().tokenKind === 14 /* StringLiteral */) { + stringLiteral = this.eatToken(14 /* StringLiteral */); + } else { + moduleName = this.parseName(); + } + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var moduleElements = TypeScript.Syntax.emptyList; + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(4 /* ModuleDeclaration_ModuleElements */); + moduleElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.moduleDeclaration(modifiers, moduleKeyword, moduleName, stringLiteral, openBraceToken, moduleElements, closeBraceToken); + }; + + ParserImpl.prototype.isInterfaceDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 52 /* InterfaceKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 52 /* InterfaceKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseInterfaceDeclaration = function () { + var modifiers = this.parseModifiers(); + var interfaceKeyword = this.eatKeyword(52 /* InterfaceKeyword */); + var identifier = this.eatIdentifierToken(); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var heritageClauses = this.parseHeritageClauses(); + + var objectType = this.parseObjectType(); + return this.factory.interfaceDeclaration(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, objectType); + }; + + ParserImpl.prototype.parseObjectType = function () { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var typeMembers = TypeScript.Syntax.emptySeparatedList; + if (openBraceToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(512 /* ObjectType_TypeMembers */); + typeMembers = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.objectType(openBraceToken, typeMembers, closeBraceToken); + }; + + ParserImpl.prototype.isTypeMember = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isTypeMember()) { + return true; + } + + return this.isCallSignature(0) || this.isConstructSignature() || this.isIndexSignature(0) || this.isMethodSignature(inErrorRecovery) || this.isPropertySignature(inErrorRecovery); + }; + + ParserImpl.prototype.parseTypeMember = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isTypeMember()) { + return this.eatNode(); + } + + if (this.isCallSignature(0)) { + return this.parseCallSignature(false); + } else if (this.isConstructSignature()) { + return this.parseConstructSignature(); + } else if (this.isIndexSignature(0)) { + return this.parseIndexSignature(); + } else if (this.isMethodSignature(inErrorRecovery)) { + return this.parseMethodSignature(); + } else if (this.isPropertySignature(inErrorRecovery)) { + return this.parsePropertySignature(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseConstructSignature = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + var callSignature = this.parseCallSignature(false); + + return this.factory.constructSignature(newKeyword, callSignature); + }; + + ParserImpl.prototype.parseIndexSignature = function () { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var parameter = this.parseParameter(); + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.indexSignature(openBracketToken, parameter, closeBracketToken, typeAnnotation); + }; + + ParserImpl.prototype.parseMethodSignature = function () { + var propertyName = this.eatPropertyName(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var callSignature = this.parseCallSignature(false); + + return this.factory.methodSignature(propertyName, questionToken, callSignature); + }; + + ParserImpl.prototype.parsePropertySignature = function () { + var propertyName = this.eatPropertyName(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.propertySignature(propertyName, questionToken, typeAnnotation); + }; + + ParserImpl.prototype.isCallSignature = function (tokenIndex) { + var tokenKind = this.peekToken(tokenIndex).tokenKind; + return tokenKind === 72 /* OpenParenToken */ || tokenKind === 80 /* LessThanToken */; + }; + + ParserImpl.prototype.isConstructSignature = function () { + if (this.currentToken().tokenKind !== 31 /* NewKeyword */) { + return false; + } + + var token1 = this.peekToken(1); + return token1.tokenKind === 80 /* LessThanToken */ || token1.tokenKind === 72 /* OpenParenToken */; + }; + + ParserImpl.prototype.isIndexSignature = function (tokenIndex) { + return this.peekToken(tokenIndex).tokenKind === 74 /* OpenBracketToken */; + }; + + ParserImpl.prototype.isMethodSignature = function (inErrorRecovery) { + if (this.isPropertyName(this.currentToken(), inErrorRecovery)) { + if (this.isCallSignature(1)) { + return true; + } + + if (this.peekToken(1).tokenKind === 105 /* QuestionToken */ && this.isCallSignature(2)) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.isPropertySignature = function (inErrorRecovery) { + var currentToken = this.currentToken(); + + if (ParserImpl.isModifier(currentToken) && !currentToken.hasTrailingNewLine() && this.isPropertyName(this.peekToken(1), inErrorRecovery)) { + return false; + } + + return this.isPropertyName(currentToken, inErrorRecovery); + }; + + ParserImpl.prototype.isHeritageClause = function () { + var token0 = this.currentToken(); + return token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */; + }; + + ParserImpl.prototype.isNotHeritageClauseTypeName = function () { + if (this.currentToken().tokenKind === 51 /* ImplementsKeyword */ || this.currentToken().tokenKind === 48 /* ExtendsKeyword */) { + return this.isIdentifier(this.peekToken(1)); + } + + return false; + }; + + ParserImpl.prototype.isHeritageClauseTypeName = function () { + if (this.isIdentifier(this.currentToken())) { + return !this.isNotHeritageClauseTypeName(); + } + + return false; + }; + + ParserImpl.prototype.parseHeritageClause = function () { + var extendsOrImplementsKeyword = this.eatAnyToken(); + TypeScript.Debug.assert(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ || extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + + var result = this.parseSeparatedSyntaxList(2048 /* HeritageClause_TypeNameList */); + var typeNames = result.list; + extendsOrImplementsKeyword = this.addSkippedTokensAfterToken(extendsOrImplementsKeyword, result.skippedTokens); + + return this.factory.heritageClause(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, extendsOrImplementsKeyword, typeNames); + }; + + ParserImpl.prototype.isStatement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isStatement()) { + return true; + } + + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 57 /* PublicKeyword */: + case 55 /* PrivateKeyword */: + case 58 /* StaticKeyword */: + var token1 = this.peekToken(1); + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token1)) { + return false; + } + + break; + + case 28 /* IfKeyword */: + case 70 /* OpenBraceToken */: + case 33 /* ReturnKeyword */: + case 34 /* SwitchKeyword */: + case 36 /* ThrowKeyword */: + case 15 /* BreakKeyword */: + case 18 /* ContinueKeyword */: + case 26 /* ForKeyword */: + case 42 /* WhileKeyword */: + case 43 /* WithKeyword */: + case 22 /* DoKeyword */: + case 38 /* TryKeyword */: + case 19 /* DebuggerKeyword */: + return true; + } + + if (this.isInterfaceDeclaration(0) || this.isClassDeclaration(0) || this.isEnumDeclaration(0) || this.isModuleDeclaration(0)) { + return false; + } + + return this.isLabeledStatement(currentToken) || this.isVariableStatement() || this.isFunctionDeclaration() || this.isEmptyStatement(currentToken, inErrorRecovery) || this.isExpressionStatement(currentToken); + }; + + ParserImpl.prototype.parseStatement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isStatement()) { + return this.eatNode(); + } + + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + switch (currentTokenKind) { + case 28 /* IfKeyword */: + return this.parseIfStatement(); + case 70 /* OpenBraceToken */: + return this.parseBlock(false, false); + case 33 /* ReturnKeyword */: + return this.parseReturnStatement(); + case 34 /* SwitchKeyword */: + return this.parseSwitchStatement(); + case 36 /* ThrowKeyword */: + return this.parseThrowStatement(); + case 15 /* BreakKeyword */: + return this.parseBreakStatement(); + case 18 /* ContinueKeyword */: + return this.parseContinueStatement(); + case 26 /* ForKeyword */: + return this.parseForOrForInStatement(); + case 42 /* WhileKeyword */: + return this.parseWhileStatement(); + case 43 /* WithKeyword */: + return this.parseWithStatement(); + case 22 /* DoKeyword */: + return this.parseDoStatement(); + case 38 /* TryKeyword */: + return this.parseTryStatement(); + case 19 /* DebuggerKeyword */: + return this.parseDebuggerStatement(); + } + + if (this.isVariableStatement()) { + return this.parseVariableStatement(); + } else if (this.isLabeledStatement(currentToken)) { + return this.parseLabeledStatement(); + } else if (this.isFunctionDeclaration()) { + return this.parseFunctionDeclaration(); + } else if (this.isEmptyStatement(currentToken, inErrorRecovery)) { + return this.parseEmptyStatement(); + } else { + return this.parseExpressionStatement(); + } + }; + + ParserImpl.prototype.parseDebuggerStatement = function () { + var debuggerKeyword = this.eatKeyword(19 /* DebuggerKeyword */); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.debuggerStatement(debuggerKeyword, semicolonToken); + }; + + ParserImpl.prototype.parseDoStatement = function () { + var doKeyword = this.eatKeyword(22 /* DoKeyword */); + var statement = this.parseStatement(false); + var whileKeyword = this.eatKeyword(42 /* WhileKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(true); + + return this.factory.doStatement(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken); + }; + + ParserImpl.prototype.isLabeledStatement = function (currentToken) { + return this.isIdentifier(currentToken) && this.peekToken(1).tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.parseLabeledStatement = function () { + var identifier = this.eatIdentifierToken(); + var colonToken = this.eatToken(106 /* ColonToken */); + var statement = this.parseStatement(false); + + return this.factory.labeledStatement(identifier, colonToken, statement); + }; + + ParserImpl.prototype.parseTryStatement = function () { + var tryKeyword = this.eatKeyword(38 /* TryKeyword */); + + var savedListParsingState = this.listParsingState; + this.listParsingState |= 64 /* TryBlock_Statements */; + var block = this.parseBlock(false, false); + this.listParsingState = savedListParsingState; + + var catchClause = null; + if (this.isCatchClause()) { + catchClause = this.parseCatchClause(); + } + + var finallyClause = null; + if (catchClause === null || this.isFinallyClause()) { + finallyClause = this.parseFinallyClause(); + } + + return this.factory.tryStatement(tryKeyword, block, catchClause, finallyClause); + }; + + ParserImpl.prototype.isCatchClause = function () { + return this.currentToken().tokenKind === 17 /* CatchKeyword */; + }; + + ParserImpl.prototype.parseCatchClause = function () { + var catchKeyword = this.eatKeyword(17 /* CatchKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var identifier = this.eatIdentifierToken(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var savedListParsingState = this.listParsingState; + this.listParsingState |= 128 /* CatchBlock_Statements */; + var block = this.parseBlock(false, false); + this.listParsingState = savedListParsingState; + + return this.factory.catchClause(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block); + }; + + ParserImpl.prototype.isFinallyClause = function () { + return this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.parseFinallyClause = function () { + var finallyKeyword = this.eatKeyword(25 /* FinallyKeyword */); + var block = this.parseBlock(false, false); + + return this.factory.finallyClause(finallyKeyword, block); + }; + + ParserImpl.prototype.parseWithStatement = function () { + var withKeyword = this.eatKeyword(43 /* WithKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.withStatement(withKeyword, openParenToken, condition, closeParenToken, statement); + }; + + ParserImpl.prototype.parseWhileStatement = function () { + var whileKeyword = this.eatKeyword(42 /* WhileKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.whileStatement(whileKeyword, openParenToken, condition, closeParenToken, statement); + }; + + ParserImpl.prototype.isEmptyStatement = function (currentToken, inErrorRecovery) { + if (inErrorRecovery) { + return false; + } + + return currentToken.tokenKind === 78 /* SemicolonToken */; + }; + + ParserImpl.prototype.parseEmptyStatement = function () { + var semicolonToken = this.eatToken(78 /* SemicolonToken */); + return this.factory.emptyStatement(semicolonToken); + }; + + ParserImpl.prototype.parseForOrForInStatement = function () { + var forKeyword = this.eatKeyword(26 /* ForKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + + var currentToken = this.currentToken(); + if (currentToken.tokenKind === 40 /* VarKeyword */) { + return this.parseForOrForInStatementWithVariableDeclaration(forKeyword, openParenToken); + } else if (currentToken.tokenKind === 78 /* SemicolonToken */) { + return this.parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword, openParenToken); + } else { + return this.parseForOrForInStatementWithInitializer(forKeyword, openParenToken); + } + }; + + ParserImpl.prototype.parseForOrForInStatementWithVariableDeclaration = function (forKeyword, openParenToken) { + var variableDeclaration = this.parseVariableDeclaration(false); + + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null); + } + + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null); + }; + + ParserImpl.prototype.parseForInStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) { + var inKeyword = this.eatKeyword(29 /* InKeyword */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.forInStatement(forKeyword, openParenToken, variableDeclaration, initializer, inKeyword, expression, closeParenToken, statement); + }; + + ParserImpl.prototype.parseForOrForInStatementWithInitializer = function (forKeyword, openParenToken) { + var initializer = this.parseExpression(false); + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer); + } else { + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer); + } + }; + + ParserImpl.prototype.parseForStatementWithNoVariableDeclarationOrInitializer = function (forKeyword, openParenToken) { + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, null); + }; + + ParserImpl.prototype.parseForStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) { + var firstSemicolonToken = this.eatToken(78 /* SemicolonToken */); + + var condition = null; + if (this.currentToken().tokenKind !== 78 /* SemicolonToken */ && this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) { + condition = this.parseExpression(true); + } + + var secondSemicolonToken = this.eatToken(78 /* SemicolonToken */); + + var incrementor = null; + if (this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) { + incrementor = this.parseExpression(true); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.forStatement(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement); + }; + + ParserImpl.prototype.parseBreakStatement = function () { + var breakKeyword = this.eatKeyword(15 /* BreakKeyword */); + + var identifier = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + } + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + return this.factory.breakStatement(breakKeyword, identifier, semicolon); + }; + + ParserImpl.prototype.parseContinueStatement = function () { + var continueKeyword = this.eatKeyword(18 /* ContinueKeyword */); + + var identifier = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + } + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + return this.factory.continueStatement(continueKeyword, identifier, semicolon); + }; + + ParserImpl.prototype.parseSwitchStatement = function () { + var switchKeyword = this.eatKeyword(34 /* SwitchKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var switchClauses = TypeScript.Syntax.emptyList; + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(8 /* SwitchStatement_SwitchClauses */); + switchClauses = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.switchStatement(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken); + }; + + ParserImpl.prototype.isCaseSwitchClause = function () { + return this.currentToken().tokenKind === 16 /* CaseKeyword */; + }; + + ParserImpl.prototype.isDefaultSwitchClause = function () { + return this.currentToken().tokenKind === 20 /* DefaultKeyword */; + }; + + ParserImpl.prototype.isSwitchClause = function () { + if (this.currentNode() !== null && this.currentNode().isSwitchClause()) { + return true; + } + + return this.isCaseSwitchClause() || this.isDefaultSwitchClause(); + }; + + ParserImpl.prototype.parseSwitchClause = function () { + if (this.currentNode() !== null && this.currentNode().isSwitchClause()) { + return this.eatNode(); + } + + if (this.isCaseSwitchClause()) { + return this.parseCaseSwitchClause(); + } else if (this.isDefaultSwitchClause()) { + return this.parseDefaultSwitchClause(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseCaseSwitchClause = function () { + var caseKeyword = this.eatKeyword(16 /* CaseKeyword */); + var expression = this.parseExpression(true); + var colonToken = this.eatToken(106 /* ColonToken */); + var statements = TypeScript.Syntax.emptyList; + + if (colonToken.fullWidth() > 0) { + var result = this.parseSyntaxList(16 /* SwitchClause_Statements */); + statements = result.list; + colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens); + } + + return this.factory.caseSwitchClause(caseKeyword, expression, colonToken, statements); + }; + + ParserImpl.prototype.parseDefaultSwitchClause = function () { + var defaultKeyword = this.eatKeyword(20 /* DefaultKeyword */); + var colonToken = this.eatToken(106 /* ColonToken */); + var statements = TypeScript.Syntax.emptyList; + + if (colonToken.fullWidth() > 0) { + var result = this.parseSyntaxList(16 /* SwitchClause_Statements */); + statements = result.list; + colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens); + } + + return this.factory.defaultSwitchClause(defaultKeyword, colonToken, statements); + }; + + ParserImpl.prototype.parseThrowStatement = function () { + var throwKeyword = this.eatKeyword(36 /* ThrowKeyword */); + + var expression = null; + if (this.canEatExplicitOrAutomaticSemicolon(false)) { + var token = this.createMissingToken(11 /* IdentifierName */, null); + expression = token; + } else { + expression = this.parseExpression(true); + } + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.throwStatement(throwKeyword, expression, semicolonToken); + }; + + ParserImpl.prototype.parseReturnStatement = function () { + var returnKeyword = this.eatKeyword(33 /* ReturnKeyword */); + + var expression = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + expression = this.parseExpression(true); + } + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.returnStatement(returnKeyword, expression, semicolonToken); + }; + + ParserImpl.prototype.isExpressionStatement = function (currentToken) { + var kind = currentToken.tokenKind; + if (kind === 70 /* OpenBraceToken */ || kind === 27 /* FunctionKeyword */) { + return false; + } + + return this.isExpression(currentToken); + }; + + ParserImpl.prototype.isAssignmentOrOmittedExpression = function () { + var currentToken = this.currentToken(); + if (currentToken.tokenKind === 79 /* CommaToken */) { + return true; + } + + return this.isExpression(currentToken); + }; + + ParserImpl.prototype.parseAssignmentOrOmittedExpression = function () { + if (this.currentToken().tokenKind === 79 /* CommaToken */) { + return this.factory.omittedExpression(); + } + + return this.parseAssignmentExpression(true); + }; + + ParserImpl.prototype.isExpression = function (currentToken) { + switch (currentToken.tokenKind) { + case 13 /* NumericLiteral */: + case 14 /* StringLiteral */: + case 12 /* RegularExpressionLiteral */: + + case 74 /* OpenBracketToken */: + + case 72 /* OpenParenToken */: + + case 80 /* LessThanToken */: + + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + case 89 /* PlusToken */: + case 90 /* MinusToken */: + case 102 /* TildeToken */: + case 101 /* ExclamationToken */: + + case 70 /* OpenBraceToken */: + + case 85 /* EqualsGreaterThanToken */: + + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + + case 50 /* SuperKeyword */: + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + + case 31 /* NewKeyword */: + + case 21 /* DeleteKeyword */: + case 41 /* VoidKeyword */: + case 39 /* TypeOfKeyword */: + + case 27 /* FunctionKeyword */: + return true; + } + + return this.isIdentifier(currentToken); + }; + + ParserImpl.prototype.parseExpressionStatement = function () { + var expression = this.parseExpression(true); + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.expressionStatement(expression, semicolon); + }; + + ParserImpl.prototype.parseIfStatement = function () { + var ifKeyword = this.eatKeyword(28 /* IfKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + var elseClause = null; + if (this.isElseClause()) { + elseClause = this.parseElseClause(); + } + + return this.factory.ifStatement(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause); + }; + + ParserImpl.prototype.isElseClause = function () { + return this.currentToken().tokenKind === 23 /* ElseKeyword */; + }; + + ParserImpl.prototype.parseElseClause = function () { + var elseKeyword = this.eatKeyword(23 /* ElseKeyword */); + var statement = this.parseStatement(false); + + return this.factory.elseClause(elseKeyword, statement); + }; + + ParserImpl.prototype.isVariableStatement = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 40 /* VarKeyword */; + }; + + ParserImpl.prototype.parseVariableStatement = function () { + var modifiers = this.parseModifiers(); + var variableDeclaration = this.parseVariableDeclaration(true); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.variableStatement(modifiers, variableDeclaration, semicolonToken); + }; + + ParserImpl.prototype.parseVariableDeclaration = function (allowIn) { + var varKeyword = this.eatKeyword(40 /* VarKeyword */); + + var listParsingState = allowIn ? 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */ : 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */; + + var result = this.parseSeparatedSyntaxList(listParsingState); + var variableDeclarators = result.list; + varKeyword = this.addSkippedTokensAfterToken(varKeyword, result.skippedTokens); + + return this.factory.variableDeclaration(varKeyword, variableDeclarators); + }; + + ParserImpl.prototype.isVariableDeclarator = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 225 /* VariableDeclarator */) { + return true; + } + + return this.isIdentifier(this.currentToken()); + }; + + ParserImpl.prototype.canReuseVariableDeclaratorNode = function (node) { + if (node === null || node.kind() !== 225 /* VariableDeclarator */) { + return false; + } + + var variableDeclarator = node; + return variableDeclarator.equalsValueClause === null; + }; + + ParserImpl.prototype.parseVariableDeclarator = function (allowIn, allowPropertyName) { + if (this.canReuseVariableDeclaratorNode(this.currentNode())) { + return this.eatNode(); + } + + var propertyName = allowPropertyName ? this.eatPropertyName() : this.eatIdentifierToken(); + var equalsValueClause = null; + var typeAnnotation = null; + + if (propertyName.width() > 0) { + typeAnnotation = this.parseOptionalTypeAnnotation(false); + + if (this.isEqualsValueClause(false)) { + equalsValueClause = this.parseEqualsValueClause(allowIn); + } + } + + return this.factory.variableDeclarator(propertyName, typeAnnotation, equalsValueClause); + }; + + ParserImpl.prototype.isColonValueClause = function () { + return this.currentToken().tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.isEqualsValueClause = function (inParameter) { + var token0 = this.currentToken(); + if (token0.tokenKind === 107 /* EqualsToken */) { + return true; + } + + if (!this.previousToken().hasTrailingNewLine()) { + if (token0.tokenKind === 85 /* EqualsGreaterThanToken */) { + return false; + } + + if (token0.tokenKind === 70 /* OpenBraceToken */ && inParameter) { + return false; + } + + return this.isExpression(token0); + } + + return false; + }; + + ParserImpl.prototype.parseEqualsValueClause = function (allowIn) { + var equalsToken = this.eatToken(107 /* EqualsToken */); + var value = this.parseAssignmentExpression(allowIn); + + return this.factory.equalsValueClause(equalsToken, value); + }; + + ParserImpl.prototype.parseExpression = function (allowIn) { + return this.parseSubExpression(0, allowIn); + }; + + ParserImpl.prototype.parseAssignmentExpression = function (allowIn) { + return this.parseSubExpression(2 /* AssignmentExpressionPrecedence */, allowIn); + }; + + ParserImpl.prototype.parseUnaryExpressionOrLower = function () { + var currentTokenKind = this.currentToken().tokenKind; + if (TypeScript.SyntaxFacts.isPrefixUnaryExpressionOperatorToken(currentTokenKind)) { + var operatorKind = TypeScript.SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken(currentTokenKind); + + var operatorToken = this.eatAnyToken(); + + var operand = this.parseUnaryExpressionOrLower(); + return this.factory.prefixUnaryExpression(operatorKind, operatorToken, operand); + } else if (currentTokenKind === 39 /* TypeOfKeyword */) { + return this.parseTypeOfExpression(); + } else if (currentTokenKind === 41 /* VoidKeyword */) { + return this.parseVoidExpression(); + } else if (currentTokenKind === 21 /* DeleteKeyword */) { + return this.parseDeleteExpression(); + } else if (currentTokenKind === 80 /* LessThanToken */) { + return this.parseCastExpression(); + } else { + return this.parsePostfixExpressionOrLower(); + } + }; + + ParserImpl.prototype.parseSubExpression = function (precedence, allowIn) { + if (precedence <= 2 /* AssignmentExpressionPrecedence */) { + if (this.isSimpleArrowFunctionExpression()) { + return this.parseSimpleArrowFunctionExpression(); + } + + var parethesizedArrowFunction = this.tryParseParenthesizedArrowFunctionExpression(); + if (parethesizedArrowFunction !== null) { + return parethesizedArrowFunction; + } + } + + var leftOperand = this.parseUnaryExpressionOrLower(); + return this.parseBinaryOrConditionalExpressions(precedence, allowIn, leftOperand); + }; + + ParserImpl.prototype.parseBinaryOrConditionalExpressions = function (precedence, allowIn, leftOperand) { + while (true) { + var token0 = this.currentToken(); + var token0Kind = token0.tokenKind; + + if (TypeScript.SyntaxFacts.isBinaryExpressionOperatorToken(token0Kind)) { + if (token0Kind === 29 /* InKeyword */ && !allowIn) { + break; + } + + var mergedToken = this.tryMergeBinaryExpressionTokens(); + var tokenKind = mergedToken === null ? token0Kind : mergedToken.syntaxKind; + + var binaryExpressionKind = TypeScript.SyntaxFacts.getBinaryExpressionFromOperatorToken(tokenKind); + var newPrecedence = ParserImpl.getPrecedence(binaryExpressionKind); + + if (newPrecedence < precedence) { + break; + } + + if (newPrecedence === precedence && !this.isRightAssociative(binaryExpressionKind)) { + break; + } + + var operatorToken = mergedToken === null ? token0 : TypeScript.Syntax.token(mergedToken.syntaxKind).withLeadingTrivia(token0.leadingTrivia()).withTrailingTrivia(this.peekToken(mergedToken.tokenCount - 1).trailingTrivia()); + + var skipCount = mergedToken === null ? 1 : mergedToken.tokenCount; + for (var i = 0; i < skipCount; i++) { + this.eatAnyToken(); + } + + leftOperand = this.factory.binaryExpression(binaryExpressionKind, leftOperand, operatorToken, this.parseSubExpression(newPrecedence, allowIn)); + continue; + } + + if (token0Kind === 105 /* QuestionToken */ && precedence <= 3 /* ConditionalExpressionPrecedence */) { + var questionToken = this.eatToken(105 /* QuestionToken */); + + var whenTrueExpression = this.parseAssignmentExpression(allowIn); + var colon = this.eatToken(106 /* ColonToken */); + + var whenFalseExpression = this.parseAssignmentExpression(allowIn); + leftOperand = this.factory.conditionalExpression(leftOperand, questionToken, whenTrueExpression, colon, whenFalseExpression); + continue; + } + + break; + } + + return leftOperand; + }; + + ParserImpl.prototype.tryMergeBinaryExpressionTokens = function () { + var token0 = this.currentToken(); + + if (token0.tokenKind === 81 /* GreaterThanToken */ && !token0.hasTrailingTrivia()) { + var storage = this.mergeTokensStorage; + storage[0] = 0 /* None */; + storage[1] = 0 /* None */; + storage[2] = 0 /* None */; + + for (var i = 0; i < storage.length; i++) { + var nextToken = this.peekToken(i + 1); + + if (!nextToken.hasLeadingTrivia()) { + storage[i] = nextToken.tokenKind; + } + + if (nextToken.hasTrailingTrivia()) { + break; + } + } + + if (storage[0] === 81 /* GreaterThanToken */) { + if (storage[1] === 81 /* GreaterThanToken */) { + if (storage[2] === 107 /* EqualsToken */) { + return { tokenCount: 4, syntaxKind: 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */ }; + } else { + return { tokenCount: 3, syntaxKind: 97 /* GreaterThanGreaterThanGreaterThanToken */ }; + } + } else if (storage[1] === 107 /* EqualsToken */) { + return { tokenCount: 3, syntaxKind: 113 /* GreaterThanGreaterThanEqualsToken */ }; + } else { + return { tokenCount: 2, syntaxKind: 96 /* GreaterThanGreaterThanToken */ }; + } + } else if (storage[0] === 107 /* EqualsToken */) { + return { tokenCount: 2, syntaxKind: 83 /* GreaterThanEqualsToken */ }; + } + } + + return null; + }; + + ParserImpl.prototype.isRightAssociative = function (expressionKind) { + switch (expressionKind) { + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + return true; + default: + return false; + } + }; + + ParserImpl.prototype.parseMemberExpressionOrLower = function (inObjectCreation) { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } + + var expression = this.parsePrimaryExpression(); + if (expression === null) { + return this.eatIdentifierToken(); + } + + return this.parseMemberExpressionRest(expression, false, inObjectCreation); + }; + + ParserImpl.prototype.parseCallExpressionOrLower = function () { + var expression; + if (this.currentToken().tokenKind === 50 /* SuperKeyword */) { + expression = this.eatKeyword(50 /* SuperKeyword */); + + var currentTokenKind = this.currentToken().tokenKind; + if (currentTokenKind !== 72 /* OpenParenToken */ && currentTokenKind !== 76 /* DotToken */) { + expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken()); + } + } else { + expression = this.parseMemberExpressionOrLower(false); + } + + return this.parseMemberExpressionRest(expression, true, false); + }; + + ParserImpl.prototype.parseMemberExpressionRest = function (expression, allowArguments, inObjectCreation) { + while (true) { + var currentTokenKind = this.currentToken().tokenKind; + + switch (currentTokenKind) { + case 72 /* OpenParenToken */: + if (!allowArguments) { + return expression; + } + + expression = this.factory.invocationExpression(expression, this.parseArgumentList(null)); + continue; + + case 80 /* LessThanToken */: + if (!allowArguments) { + return expression; + } + + var argumentList = this.tryParseArgumentList(); + if (argumentList !== null) { + expression = this.factory.invocationExpression(expression, argumentList); + continue; + } + + break; + + case 74 /* OpenBracketToken */: + expression = this.parseElementAccessExpression(expression, inObjectCreation); + continue; + + case 76 /* DotToken */: + expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken()); + continue; + } + + return expression; + } + }; + + ParserImpl.prototype.parseLeftHandSideExpressionOrLower = function () { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } else { + return this.parseCallExpressionOrLower(); + } + }; + + ParserImpl.prototype.parsePostfixExpressionOrLower = function () { + var expression = this.parseLeftHandSideExpressionOrLower(); + if (expression === null) { + return this.eatIdentifierToken(); + } + + var currentTokenKind = this.currentToken().tokenKind; + + switch (currentTokenKind) { + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) { + break; + } + + return this.factory.postfixUnaryExpression(TypeScript.SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken(currentTokenKind), expression, this.eatAnyToken()); + } + + return expression; + }; + + ParserImpl.prototype.tryParseGenericArgumentList = function () { + var rewindPoint = this.getRewindPoint(); + + var typeArgumentList = this.tryParseTypeArgumentList(true); + var token0 = this.currentToken(); + + var isOpenParen = token0.tokenKind === 72 /* OpenParenToken */; + var isDot = token0.tokenKind === 76 /* DotToken */; + var isOpenParenOrDot = isOpenParen || isDot; + + var argumentList = null; + if (typeArgumentList === null || !isOpenParenOrDot) { + this.rewind(rewindPoint); + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + + if (isDot) { + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, null); + this.addDiagnostic(diagnostic); + + return this.factory.argumentList(typeArgumentList, TypeScript.Syntax.emptyToken(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.emptyToken(73 /* CloseParenToken */)); + } else { + return this.parseArgumentList(typeArgumentList); + } + } + }; + + ParserImpl.prototype.tryParseArgumentList = function () { + if (this.currentToken().tokenKind === 80 /* LessThanToken */) { + return this.tryParseGenericArgumentList(); + } + + if (this.currentToken().tokenKind === 72 /* OpenParenToken */) { + return this.parseArgumentList(null); + } + + return null; + }; + + ParserImpl.prototype.parseArgumentList = function (typeArgumentList) { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + + var _arguments = TypeScript.Syntax.emptySeparatedList; + + if (openParenToken.fullWidth() > 0) { + var result = this.parseSeparatedSyntaxList(16384 /* ArgumentList_AssignmentExpressions */); + _arguments = result.list; + openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.argumentList(typeArgumentList, openParenToken, _arguments, closeParenToken); + }; + + ParserImpl.prototype.parseElementAccessExpression = function (expression, inObjectCreation) { + var start = this.currentTokenStart(); + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var argumentExpression; + + if (this.currentToken().tokenKind === 75 /* CloseBracketToken */ && inObjectCreation) { + var end = this.currentTokenStart() + this.currentToken().width(); + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, start, end - start, TypeScript.DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, null); + this.addDiagnostic(diagnostic); + + argumentExpression = TypeScript.Syntax.emptyToken(11 /* IdentifierName */); + } else { + argumentExpression = this.parseExpression(true); + } + + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + return this.factory.elementAccessExpression(expression, openBracketToken, argumentExpression, closeBracketToken); + }; + + ParserImpl.prototype.parsePrimaryExpression = function () { + var currentToken = this.currentToken(); + + if (this.isIdentifier(currentToken)) { + return this.eatIdentifierToken(); + } + + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 35 /* ThisKeyword */: + return this.parseThisExpression(); + + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return this.parseLiteralExpression(); + + case 32 /* NullKeyword */: + return this.parseLiteralExpression(); + + case 27 /* FunctionKeyword */: + return this.parseFunctionExpression(); + + case 13 /* NumericLiteral */: + return this.parseLiteralExpression(); + + case 12 /* RegularExpressionLiteral */: + return this.parseLiteralExpression(); + + case 14 /* StringLiteral */: + return this.parseLiteralExpression(); + + case 74 /* OpenBracketToken */: + return this.parseArrayLiteralExpression(); + + case 70 /* OpenBraceToken */: + return this.parseObjectLiteralExpression(); + + case 72 /* OpenParenToken */: + return this.parseParenthesizedExpression(); + + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + var result = this.tryReparseDivideAsRegularExpression(); + if (result !== null) { + return result; + } + break; + } + + return null; + }; + + ParserImpl.prototype.tryReparseDivideAsRegularExpression = function () { + var currentToken = this.currentToken(); + + if (this.previousToken() !== null) { + var previousTokenKind = this.previousToken().tokenKind; + switch (previousTokenKind) { + case 11 /* IdentifierName */: + return null; + + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return null; + + case 14 /* StringLiteral */: + case 13 /* NumericLiteral */: + case 12 /* RegularExpressionLiteral */: + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + case 75 /* CloseBracketToken */: + return null; + } + } + + currentToken = this.currentTokenAllowingRegularExpression(); + + if (currentToken.tokenKind === 118 /* SlashToken */ || currentToken.tokenKind === 119 /* SlashEqualsToken */) { + return null; + } else if (currentToken.tokenKind === 12 /* RegularExpressionLiteral */) { + return this.parseLiteralExpression(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseTypeOfExpression = function () { + var typeOfKeyword = this.eatKeyword(39 /* TypeOfKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.typeOfExpression(typeOfKeyword, expression); + }; + + ParserImpl.prototype.parseDeleteExpression = function () { + var deleteKeyword = this.eatKeyword(21 /* DeleteKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.deleteExpression(deleteKeyword, expression); + }; + + ParserImpl.prototype.parseVoidExpression = function () { + var voidKeyword = this.eatKeyword(41 /* VoidKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.voidExpression(voidKeyword, expression); + }; + + ParserImpl.prototype.parseFunctionExpression = function () { + var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */); + var identifier = null; + + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + + var callSignature = this.parseCallSignature(false); + var block = this.parseBlock(false, true); + + return this.factory.functionExpression(functionKeyword, identifier, callSignature, block); + }; + + ParserImpl.prototype.parseObjectCreationExpression = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + + var expression = this.parseObjectCreationExpressionOrLower(true); + var argumentList = this.tryParseArgumentList(); + + var result = this.factory.objectCreationExpression(newKeyword, expression, argumentList); + return this.parseMemberExpressionRest(result, true, false); + }; + + ParserImpl.prototype.parseObjectCreationExpressionOrLower = function (inObjectCreation) { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } else { + return this.parseMemberExpressionOrLower(inObjectCreation); + } + }; + + ParserImpl.prototype.parseCastExpression = function () { + var lessThanToken = this.eatToken(80 /* LessThanToken */); + var type = this.parseType(); + var greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.castExpression(lessThanToken, type, greaterThanToken, expression); + }; + + ParserImpl.prototype.parseParenthesizedExpression = function () { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.parenthesizedExpression(openParenToken, expression, closeParenToken); + }; + + ParserImpl.prototype.tryParseParenthesizedArrowFunctionExpression = function () { + var tokenKind = this.currentToken().tokenKind; + if (tokenKind !== 72 /* OpenParenToken */ && tokenKind !== 80 /* LessThanToken */) { + return null; + } + + if (this.isDefinitelyArrowFunctionExpression()) { + return this.parseParenthesizedArrowFunctionExpression(false); + } + + if (!this.isPossiblyArrowFunctionExpression()) { + return null; + } + + var rewindPoint = this.getRewindPoint(); + + var arrowFunction = this.parseParenthesizedArrowFunctionExpression(true); + if (arrowFunction === null) { + this.rewind(rewindPoint); + } + + this.releaseRewindPoint(rewindPoint); + return arrowFunction; + }; + + ParserImpl.prototype.parseParenthesizedArrowFunctionExpression = function (requireArrow) { + var currentToken = this.currentToken(); + + var callSignature = this.parseCallSignature(true); + + if (requireArrow && this.currentToken().tokenKind !== 85 /* EqualsGreaterThanToken */) { + return null; + } + + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + + var block = this.tryParseArrowFunctionBlock(); + var expression = null; + if (block === null) { + expression = this.parseAssignmentExpression(true); + } + + return this.factory.parenthesizedArrowFunctionExpression(callSignature, equalsGreaterThanToken, block, expression); + }; + + ParserImpl.prototype.tryParseArrowFunctionBlock = function () { + if (this.isBlock()) { + return this.parseBlock(false, false); + } else { + if (this.isStatement(false) && !this.isExpressionStatement(this.currentToken()) && !this.isFunctionDeclaration()) { + return this.parseBlock(true, false); + } else { + return null; + } + } + }; + + ParserImpl.prototype.isSimpleArrowFunctionExpression = function () { + if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return this.isIdentifier(this.currentToken()) && this.peekToken(1).tokenKind === 85 /* EqualsGreaterThanToken */; + }; + + ParserImpl.prototype.parseSimpleArrowFunctionExpression = function () { + var identifier = this.eatIdentifierToken(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + + var block = this.tryParseArrowFunctionBlock(); + var expression = null; + if (block === null) { + expression = this.parseAssignmentExpression(true); + } + + return this.factory.simpleArrowFunctionExpression(identifier, equalsGreaterThanToken, block, expression); + }; + + ParserImpl.prototype.isBlock = function () { + return this.currentToken().tokenKind === 70 /* OpenBraceToken */; + }; + + ParserImpl.prototype.isDefinitelyArrowFunctionExpression = function () { + var token0 = this.currentToken(); + if (token0.tokenKind !== 72 /* OpenParenToken */) { + return false; + } + + var token1 = this.peekToken(1); + var token2; + + if (token1.tokenKind === 73 /* CloseParenToken */) { + token2 = this.peekToken(2); + return token2.tokenKind === 106 /* ColonToken */ || token2.tokenKind === 85 /* EqualsGreaterThanToken */ || token2.tokenKind === 70 /* OpenBraceToken */; + } + + if (token1.tokenKind === 77 /* DotDotDotToken */) { + return true; + } + + token2 = this.peekToken(2); + if (token1.tokenKind === 57 /* PublicKeyword */ || token1.tokenKind === 55 /* PrivateKeyword */) { + if (this.isIdentifier(token2)) { + return true; + } + } + + if (!this.isIdentifier(token1)) { + return false; + } + + if (token2.tokenKind === 106 /* ColonToken */) { + return true; + } + + var token3 = this.peekToken(3); + if (token2.tokenKind === 105 /* QuestionToken */) { + if (token3.tokenKind === 106 /* ColonToken */ || token3.tokenKind === 73 /* CloseParenToken */ || token3.tokenKind === 79 /* CommaToken */) { + return true; + } + } + + if (token2.tokenKind === 73 /* CloseParenToken */) { + if (token3.tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.isPossiblyArrowFunctionExpression = function () { + var token0 = this.currentToken(); + if (token0.tokenKind !== 72 /* OpenParenToken */) { + return true; + } + + var token1 = this.peekToken(1); + + if (!this.isIdentifier(token1)) { + return false; + } + + var token2 = this.peekToken(2); + if (token2.tokenKind === 107 /* EqualsToken */) { + return true; + } + + if (token2.tokenKind === 79 /* CommaToken */) { + return true; + } + + if (token2.tokenKind === 73 /* CloseParenToken */) { + var token3 = this.peekToken(3); + if (token3.tokenKind === 106 /* ColonToken */) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.parseObjectLiteralExpression = function () { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var result = this.parseSeparatedSyntaxList(32768 /* ObjectLiteralExpression_PropertyAssignments */); + var propertyAssignments = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.objectLiteralExpression(openBraceToken, propertyAssignments, closeBraceToken); + }; + + ParserImpl.prototype.parsePropertyAssignment = function (inErrorRecovery) { + if (this.isAccessor(inErrorRecovery)) { + return this.parseAccessor(true); + } else if (this.isFunctionPropertyAssignment(inErrorRecovery)) { + return this.parseFunctionPropertyAssignment(); + } else if (this.isSimplePropertyAssignment(inErrorRecovery)) { + return this.parseSimplePropertyAssignment(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isPropertyAssignment = function (inErrorRecovery) { + return this.isAccessor(inErrorRecovery) || this.isFunctionPropertyAssignment(inErrorRecovery) || this.isSimplePropertyAssignment(inErrorRecovery); + }; + + ParserImpl.prototype.eatPropertyName = function () { + return TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.currentToken()) ? this.eatIdentifierNameToken() : this.eatAnyToken(); + }; + + ParserImpl.prototype.isFunctionPropertyAssignment = function (inErrorRecovery) { + return this.isPropertyName(this.currentToken(), inErrorRecovery) && this.isCallSignature(1); + }; + + ParserImpl.prototype.parseFunctionPropertyAssignment = function () { + var propertyName = this.eatPropertyName(); + var callSignature = this.parseCallSignature(false); + var block = this.parseBlock(false, true); + + return this.factory.functionPropertyAssignment(propertyName, callSignature, block); + }; + + ParserImpl.prototype.isSimplePropertyAssignment = function (inErrorRecovery) { + return this.isPropertyName(this.currentToken(), inErrorRecovery); + }; + + ParserImpl.prototype.parseSimplePropertyAssignment = function () { + var propertyName = this.eatPropertyName(); + var colonToken = this.eatToken(106 /* ColonToken */); + var expression = this.parseAssignmentExpression(true); + + return this.factory.simplePropertyAssignment(propertyName, colonToken, expression); + }; + + ParserImpl.prototype.isPropertyName = function (token, inErrorRecovery) { + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) { + if (inErrorRecovery) { + return this.isIdentifier(token); + } else { + return true; + } + } + + switch (token.tokenKind) { + case 14 /* StringLiteral */: + case 13 /* NumericLiteral */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.parseArrayLiteralExpression = function () { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + + var result = this.parseSeparatedSyntaxList(65536 /* ArrayLiteralExpression_AssignmentExpressions */); + var expressions = result.list; + openBracketToken = this.addSkippedTokensAfterToken(openBracketToken, result.skippedTokens); + + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + return this.factory.arrayLiteralExpression(openBracketToken, expressions, closeBracketToken); + }; + + ParserImpl.prototype.parseLiteralExpression = function () { + return this.eatAnyToken(); + }; + + ParserImpl.prototype.parseThisExpression = function () { + return this.eatKeyword(35 /* ThisKeyword */); + }; + + ParserImpl.prototype.parseBlock = function (parseBlockEvenWithNoOpenBrace, checkForStrictMode) { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var statements = TypeScript.Syntax.emptyList; + + if (parseBlockEvenWithNoOpenBrace || openBraceToken.width() > 0) { + var savedIsInStrictMode = this.isInStrictMode; + + var processItems = checkForStrictMode ? ParserImpl.updateStrictModeState : null; + var result = this.parseSyntaxList(32 /* Block_Statements */, processItems); + statements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + + this.setStrictMode(savedIsInStrictMode); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.block(openBraceToken, statements, closeBraceToken); + }; + + ParserImpl.prototype.parseCallSignature = function (requireCompleteTypeParameterList) { + var typeParameterList = this.parseOptionalTypeParameterList(requireCompleteTypeParameterList); + var parameterList = this.parseParameterList(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.callSignature(typeParameterList, parameterList, typeAnnotation); + }; + + ParserImpl.prototype.parseOptionalTypeParameterList = function (requireCompleteTypeParameterList) { + if (this.currentToken().tokenKind !== 80 /* LessThanToken */) { + return null; + } + + var rewindPoint = this.getRewindPoint(); + + var lessThanToken = this.eatToken(80 /* LessThanToken */); + + var result = this.parseSeparatedSyntaxList(524288 /* TypeParameterList_TypeParameters */); + var typeParameters = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + var greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + if (requireCompleteTypeParameterList && greaterThanToken.fullWidth() === 0) { + this.rewind(rewindPoint); + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + var typeParameterList = this.factory.typeParameterList(lessThanToken, typeParameters, greaterThanToken); + + return typeParameterList; + } + }; + + ParserImpl.prototype.isTypeParameter = function () { + return this.isIdentifier(this.currentToken()); + }; + + ParserImpl.prototype.parseTypeParameter = function () { + var identifier = this.eatIdentifierToken(); + var constraint = this.parseOptionalConstraint(); + + return this.factory.typeParameter(identifier, constraint); + }; + + ParserImpl.prototype.parseOptionalConstraint = function () { + if (this.currentToken().kind() !== 48 /* ExtendsKeyword */) { + return null; + } + + var extendsKeyword = this.eatKeyword(48 /* ExtendsKeyword */); + var type = this.parseType(); + + return this.factory.constraint(extendsKeyword, type); + }; + + ParserImpl.prototype.parseParameterList = function () { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var parameters = TypeScript.Syntax.emptySeparatedList; + + if (openParenToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(131072 /* ParameterList_Parameters */); + parameters = result.list; + openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + return this.factory.parameterList(openParenToken, parameters, closeParenToken); + }; + + ParserImpl.prototype.isTypeAnnotation = function () { + return this.currentToken().tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.parseOptionalTypeAnnotation = function (allowStringLiteral) { + return this.isTypeAnnotation() ? this.parseTypeAnnotation(allowStringLiteral) : null; + }; + + ParserImpl.prototype.parseTypeAnnotation = function (allowStringLiteral) { + var colonToken = this.eatToken(106 /* ColonToken */); + var type = allowStringLiteral && this.currentToken().tokenKind === 14 /* StringLiteral */ ? this.eatToken(14 /* StringLiteral */) : this.parseType(); + + return this.factory.typeAnnotation(colonToken, type); + }; + + ParserImpl.prototype.isType = function () { + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + switch (currentTokenKind) { + case 39 /* TypeOfKeyword */: + + case 60 /* AnyKeyword */: + case 67 /* NumberKeyword */: + case 61 /* BooleanKeyword */: + case 69 /* StringKeyword */: + case 41 /* VoidKeyword */: + + case 70 /* OpenBraceToken */: + + case 72 /* OpenParenToken */: + case 80 /* LessThanToken */: + + case 31 /* NewKeyword */: + return true; + } + + return this.isIdentifier(currentToken); + }; + + ParserImpl.prototype.parseType = function () { + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + if (currentTokenKind === 39 /* TypeOfKeyword */) { + return this.parseTypeQuery(); + } + + var type = this.parseNonArrayType(currentToken); + + while (this.currentToken().tokenKind === 74 /* OpenBracketToken */) { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + type = this.factory.arrayType(type, openBracketToken, closeBracketToken); + } + + return type; + }; + + ParserImpl.prototype.isTypeQuery = function () { + return this.currentToken().tokenKind === 39 /* TypeOfKeyword */; + }; + + ParserImpl.prototype.parseTypeQuery = function () { + var typeOfKeyword = this.eatToken(39 /* TypeOfKeyword */); + var name = this.parseName(); + + return this.factory.typeQuery(typeOfKeyword, name); + }; + + ParserImpl.prototype.parseNonArrayType = function (currentToken) { + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 60 /* AnyKeyword */: + case 67 /* NumberKeyword */: + case 61 /* BooleanKeyword */: + case 69 /* StringKeyword */: + case 41 /* VoidKeyword */: + return this.eatAnyToken(); + + case 70 /* OpenBraceToken */: + return this.parseObjectType(); + + case 72 /* OpenParenToken */: + case 80 /* LessThanToken */: + return this.parseFunctionType(); + + case 31 /* NewKeyword */: + return this.parseConstructorType(); + } + + return this.parseNameOrGenericType(); + }; + + ParserImpl.prototype.parseNameOrGenericType = function () { + var name = this.parseName(); + var typeArgumentList = this.tryParseTypeArgumentList(false); + + return typeArgumentList === null ? name : this.factory.genericType(name, typeArgumentList); + }; + + ParserImpl.prototype.parseFunctionType = function () { + var typeParameterList = this.parseOptionalTypeParameterList(false); + var parameterList = this.parseParameterList(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + var returnType = this.parseType(); + + return this.factory.functionType(typeParameterList, parameterList, equalsGreaterThanToken, returnType); + }; + + ParserImpl.prototype.parseConstructorType = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var parameterList = this.parseParameterList(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + var type = this.parseType(); + + return this.factory.constructorType(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type); + }; + + ParserImpl.prototype.isParameter = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) { + return true; + } + + var token = this.currentToken(); + var tokenKind = token.tokenKind; + if (tokenKind === 77 /* DotDotDotToken */) { + return true; + } + + if (ParserImpl.isModifier(token) && !this.isModifierUsedAsParameterIdentifier(token)) { + return true; + } + + return this.isIdentifier(token); + }; + + ParserImpl.prototype.isModifierUsedAsParameterIdentifier = function (token) { + if (this.isIdentifier(token)) { + var nextTokenKind = this.peekToken(1).tokenKind; + switch (nextTokenKind) { + case 73 /* CloseParenToken */: + case 106 /* ColonToken */: + case 107 /* EqualsToken */: + case 79 /* CommaToken */: + case 105 /* QuestionToken */: + return true; + } + } + + return false; + }; + + ParserImpl.prototype.parseParameter = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) { + return this.eatNode(); + } + + var dotDotDotToken = this.tryEatToken(77 /* DotDotDotToken */); + + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (ParserImpl.isModifier(currentToken) && !this.isModifierUsedAsParameterIdentifier(currentToken)) { + modifierArray.push(this.eatAnyToken()); + continue; + } + + break; + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var identifier = this.eatIdentifierToken(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(true); + + var equalsValueClause = null; + if (this.isEqualsValueClause(true)) { + equalsValueClause = this.parseEqualsValueClause(true); + } + + return this.factory.parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause); + }; + + ParserImpl.prototype.parseSyntaxList = function (currentListType, processItems) { + if (typeof processItems === "undefined") { processItems = null; } + var savedListParsingState = this.listParsingState; + this.listParsingState |= currentListType; + + var result = this.parseSyntaxListWorker(currentListType, processItems); + + this.listParsingState = savedListParsingState; + + return result; + }; + + ParserImpl.prototype.parseSeparatedSyntaxList = function (currentListType) { + var savedListParsingState = this.listParsingState; + this.listParsingState |= currentListType; + + var result = this.parseSeparatedSyntaxListWorker(currentListType); + + this.listParsingState = savedListParsingState; + + return result; + }; + + ParserImpl.prototype.abortParsingListOrMoveToNextToken = function (currentListType, items, skippedTokens) { + this.reportUnexpectedTokenDiagnostic(currentListType); + + for (var state = 262144 /* LastListParsingState */; state >= 1 /* FirstListParsingState */; state >>= 1) { + if ((this.listParsingState & state) !== 0) { + if (this.isExpectedListTerminator(state) || this.isExpectedListItem(state, true)) { + return true; + } + } + } + + var skippedToken = this.currentToken(); + + this.moveToNextToken(); + + this.addSkippedTokenToList(items, skippedTokens, skippedToken); + + return false; + }; + + ParserImpl.prototype.addSkippedTokenToList = function (items, skippedTokens, skippedToken) { + for (var i = items.length - 1; i >= 0; i--) { + var item = items[i]; + var lastToken = item.lastToken(); + if (lastToken.fullWidth() > 0) { + items[i] = this.addSkippedTokenAfterNodeOrToken(item, skippedToken); + return; + } + } + + skippedTokens.push(skippedToken); + }; + + ParserImpl.prototype.tryParseExpectedListItem = function (currentListType, inErrorRecovery, items, processItems) { + if (this.isExpectedListItem(currentListType, inErrorRecovery)) { + var item = this.parseExpectedListItem(currentListType, inErrorRecovery); + + items.push(item); + + if (processItems !== null) { + processItems(this, items); + } + } + }; + + ParserImpl.prototype.listIsTerminated = function (currentListType) { + return this.isExpectedListTerminator(currentListType) || this.currentToken().tokenKind === 10 /* EndOfFileToken */; + }; + + ParserImpl.prototype.getArray = function () { + if (this.arrayPool.length > 0) { + return this.arrayPool.pop(); + } + + return []; + }; + + ParserImpl.prototype.returnZeroOrOneLengthArray = function (array) { + if (array.length <= 1) { + this.returnArray(array); + } + }; + + ParserImpl.prototype.returnArray = function (array) { + array.length = 0; + this.arrayPool.push(array); + }; + + ParserImpl.prototype.parseSyntaxListWorker = function (currentListType, processItems) { + var items = this.getArray(); + var skippedTokens = this.getArray(); + + while (true) { + var oldItemsCount = items.length; + this.tryParseExpectedListItem(currentListType, false, items, processItems); + + var newItemsCount = items.length; + if (newItemsCount === oldItemsCount) { + if (this.listIsTerminated(currentListType)) { + break; + } + + var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens); + if (abort) { + break; + } + } + } + + var result = TypeScript.Syntax.list(items); + + this.returnZeroOrOneLengthArray(items); + + return { skippedTokens: skippedTokens, list: result }; + }; + + ParserImpl.prototype.parseSeparatedSyntaxListWorker = function (currentListType) { + var items = this.getArray(); + var skippedTokens = this.getArray(); + TypeScript.Debug.assert(items.length === 0); + TypeScript.Debug.assert(skippedTokens.length === 0); + TypeScript.Debug.assert(skippedTokens !== items); + + var separatorKind = this.separatorKind(currentListType); + var allowAutomaticSemicolonInsertion = separatorKind === 78 /* SemicolonToken */; + + var inErrorRecovery = false; + var listWasTerminated = false; + while (true) { + var oldItemsCount = items.length; + + this.tryParseExpectedListItem(currentListType, inErrorRecovery, items, null); + + var newItemsCount = items.length; + if (newItemsCount === oldItemsCount) { + if (this.listIsTerminated(currentListType)) { + listWasTerminated = true; + break; + } + + var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens); + if (abort) { + break; + } else { + inErrorRecovery = true; + continue; + } + } + + inErrorRecovery = false; + + var currentToken = this.currentToken(); + if (currentToken.tokenKind === separatorKind || currentToken.tokenKind === 79 /* CommaToken */) { + items.push(this.eatAnyToken()); + continue; + } + + if (this.listIsTerminated(currentListType)) { + listWasTerminated = true; + break; + } + + if (allowAutomaticSemicolonInsertion && this.canEatAutomaticSemicolon(false)) { + items.push(this.eatExplicitOrAutomaticSemicolon(false)); + + continue; + } + + items.push(this.eatToken(separatorKind)); + + inErrorRecovery = true; + } + + var result = TypeScript.Syntax.separatedList(items); + + this.returnZeroOrOneLengthArray(items); + + return { skippedTokens: skippedTokens, list: result }; + }; + + ParserImpl.prototype.separatorKind = function (currentListType) { + switch (currentListType) { + case 2048 /* HeritageClause_TypeNameList */: + case 16384 /* ArgumentList_AssignmentExpressions */: + case 256 /* EnumDeclaration_EnumElements */: + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + case 131072 /* ParameterList_Parameters */: + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + case 262144 /* TypeArgumentList_Types */: + case 524288 /* TypeParameterList_TypeParameters */: + return 79 /* CommaToken */; + + case 512 /* ObjectType_TypeMembers */: + return 78 /* SemicolonToken */; + + case 1 /* SourceUnit_ModuleElements */: + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + case 2 /* ClassDeclaration_ClassElements */: + case 4 /* ModuleDeclaration_ModuleElements */: + case 8 /* SwitchStatement_SwitchClauses */: + case 16 /* SwitchClause_Statements */: + case 32 /* Block_Statements */: + default: + throw TypeScript.Errors.notYetImplemented(); + } + }; + + ParserImpl.prototype.reportUnexpectedTokenDiagnostic = function (listType) { + var token = this.currentToken(); + + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [this.getExpectedListElementType(listType)]); + this.addDiagnostic(diagnostic); + }; + + ParserImpl.prototype.addDiagnostic = function (diagnostic) { + if (this.diagnostics.length > 0 && this.diagnostics[this.diagnostics.length - 1].start() === diagnostic.start()) { + return; + } + + this.diagnostics.push(diagnostic); + }; + + ParserImpl.prototype.isExpectedListTerminator = function (currentListType) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.isExpectedSourceUnit_ModuleElementsTerminator(); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.isExpectedClassDeclaration_ClassElementsTerminator(); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.isExpectedModuleDeclaration_ModuleElementsTerminator(); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.isExpectedSwitchStatement_SwitchClausesTerminator(); + + case 16 /* SwitchClause_Statements */: + return this.isExpectedSwitchClause_StatementsTerminator(); + + case 32 /* Block_Statements */: + return this.isExpectedBlock_StatementsTerminator(); + + case 64 /* TryBlock_Statements */: + return this.isExpectedTryBlock_StatementsTerminator(); + + case 128 /* CatchBlock_Statements */: + return this.isExpectedCatchBlock_StatementsTerminator(); + + case 256 /* EnumDeclaration_EnumElements */: + return this.isExpectedEnumDeclaration_EnumElementsTerminator(); + + case 512 /* ObjectType_TypeMembers */: + return this.isExpectedObjectType_TypeMembersTerminator(); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.isExpectedArgumentList_AssignmentExpressionsTerminator(); + + case 2048 /* HeritageClause_TypeNameList */: + return this.isExpectedHeritageClause_TypeNameListTerminator(); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + return this.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator(); + + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator(); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator(); + + case 131072 /* ParameterList_Parameters */: + return this.isExpectedParameterList_ParametersTerminator(); + + case 262144 /* TypeArgumentList_Types */: + return this.isExpectedTypeArgumentList_TypesTerminator(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.isExpectedTypeParameterList_TypeParametersTerminator(); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.isExpectedLiteralExpression_AssignmentExpressionsTerminator(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isExpectedSourceUnit_ModuleElementsTerminator = function () { + return this.currentToken().tokenKind === 10 /* EndOfFileToken */; + }; + + ParserImpl.prototype.isExpectedEnumDeclaration_EnumElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedModuleDeclaration_ModuleElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedObjectType_TypeMembersTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedLiteralExpression_AssignmentExpressionsTerminator = function () { + return this.currentToken().tokenKind === 75 /* CloseBracketToken */; + }; + + ParserImpl.prototype.isExpectedTypeArgumentList_TypesTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 81 /* GreaterThanToken */) { + return true; + } + + if (this.canFollowTypeArgumentListInExpression(token.tokenKind)) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedTypeParameterList_TypeParametersTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 81 /* GreaterThanToken */) { + return true; + } + + if (token.tokenKind === 72 /* OpenParenToken */ || token.tokenKind === 70 /* OpenBraceToken */ || token.tokenKind === 48 /* ExtendsKeyword */ || token.tokenKind === 51 /* ImplementsKeyword */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedParameterList_ParametersTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 73 /* CloseParenToken */) { + return true; + } + + if (token.tokenKind === 70 /* OpenBraceToken */) { + return true; + } + + if (token.tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator = function () { + if (this.currentToken().tokenKind === 78 /* SemicolonToken */ || this.currentToken().tokenKind === 73 /* CloseParenToken */) { + return true; + } + + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator = function () { + if (this.previousToken().tokenKind === 79 /* CommaToken */) { + return false; + } + + if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return this.canEatExplicitOrAutomaticSemicolon(false); + }; + + ParserImpl.prototype.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 70 /* OpenBraceToken */ || token0.tokenKind === 71 /* CloseBraceToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedHeritageClause_TypeNameListTerminator = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */) { + return true; + } + + if (this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator()) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedArgumentList_AssignmentExpressionsTerminator = function () { + var token0 = this.currentToken(); + return token0.tokenKind === 73 /* CloseParenToken */ || token0.tokenKind === 78 /* SemicolonToken */; + }; + + ParserImpl.prototype.isExpectedClassDeclaration_ClassElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedSwitchStatement_SwitchClausesTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedSwitchClause_StatementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */ || this.isSwitchClause(); + }; + + ParserImpl.prototype.isExpectedBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedTryBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 17 /* CatchKeyword */ || this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.isExpectedCatchBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.isExpectedListItem = function (currentListType, inErrorRecovery) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.isModuleElement(inErrorRecovery); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.isHeritageClause(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.isClassElement(inErrorRecovery); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.isModuleElement(inErrorRecovery); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.isSwitchClause(); + + case 16 /* SwitchClause_Statements */: + return this.isStatement(inErrorRecovery); + + case 32 /* Block_Statements */: + return this.isStatement(inErrorRecovery); + + case 64 /* TryBlock_Statements */: + case 128 /* CatchBlock_Statements */: + return false; + + case 256 /* EnumDeclaration_EnumElements */: + return this.isEnumElement(inErrorRecovery); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.isVariableDeclarator(); + + case 512 /* ObjectType_TypeMembers */: + return this.isTypeMember(inErrorRecovery); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.isExpectedArgumentList_AssignmentExpression(); + + case 2048 /* HeritageClause_TypeNameList */: + return this.isHeritageClauseTypeName(); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.isPropertyAssignment(inErrorRecovery); + + case 131072 /* ParameterList_Parameters */: + return this.isParameter(); + + case 262144 /* TypeArgumentList_Types */: + return this.isType(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.isTypeParameter(); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.isAssignmentOrOmittedExpression(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isExpectedArgumentList_AssignmentExpression = function () { + var currentToken = this.currentToken(); + if (this.isExpression(currentToken)) { + return true; + } + + if (currentToken.tokenKind === 79 /* CommaToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.parseExpectedListItem = function (currentListType, inErrorRecovery) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.parseModuleElement(inErrorRecovery); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.parseHeritageClause(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.parseClassElement(inErrorRecovery); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.parseModuleElement(inErrorRecovery); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.parseSwitchClause(); + + case 16 /* SwitchClause_Statements */: + return this.parseStatement(inErrorRecovery); + + case 32 /* Block_Statements */: + return this.parseStatement(inErrorRecovery); + + case 256 /* EnumDeclaration_EnumElements */: + return this.parseEnumElement(); + + case 512 /* ObjectType_TypeMembers */: + return this.parseTypeMember(inErrorRecovery); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.parseAssignmentExpression(true); + + case 2048 /* HeritageClause_TypeNameList */: + return this.parseNameOrGenericType(); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + return this.parseVariableDeclarator(true, false); + + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.parseVariableDeclarator(false, false); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.parsePropertyAssignment(inErrorRecovery); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.parseAssignmentOrOmittedExpression(); + + case 131072 /* ParameterList_Parameters */: + return this.parseParameter(); + + case 262144 /* TypeArgumentList_Types */: + return this.parseType(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.parseTypeParameter(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.getExpectedListElementType = function (currentListType) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return '{'; + + case 2 /* ClassDeclaration_ClassElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.constructor_function_accessor_or_variable, null); + + case 4 /* ModuleDeclaration_ModuleElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null); + + case 8 /* SwitchStatement_SwitchClauses */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.case_or_default_clause, null); + + case 16 /* SwitchClause_Statements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null); + + case 32 /* Block_Statements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null); + + case 256 /* EnumDeclaration_EnumElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null); + + case 512 /* ObjectType_TypeMembers */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.call_construct_index_property_or_function_signature, null); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null); + + case 2048 /* HeritageClause_TypeNameList */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.property_or_accessor, null); + + case 131072 /* ParameterList_Parameters */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.parameter, null); + + case 262144 /* TypeArgumentList_Types */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type, null); + + case 524288 /* TypeParameterList_TypeParameters */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_parameter, null); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + return ParserImpl; + })(); + + function parse(fileName, text, isDeclaration, options) { + var source = new NormalParserSource(fileName, text, options.languageVersion()); + + return new ParserImpl(fileName, text.lineMap(), source, options, text).parseSyntaxTree(isDeclaration); + } + Parser.parse = parse; + + function incrementalParse(oldSyntaxTree, textChangeRange, newText) { + if (textChangeRange.isUnchanged()) { + return oldSyntaxTree; + } + + var source = new IncrementalParserSource(oldSyntaxTree, textChangeRange, newText); + + return new ParserImpl(oldSyntaxTree.fileName(), newText.lineMap(), source, oldSyntaxTree.parseOptions(), newText).parseSyntaxTree(oldSyntaxTree.isDeclaration()); + } + Parser.incrementalParse = incrementalParse; + })(TypeScript.Parser || (TypeScript.Parser = {})); + var Parser = TypeScript.Parser; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTree = (function () { + function SyntaxTree(sourceUnit, isDeclaration, diagnostics, fileName, lineMap, parseOtions) { + this._allDiagnostics = null; + this._sourceUnit = sourceUnit; + this._isDeclaration = isDeclaration; + this._parserDiagnostics = diagnostics; + this._fileName = fileName; + this._lineMap = lineMap; + this._parseOptions = parseOtions; + } + SyntaxTree.prototype.toJSON = function (key) { + var result = {}; + + result.isDeclaration = this._isDeclaration; + result.languageVersion = TypeScript.LanguageVersion[this._parseOptions.languageVersion()]; + result.parseOptions = this._parseOptions; + + if (this.diagnostics().length > 0) { + result.diagnostics = this.diagnostics(); + } + + result.sourceUnit = this._sourceUnit; + result.lineMap = this._lineMap; + + return result; + }; + + SyntaxTree.prototype.sourceUnit = function () { + return this._sourceUnit; + }; + + SyntaxTree.prototype.isDeclaration = function () { + return this._isDeclaration; + }; + + SyntaxTree.prototype.computeDiagnostics = function () { + if (this._parserDiagnostics.length > 0) { + return this._parserDiagnostics; + } + + var diagnostics = []; + this.sourceUnit().accept(new GrammarCheckerWalker(this, diagnostics)); + + return diagnostics; + }; + + SyntaxTree.prototype.diagnostics = function () { + if (this._allDiagnostics === null) { + this._allDiagnostics = this.computeDiagnostics(); + } + + return this._allDiagnostics; + }; + + SyntaxTree.prototype.fileName = function () { + return this._fileName; + }; + + SyntaxTree.prototype.lineMap = function () { + return this._lineMap; + }; + + SyntaxTree.prototype.parseOptions = function () { + return this._parseOptions; + }; + + SyntaxTree.prototype.structuralEquals = function (tree) { + return TypeScript.ArrayUtilities.sequenceEquals(this.diagnostics(), tree.diagnostics(), TypeScript.Diagnostic.equals) && this.sourceUnit().structuralEquals(tree.sourceUnit()); + }; + return SyntaxTree; + })(); + TypeScript.SyntaxTree = SyntaxTree; + + var GrammarCheckerWalker = (function (_super) { + __extends(GrammarCheckerWalker, _super); + function GrammarCheckerWalker(syntaxTree, diagnostics) { + _super.call(this); + this.syntaxTree = syntaxTree; + this.diagnostics = diagnostics; + this.inAmbientDeclaration = false; + this.inBlock = false; + this.inObjectLiteralExpression = false; + this.currentConstructor = null; + } + GrammarCheckerWalker.prototype.childFullStart = function (parent, child) { + return this.position() + TypeScript.Syntax.childOffset(parent, child); + }; + + GrammarCheckerWalker.prototype.childStart = function (parent, child) { + return this.childFullStart(parent, child) + child.leadingTriviaWidth(); + }; + + GrammarCheckerWalker.prototype.pushDiagnostic = function (start, length, diagnosticKey, args) { + if (typeof args === "undefined") { args = null; } + this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start, length, diagnosticKey, args)); + }; + + GrammarCheckerWalker.prototype.pushDiagnostic1 = function (elementFullStart, element, diagnosticKey, args) { + if (typeof args === "undefined") { args = null; } + this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), elementFullStart + element.leadingTriviaWidth(), element.width(), diagnosticKey, args)); + }; + + GrammarCheckerWalker.prototype.visitCatchClause = function (node) { + if (node.typeAnnotation) { + this.pushDiagnostic(this.childStart(node, node.typeAnnotation), node.typeAnnotation.width(), TypeScript.DiagnosticCode.Catch_clause_parameter_cannot_have_a_type_annotation); + } + + _super.prototype.visitCatchClause.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkParameterListOrder = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameters); + + var seenOptionalParameter = false; + var parameterCount = node.parameters.nonSeparatorCount(); + + for (var i = 0, n = node.parameters.childCount(); i < n; i++) { + var nodeOrToken = node.parameters.childAt(i); + if (i % 2 === 0) { + var parameterIndex = i / 2; + var parameter = node.parameters.childAt(i); + + if (parameter.dotDotDotToken) { + if (parameterIndex !== (parameterCount - 1)) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_must_be_last_in_list); + return true; + } + + if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_be_optional); + return true; + } + + if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_have_an_initializer); + return true; + } + } else if (parameter.questionToken || parameter.equalsValueClause) { + seenOptionalParameter = true; + + if (parameter.questionToken && parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Parameter_cannot_have_question_mark_and_initializer); + return true; + } + } else { + if (seenOptionalParameter) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Required_parameter_cannot_follow_optional_parameter); + return true; + } + } + } + + parameterFullStart += nodeOrToken.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterListAcessibilityModifiers = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameters); + + for (var i = 0, n = node.parameters.childCount(); i < n; i++) { + var nodeOrToken = node.parameters.childAt(i); + if (i % 2 === 0) { + var parameter = node.parameters.childAt(i); + + if (this.checkParameterAccessibilityModifiers(node, parameter, parameterFullStart)) { + return true; + } + } + + parameterFullStart += nodeOrToken.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterAccessibilityModifiers = function (parameterList, parameter, parameterFullStart) { + if (parameter.modifiers.childCount() > 0) { + var modifiers = parameter.modifiers; + var modifierFullStart = parameterFullStart + TypeScript.Syntax.childOffset(parameter, modifiers); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + + if (this.checkParameterAccessibilityModifier(parameterList, modifier, modifierFullStart, i)) { + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterAccessibilityModifier = function (parameterList, modifier, modifierFullStart, modifierIndex) { + if (modifier.tokenKind !== 57 /* PublicKeyword */ && modifier.tokenKind !== 55 /* PrivateKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]); + return true; + } else { + if (modifierIndex > 0) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return true; + } + + if (this.inAmbientDeclaration) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_an_ambient_context); + return true; + } else if (this.currentConstructor && !this.currentConstructor.block && this.currentConstructor.parameterList === parameterList) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_a_constructor_overload); + return true; + } else if (this.currentConstructor === null || this.currentConstructor.parameterList !== parameterList) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_can_only_be_used_in_constructors); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForTrailingSeparator = function (parent, list) { + if (list.childCount() === 0 || list.childCount() % 2 === 1) { + return false; + } + + var currentElementFullStart = this.childFullStart(parent, list); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var child = list.childAt(i); + if (i === n - 1) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode.Trailing_separator_not_allowed); + } + + currentElementFullStart += child.fullWidth(); + } + + return true; + }; + + GrammarCheckerWalker.prototype.checkForAtLeastOneElement = function (parent, list, expected) { + if (list.childCount() > 0) { + return false; + } + + var listFullStart = this.childFullStart(parent, list); + var tokenAtStart = this.syntaxTree.sourceUnit().findToken(listFullStart); + + this.pushDiagnostic1(listFullStart, tokenAtStart.token(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [expected]); + + return true; + }; + + GrammarCheckerWalker.prototype.visitParameterList = function (node) { + if (this.checkParameterListAcessibilityModifiers(node) || this.checkParameterListOrder(node) || this.checkForTrailingSeparator(node, node.parameters)) { + this.skip(node); + return; + } + + _super.prototype.visitParameterList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitHeritageClause = function (node) { + if (this.checkForTrailingSeparator(node, node.typeNames) || this.checkForAtLeastOneElement(node, node.typeNames, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null))) { + this.skip(node); + return; + } + + _super.prototype.visitHeritageClause.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitArgumentList = function (node) { + if (this.checkForTrailingSeparator(node, node.arguments)) { + this.skip(node); + return; + } + + _super.prototype.visitArgumentList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitVariableDeclaration = function (node) { + if (this.checkForTrailingSeparator(node, node.variableDeclarators) || this.checkForAtLeastOneElement(node, node.variableDeclarators, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitVariableDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTypeArgumentList = function (node) { + if (this.checkForTrailingSeparator(node, node.typeArguments) || this.checkForAtLeastOneElement(node, node.typeArguments, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitTypeArgumentList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTypeParameterList = function (node) { + if (this.checkForTrailingSeparator(node, node.typeParameters) || this.checkForAtLeastOneElement(node, node.typeParameters, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitTypeParameterList.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkIndexSignatureParameter = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameter); + var parameter = node.parameter; + + if (parameter.dotDotDotToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signatures_cannot_have_rest_parameters); + return true; + } else if (parameter.modifiers.childCount() > 0) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_accessibility_modifiers); + return true; + } else if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_a_question_mark); + return true; + } else if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_an_initializer); + return true; + } else if (!parameter.typeAnnotation) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation); + return true; + } else if (parameter.typeAnnotation.type.kind() !== 69 /* StringKeyword */ && parameter.typeAnnotation.type.kind() !== 67 /* NumberKeyword */) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitIndexSignature = function (node) { + if (this.checkIndexSignatureParameter(node)) { + this.skip(node); + return; + } + + if (!node.typeAnnotation) { + this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.Index_signature_must_have_a_type_annotation); + this.skip(node); + return; + } + + _super.prototype.visitIndexSignature.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkClassDeclarationHeritageClauses = function (node) { + var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses); + + var seenExtendsClause = false; + var seenImplementsClause = false; + + for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) { + TypeScript.Debug.assert(i <= 2); + var heritageClause = node.heritageClauses.childAt(i); + + if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) { + if (seenExtendsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen); + return true; + } + + if (seenImplementsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_must_precede_implements_clause); + return true; + } + + if (heritageClause.typeNames.nonSeparatorCount() > 1) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Classes_can_only_extend_a_single_class); + return true; + } + + seenExtendsClause = true; + } else { + TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + if (seenImplementsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.implements_clause_already_seen); + return true; + } + + seenImplementsClause = true; + } + + heritageClauseFullStart += heritageClause.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifier = function (modifiers) { + if (this.inAmbientDeclaration) { + var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */); + + if (declareToken) { + this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_for_code_already_in_an_ambient_context); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForRequiredDeclareModifier = function (moduleElement, typeKeyword, modifiers) { + if (!this.inAmbientDeclaration && this.syntaxTree.isDeclaration()) { + if (!TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) { + this.pushDiagnostic1(this.childFullStart(moduleElement, typeKeyword), typeKeyword.firstToken(), TypeScript.DiagnosticCode.declare_modifier_required_for_top_level_element); + return true; + } + } + }; + + GrammarCheckerWalker.prototype.checkFunctionOverloads = function (node, moduleElements) { + if (!this.inAmbientDeclaration && !this.syntaxTree.isDeclaration()) { + var moduleElementFullStart = this.childFullStart(node, moduleElements); + + var inFunctionOverloadChain = false; + var functionOverloadChainName = null; + + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + var lastElement = i === (n - 1); + + if (inFunctionOverloadChain) { + if (moduleElement.kind() !== 129 /* FunctionDeclaration */) { + this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + + var functionDeclaration = moduleElement; + if (functionDeclaration.identifier.valueText() !== functionOverloadChainName) { + var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier); + this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]); + return true; + } + } + + if (moduleElement.kind() === 129 /* FunctionDeclaration */) { + functionDeclaration = moduleElement; + if (!TypeScript.SyntaxUtilities.containsToken(functionDeclaration.modifiers, 63 /* DeclareKeyword */)) { + inFunctionOverloadChain = functionDeclaration.block === null; + functionOverloadChainName = functionDeclaration.identifier.valueText(); + + if (lastElement && inFunctionOverloadChain) { + this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + } else { + inFunctionOverloadChain = false; + functionOverloadChainName = ""; + } + } + + moduleElementFullStart += moduleElement.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkClassOverloads = function (node) { + if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + var classElementFullStart = this.childFullStart(node, node.classElements); + + var inFunctionOverloadChain = false; + var inConstructorOverloadChain = false; + + var functionOverloadChainName = null; + var isInStaticOverloadChain = null; + var memberFunctionDeclaration = null; + + for (var i = 0, n = node.classElements.childCount(); i < n; i++) { + var classElement = node.classElements.childAt(i); + var lastElement = i === (n - 1); + var isStaticOverload = null; + + if (inFunctionOverloadChain) { + if (classElement.kind() !== 135 /* MemberFunctionDeclaration */) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + + memberFunctionDeclaration = classElement; + if (memberFunctionDeclaration.propertyName.valueText() !== functionOverloadChainName) { + var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName); + this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]); + return true; + } + isStaticOverload = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */); + if (isStaticOverload !== isInStaticOverloadChain) { + propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName); + var diagnostic = isInStaticOverloadChain ? TypeScript.DiagnosticCode.Function_overload_must_be_static : TypeScript.DiagnosticCode.Function_overload_must_not_be_static; + this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, diagnostic, null); + return true; + } + } else if (inConstructorOverloadChain) { + if (classElement.kind() !== 137 /* ConstructorDeclaration */) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected); + return true; + } + } + + if (classElement.kind() === 135 /* MemberFunctionDeclaration */) { + memberFunctionDeclaration = classElement; + + inFunctionOverloadChain = memberFunctionDeclaration.block === null; + functionOverloadChainName = memberFunctionDeclaration.propertyName.valueText(); + isInStaticOverloadChain = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */); + + if (lastElement && inFunctionOverloadChain) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + } else if (classElement.kind() === 137 /* ConstructorDeclaration */) { + var constructorDeclaration = classElement; + + inConstructorOverloadChain = constructorDeclaration.block === null; + if (lastElement && inConstructorOverloadChain) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected); + return true; + } + } + + classElementFullStart += classElement.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForReservedName = function (parent, name, diagnosticKey) { + var nameFullStart = this.childFullStart(parent, name); + var token; + var tokenFullStart; + + var current = name; + while (current !== null) { + if (current.kind() === 121 /* QualifiedName */) { + var qualifiedName = current; + token = qualifiedName.right; + tokenFullStart = nameFullStart + this.childFullStart(qualifiedName, token); + current = qualifiedName.left; + } else { + TypeScript.Debug.assert(current.kind() === 11 /* IdentifierName */); + token = current; + tokenFullStart = nameFullStart; + current = null; + } + + switch (token.valueText()) { + case "any": + case "number": + case "boolean": + case "string": + case "void": + this.pushDiagnostic(tokenFullStart + token.leadingTriviaWidth(), token.width(), diagnosticKey, [token.valueText()]); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitClassDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Class_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.classKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkClassDeclarationHeritageClauses(node) || this.checkClassOverloads(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitClassDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkInterfaceDeclarationHeritageClauses = function (node) { + var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses); + + var seenExtendsClause = false; + + for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) { + TypeScript.Debug.assert(i <= 1); + var heritageClause = node.heritageClauses.childAt(i); + + if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) { + if (seenExtendsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen); + return true; + } + + seenExtendsClause = true; + } else { + TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Interface_declaration_cannot_have_implements_clause); + return true; + } + + heritageClauseFullStart += heritageClause.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkInterfaceModifiers = function (modifiers) { + var modifierFullStart = this.position(); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + if (modifier.tokenKind === 63 /* DeclareKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.declare_modifier_cannot_appear_on_an_interface_declaration); + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitInterfaceDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Interface_name_cannot_be_0) || this.checkInterfaceModifiers(node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkInterfaceDeclarationHeritageClauses(node)) { + this.skip(node); + return; + } + + _super.prototype.visitInterfaceDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkClassElementModifiers = function (list) { + var modifierFullStart = this.position(); + + var seenAccessibilityModifier = false; + var seenStaticModifier = false; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var modifier = list.childAt(i); + if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */) { + if (seenAccessibilityModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return true; + } + + if (seenStaticModifier) { + var previousToken = list.childAt(i - 1); + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), previousToken.text()]); + return true; + } + + seenAccessibilityModifier = true; + } else if (modifier.tokenKind === 58 /* StaticKeyword */) { + if (seenStaticModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]); + return true; + } + + seenStaticModifier = true; + } else { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_class_element, [modifier.text()]); + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitMemberVariableDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitMemberVariableDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitMemberFunctionDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitMemberFunctionDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkGetAccessorParameter = function (node, getKeyword, parameterList) { + var getKeywordFullStart = this.childFullStart(node, getKeyword); + if (parameterList.parameters.childCount() !== 0) { + this.pushDiagnostic1(getKeywordFullStart, getKeyword, TypeScript.DiagnosticCode.get_accessor_cannot_have_parameters); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitIndexMemberDeclaration = function (node) { + if (this.checkIndexMemberModifiers(node)) { + this.skip(node); + return; + } + + _super.prototype.visitIndexMemberDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkIndexMemberModifiers = function (node) { + if (node.modifiers.childCount() > 0) { + var modifierFullStart = this.childFullStart(node, node.modifiers); + this.pushDiagnostic1(modifierFullStart, node.modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkEcmaScriptVersionIsAtLeast = function (parent, node, languageVersion, diagnosticKey) { + if (this.syntaxTree.parseOptions().languageVersion() < languageVersion) { + var nodeFullStart = this.childFullStart(parent, node); + this.pushDiagnostic1(nodeFullStart, node, diagnosticKey); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitObjectLiteralExpression = function (node) { + var savedInObjectLiteralExpression = this.inObjectLiteralExpression; + this.inObjectLiteralExpression = true; + _super.prototype.visitObjectLiteralExpression.call(this, node); + this.inObjectLiteralExpression = savedInObjectLiteralExpression; + }; + + GrammarCheckerWalker.prototype.visitGetAccessor = function (node) { + if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.getKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkGetAccessorParameter(node, node.getKeyword, node.parameterList)) { + this.skip(node); + return; + } + + _super.prototype.visitGetAccessor.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkForAccessorDeclarationInAmbientContext = function (accessor) { + if (this.inAmbientDeclaration) { + this.pushDiagnostic1(this.position(), accessor, TypeScript.DiagnosticCode.Accessors_are_not_allowed_in_ambient_contexts, null); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkSetAccessorParameter = function (node, setKeyword, parameterList) { + var setKeywordFullStart = this.childFullStart(node, setKeyword); + if (parameterList.parameters.childCount() !== 1) { + this.pushDiagnostic1(setKeywordFullStart, setKeyword, TypeScript.DiagnosticCode.set_accessor_must_have_one_and_only_one_parameter); + return true; + } + + var parameterListFullStart = this.childFullStart(node, parameterList); + var parameterFullStart = parameterListFullStart + TypeScript.Syntax.childOffset(parameterList, parameterList.openParenToken); + var parameter = parameterList.parameters.childAt(0); + + if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_be_optional); + return true; + } + + if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_have_an_initializer); + return true; + } + + if (parameter.dotDotDotToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_cannot_have_rest_parameter); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitSetAccessor = function (node) { + if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.setKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkSetAccessorParameter(node, node.setKeyword, node.parameterList)) { + this.skip(node); + return; + } + + _super.prototype.visitSetAccessor.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitEnumDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Enum_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.enumKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers), this.checkEnumElements(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitEnumDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkEnumElements = function (node) { + var enumElementFullStart = this.childFullStart(node, node.enumElements); + + var seenComputedValue = false; + for (var i = 0, n = node.enumElements.childCount(); i < n; i++) { + var child = node.enumElements.childAt(i); + + if (i % 2 === 0) { + var enumElement = child; + + if (!enumElement.equalsValueClause && seenComputedValue) { + this.pushDiagnostic1(enumElementFullStart, enumElement, TypeScript.DiagnosticCode.Enum_member_must_have_initializer, null); + return true; + } + + if (enumElement.equalsValueClause) { + var value = enumElement.equalsValueClause.value; + if (!TypeScript.Syntax.isIntegerLiteral(value)) { + seenComputedValue = true; + } + } + } + + enumElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitEnumElement = function (node) { + if (this.inAmbientDeclaration && node.equalsValueClause) { + var expression = node.equalsValueClause.value; + if (!TypeScript.Syntax.isIntegerLiteral(expression)) { + this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Ambient_enum_elements_can_only_have_integer_literal_initializers); + this.skip(node); + return; + } + } + + _super.prototype.visitEnumElement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitInvocationExpression = function (node) { + if (node.expression.kind() === 50 /* SuperKeyword */ && node.argumentList.typeArgumentList !== null) { + this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.super_invocation_cannot_have_type_arguments); + } + + _super.prototype.visitInvocationExpression.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkModuleElementModifiers = function (modifiers) { + var modifierFullStart = this.position(); + var seenExportModifier = false; + var seenDeclareModifier = false; + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */ || modifier.tokenKind === 58 /* StaticKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_module_element, [modifier.text()]); + return true; + } + + if (modifier.tokenKind === 63 /* DeclareKeyword */) { + if (seenDeclareModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return; + } + + seenDeclareModifier = true; + } else if (modifier.tokenKind === 47 /* ExportKeyword */) { + if (seenExportModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]); + return; + } + + if (seenDeclareModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [TypeScript.SyntaxFacts.getText(47 /* ExportKeyword */), TypeScript.SyntaxFacts.getText(63 /* DeclareKeyword */)]); + return; + } + + seenExportModifier = true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedImportDeclaration = function (node) { + var currentElementFullStart = this.childFullStart(node, node.moduleElements); + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var child = node.moduleElements.childAt(i); + if (child.kind() === 133 /* ImportDeclaration */) { + var importDeclaration = child; + if (importDeclaration.moduleReference.kind() === 245 /* ExternalModuleReference */) { + if (node.stringLiteral === null) { + this.pushDiagnostic1(currentElementFullStart, importDeclaration, TypeScript.DiagnosticCode.Import_declarations_in_an_internal_module_cannot_reference_an_external_module, null); + } + } + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifierOnImportDeclaration = function (modifiers) { + var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */); + + if (declareToken) { + this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_on_import_declaration); + return true; + } + }; + + GrammarCheckerWalker.prototype.visitImportDeclaration = function (node) { + if (this.checkForDisallowedDeclareModifierOnImportDeclaration(node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitImportDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitModuleDeclaration = function (node) { + if (this.checkForReservedName(node, node.name, TypeScript.DiagnosticCode.Module_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.moduleKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkForDisallowedImportDeclaration(node) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) { + this.skip(node); + return; + } + + if (!TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */) && this.checkFunctionOverloads(node, node.moduleElements)) { + this.skip(node); + return; + } + + if (node.stringLiteral) { + if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + var stringLiteralFullStart = this.childFullStart(node, node.stringLiteral); + this.pushDiagnostic1(stringLiteralFullStart, node.stringLiteral, TypeScript.DiagnosticCode.Only_ambient_modules_can_use_quoted_names); + this.skip(node); + return; + } + } + + if (!node.stringLiteral && this.checkForDisallowedExportAssignment(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitModuleDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedExports = function (node, moduleElements) { + var seenExportedElement = false; + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + + if (TypeScript.SyntaxUtilities.hasExportKeyword(child)) { + seenExportedElement = true; + break; + } + } + + var moduleElementFullStart = this.childFullStart(node, moduleElements); + if (seenExportedElement) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + + if (child.kind() === 134 /* ExportAssignment */) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_not_allowed_in_module_with_exported_element); + return true; + } + + moduleElementFullStart += child.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForMultipleExportAssignments = function (node, moduleElements) { + var moduleElementFullStart = this.childFullStart(node, moduleElements); + var seenExportAssignment = false; + var errorFound = false; + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + if (child.kind() === 134 /* ExportAssignment */) { + if (seenExportAssignment) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Module_cannot_have_multiple_export_assignments); + errorFound = true; + } + seenExportAssignment = true; + } + + moduleElementFullStart += child.fullWidth(); + } + + return errorFound; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedExportAssignment = function (node) { + var moduleElementFullStart = this.childFullStart(node, node.moduleElements); + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var child = node.moduleElements.childAt(i); + + if (child.kind() === 134 /* ExportAssignment */) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_cannot_be_used_in_internal_modules); + + return true; + } + + moduleElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitBlock = function (node) { + if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) { + this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Implementations_are_not_allowed_in_ambient_contexts); + this.skip(node); + return; + } + + if (this.checkFunctionOverloads(node, node.statements)) { + this.skip(node); + return; + } + + var savedInBlock = this.inBlock; + this.inBlock = true; + _super.prototype.visitBlock.call(this, node); + this.inBlock = savedInBlock; + }; + + GrammarCheckerWalker.prototype.checkForStatementInAmbientContxt = function (node) { + if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) { + this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Statements_are_not_allowed_in_ambient_contexts); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitBreakStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitBreakStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitContinueStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitContinueStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitDebuggerStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitDebuggerStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitDoStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitDoStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitEmptyStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitEmptyStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitExpressionStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitExpressionStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitForInStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitForInStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitForStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitForStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitIfStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitIfStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitLabeledStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitLabeledStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitReturnStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitReturnStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitSwitchStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitSwitchStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitThrowStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitThrowStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTryStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitTryStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitWhileStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitWhileStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitWithStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitWithStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkForDisallowedModifiers = function (parent, modifiers) { + if (this.inBlock || this.inObjectLiteralExpression) { + if (modifiers.childCount() > 0) { + var modifierFullStart = this.childFullStart(parent, modifiers); + this.pushDiagnostic1(modifierFullStart, modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitFunctionDeclaration = function (node) { + if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.functionKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitFunctionDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitVariableStatement = function (node) { + if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.variableDeclaration, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitVariableStatement.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkListSeparators = function (parent, list, kind) { + var currentElementFullStart = this.childFullStart(parent, list); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var child = list.childAt(i); + if (i % 2 === 1 && child.kind() !== kind) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(kind)]); + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitObjectType = function (node) { + if (this.checkListSeparators(node, node.typeMembers, 78 /* SemicolonToken */)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitObjectType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitArrayType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitArrayType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitFunctionType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitFunctionType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitConstructorType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitConstructorType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitVariableDeclarator = function (node) { + if (this.inAmbientDeclaration && node.equalsValueClause) { + this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Initializers_are_not_allowed_in_ambient_contexts); + this.skip(node); + return; + } + + _super.prototype.visitVariableDeclarator.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitConstructorDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers) || this.checkConstructorModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedCurrentConstructor = this.currentConstructor; + this.currentConstructor = node; + _super.prototype.visitConstructorDeclaration.call(this, node); + this.currentConstructor = savedCurrentConstructor; + }; + + GrammarCheckerWalker.prototype.checkConstructorModifiers = function (modifiers) { + var currentElementFullStart = this.position(); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var child = modifiers.childAt(i); + if (child.kind() !== 57 /* PublicKeyword */) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [TypeScript.SyntaxFacts.getText(child.kind())]); + return true; + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitSourceUnit = function (node) { + if (this.checkFunctionOverloads(node, node.moduleElements) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) { + this.skip(node); + return; + } + + _super.prototype.visitSourceUnit.call(this, node); + }; + return GrammarCheckerWalker; + })(TypeScript.PositionTrackingWalker); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Unicode = (function () { + function Unicode() { + } + Unicode.lookupInUnicodeMap = function (code, map) { + if (code < map[0]) { + return false; + } + + var lo = 0; + var hi = map.length; + var mid; + + while (lo + 1 < hi) { + mid = lo + (hi - lo) / 2; + + mid -= mid % 2; + if (map[mid] <= code && code <= map[mid + 1]) { + return true; + } + + if (code < map[mid]) { + hi = mid; + } else { + lo = mid + 2; + } + } + + return false; + }; + + Unicode.isIdentifierStart = function (code, languageVersion) { + if (languageVersion === 0 /* EcmaScript3 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierStart); + } else if (languageVersion === 1 /* EcmaScript5 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierStart); + } else { + throw TypeScript.Errors.argumentOutOfRange("languageVersion"); + } + }; + + Unicode.isIdentifierPart = function (code, languageVersion) { + if (languageVersion === 0 /* EcmaScript3 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierPart); + } else if (languageVersion === 1 /* EcmaScript5 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierPart); + } else { + throw TypeScript.Errors.argumentOutOfRange("languageVersion"); + } + }; + Unicode.unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + Unicode.unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + + Unicode.unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + Unicode.unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + return Unicode; + })(); + TypeScript.Unicode = Unicode; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (CompilerDiagnostics) { + CompilerDiagnostics.debug = false; + + CompilerDiagnostics.diagnosticWriter = null; + + CompilerDiagnostics.analysisPass = 0; + + function Alert(output) { + if (CompilerDiagnostics.diagnosticWriter) { + CompilerDiagnostics.diagnosticWriter.Alert(output); + } + } + CompilerDiagnostics.Alert = Alert; + + function debugPrint(s) { + if (CompilerDiagnostics.debug) { + Alert(s); + } + } + CompilerDiagnostics.debugPrint = debugPrint; + + function assert(condition, s) { + if (CompilerDiagnostics.debug) { + if (!condition) { + Alert(s); + } + } + } + CompilerDiagnostics.assert = assert; + })(TypeScript.CompilerDiagnostics || (TypeScript.CompilerDiagnostics = {})); + var CompilerDiagnostics = TypeScript.CompilerDiagnostics; + + var NullLogger = (function () { + function NullLogger() { + } + NullLogger.prototype.information = function () { + return false; + }; + NullLogger.prototype.debug = function () { + return false; + }; + NullLogger.prototype.warning = function () { + return false; + }; + NullLogger.prototype.error = function () { + return false; + }; + NullLogger.prototype.fatal = function () { + return false; + }; + NullLogger.prototype.log = function (s) { + }; + return NullLogger; + })(); + TypeScript.NullLogger = NullLogger; + + function timeFunction(logger, funcDescription, func) { + var start = (new Date()).getTime(); + var result = func(); + var end = (new Date()).getTime(); + logger.log(funcDescription + " completed in " + (end - start) + " msec"); + return result; + } + TypeScript.timeFunction = timeFunction; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Document = (function () { + function Document(_compiler, _semanticInfoChain, fileName, referencedFiles, _scriptSnapshot, byteOrderMark, version, isOpen, _syntaxTree, _topLevelDecl) { + this._compiler = _compiler; + this._semanticInfoChain = _semanticInfoChain; + this.fileName = fileName; + this.referencedFiles = referencedFiles; + this._scriptSnapshot = _scriptSnapshot; + this.byteOrderMark = byteOrderMark; + this.version = version; + this.isOpen = isOpen; + this._syntaxTree = _syntaxTree; + this._topLevelDecl = _topLevelDecl; + this._diagnostics = null; + this._bloomFilter = null; + this._sourceUnit = null; + this._lineMap = null; + this._declASTMap = []; + this._astDeclMap = []; + this._isExternalModule = undefined; + this._amdDependencies = undefined; + } + Document.prototype.invalidate = function () { + this._declASTMap.length = 0; + this._astDeclMap.length = 0; + this._topLevelDecl = null; + + this._syntaxTree = null; + this._sourceUnit = null; + this._diagnostics = null; + this._bloomFilter = null; + }; + + Document.prototype.isDeclareFile = function () { + return TypeScript.isDTSFile(this.fileName); + }; + + Document.prototype.cacheSyntaxTreeInfo = function (syntaxTree) { + var start = new Date().getTime(); + this._diagnostics = syntaxTree.diagnostics(); + TypeScript.syntaxDiagnosticsTime += new Date().getTime() - start; + + this._lineMap = syntaxTree.lineMap(); + + var sourceUnit = syntaxTree.sourceUnit(); + var leadingComments = this.getLeadingComments(sourceUnit); + + this._isExternalModule = this.hasImplicitImport(leadingComments) || this.hasTopLevelImportOrExport(sourceUnit); + + var amdDependencies = []; + for (var i = 0, n = leadingComments.length; i < n; i++) { + var trivia = leadingComments[i]; + var amdDependency = this.getAmdDependency(trivia.fullText()); + if (amdDependency) { + amdDependencies.push(amdDependency); + } + } + + this._amdDependencies = amdDependencies; + }; + + Document.prototype.getLeadingComments = function (node) { + var firstToken = node.firstToken(); + var result = []; + + if (firstToken.hasLeadingComment()) { + var leadingTrivia = firstToken.leadingTrivia(); + + for (var i = 0, n = leadingTrivia.count(); i < n; i++) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + + if (trivia.isComment()) { + result.push(trivia); + } + } + } + + return result; + }; + + Document.prototype.getAmdDependency = function (comment) { + var amdDependencyRegEx = /^\/\/\/\s*/gim; + var match = implicitImportRegEx.exec(comment); + + if (match) { + return true; + } + + return false; + }; + + Document.prototype.hasTopLevelImportOrExport = function (node) { + var firstToken; + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var moduleElement = node.moduleElements.childAt(i); + + firstToken = moduleElement.firstToken(); + if (firstToken !== null && firstToken.tokenKind === 47 /* ExportKeyword */) { + return true; + } + + if (moduleElement.kind() === 133 /* ImportDeclaration */) { + var importDecl = moduleElement; + if (importDecl.moduleReference.kind() === 245 /* ExternalModuleReference */) { + return true; + } + } + } + + return false; + }; + + Document.prototype.sourceUnit = function () { + if (!this._sourceUnit) { + var start = new Date().getTime(); + var syntaxTree = this.syntaxTree(); + this._sourceUnit = TypeScript.SyntaxTreeToAstVisitor.visit(syntaxTree, this.fileName, this._compiler.compilationSettings(), this.isOpen); + TypeScript.astTranslationTime += new Date().getTime() - start; + + if (!this.isOpen) { + this._syntaxTree = null; + } + } + + return this._sourceUnit; + }; + + Document.prototype.diagnostics = function () { + if (this._diagnostics === null) { + this.syntaxTree(); + TypeScript.Debug.assert(this._diagnostics); + } + + return this._diagnostics; + }; + + Document.prototype.lineMap = function () { + if (this._lineMap === null) { + this.syntaxTree(); + TypeScript.Debug.assert(this._lineMap); + } + + return this._lineMap; + }; + + Document.prototype.isExternalModule = function () { + if (this._isExternalModule === undefined) { + this.syntaxTree(); + TypeScript.Debug.assert(this._isExternalModule !== undefined); + } + + return this._isExternalModule; + }; + + Document.prototype.amdDependencies = function () { + if (this._amdDependencies === undefined) { + this.syntaxTree(); + TypeScript.Debug.assert(this._amdDependencies !== undefined); + } + + return this._amdDependencies; + }; + + Document.prototype.syntaxTree = function () { + var result = this._syntaxTree; + if (!result) { + var start = new Date().getTime(); + + result = TypeScript.Parser.parse(this.fileName, TypeScript.SimpleText.fromScriptSnapshot(this._scriptSnapshot), TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())); + + TypeScript.syntaxTreeParseTime += new Date().getTime() - start; + + if (this.isOpen || !this._sourceUnit) { + this._syntaxTree = result; + } + } + + this.cacheSyntaxTreeInfo(result); + return result; + }; + + Document.prototype.bloomFilter = function () { + if (!this._bloomFilter) { + var identifiers = TypeScript.createIntrinsicsObject(); + var pre = function (cur) { + if (TypeScript.isValidAstNode(cur)) { + if (cur.kind() === 11 /* IdentifierName */) { + var nodeText = cur.valueText(); + + identifiers[nodeText] = true; + } + } + }; + + TypeScript.getAstWalkerFactory().simpleWalk(this.sourceUnit(), pre, null, identifiers); + + var identifierCount = 0; + for (var name in identifiers) { + if (identifiers[name]) { + identifierCount++; + } + } + + this._bloomFilter = new TypeScript.BloomFilter(identifierCount); + this._bloomFilter.addKeys(identifiers); + } + return this._bloomFilter; + }; + + Document.prototype.emitToOwnOutputFile = function () { + return !this._compiler.compilationSettings().outFileOption() || this.isExternalModule(); + }; + + Document.prototype.update = function (scriptSnapshot, version, isOpen, textChangeRange) { + var oldSyntaxTree = this._syntaxTree; + + if (textChangeRange !== null && TypeScript.Debug.shouldAssert(1 /* Normal */)) { + var oldText = this._scriptSnapshot; + var newText = scriptSnapshot; + + TypeScript.Debug.assert((oldText.getLength() - textChangeRange.span().length() + textChangeRange.newLength()) === newText.getLength()); + + if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) { + var oldTextPrefix = oldText.getText(0, textChangeRange.span().start()); + var newTextPrefix = newText.getText(0, textChangeRange.span().start()); + TypeScript.Debug.assert(oldTextPrefix === newTextPrefix); + + var oldTextSuffix = oldText.getText(textChangeRange.span().end(), oldText.getLength()); + var newTextSuffix = newText.getText(textChangeRange.newSpan().end(), newText.getLength()); + TypeScript.Debug.assert(oldTextSuffix === newTextSuffix); + } + } + + var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot); + + var newSyntaxTree = textChangeRange === null || oldSyntaxTree === null ? TypeScript.Parser.parse(this.fileName, text, TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())) : TypeScript.Parser.incrementalParse(oldSyntaxTree, textChangeRange, text); + + return new Document(this._compiler, this._semanticInfoChain, this.fileName, this.referencedFiles, scriptSnapshot, this.byteOrderMark, version, isOpen, newSyntaxTree, null); + }; + + Document.create = function (compiler, semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) { + return new Document(compiler, semanticInfoChain, fileName, referencedFiles, scriptSnapshot, byteOrderMark, version, isOpen, null, null); + }; + + Document.prototype.topLevelDecl = function () { + if (this._topLevelDecl === null) { + this._topLevelDecl = TypeScript.DeclarationCreator.create(this, this._semanticInfoChain, this._compiler.compilationSettings()); + } + + return this._topLevelDecl; + }; + + Document.prototype._getDeclForAST = function (ast) { + this.topLevelDecl(); + return this._astDeclMap[ast.syntaxID()]; + }; + + Document.prototype.getEnclosingDecl = function (ast) { + if (ast.kind() === 120 /* SourceUnit */) { + return this._getDeclForAST(ast); + } + + ast = ast.parent; + var decl = null; + while (ast) { + decl = this._getDeclForAST(ast); + + if (decl) { + break; + } + + ast = ast.parent; + } + + return decl._getEnclosingDeclFromParentDecl(); + }; + + Document.prototype._setDeclForAST = function (ast, decl) { + TypeScript.Debug.assert(decl.fileName() === this.fileName); + this._astDeclMap[ast.syntaxID()] = decl; + }; + + Document.prototype._getASTForDecl = function (decl) { + return this._declASTMap[decl.declID]; + }; + + Document.prototype._setASTForDecl = function (decl, ast) { + TypeScript.Debug.assert(decl.fileName() === this.fileName); + this._declASTMap[decl.declID] = ast; + }; + return Document; + })(); + TypeScript.Document = Document; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function hasFlag(val, flag) { + return (val & flag) !== 0; + } + TypeScript.hasFlag = hasFlag; + + (function (TypeRelationshipFlags) { + TypeRelationshipFlags[TypeRelationshipFlags["SuccessfulComparison"] = 0] = "SuccessfulComparison"; + TypeRelationshipFlags[TypeRelationshipFlags["RequiredPropertyIsMissing"] = 1 << 1] = "RequiredPropertyIsMissing"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleSignatures"] = 1 << 2] = "IncompatibleSignatures"; + TypeRelationshipFlags[TypeRelationshipFlags["SourceSignatureHasTooManyParameters"] = 3] = "SourceSignatureHasTooManyParameters"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleReturnTypes"] = 1 << 4] = "IncompatibleReturnTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatiblePropertyTypes"] = 1 << 5] = "IncompatiblePropertyTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleParameterTypes"] = 1 << 6] = "IncompatibleParameterTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["InconsistantPropertyAccesibility"] = 1 << 7] = "InconsistantPropertyAccesibility"; + })(TypeScript.TypeRelationshipFlags || (TypeScript.TypeRelationshipFlags = {})); + var TypeRelationshipFlags = TypeScript.TypeRelationshipFlags; + + (function (ModuleGenTarget) { + ModuleGenTarget[ModuleGenTarget["Unspecified"] = 0] = "Unspecified"; + ModuleGenTarget[ModuleGenTarget["Synchronous"] = 1] = "Synchronous"; + ModuleGenTarget[ModuleGenTarget["Asynchronous"] = 2] = "Asynchronous"; + })(TypeScript.ModuleGenTarget || (TypeScript.ModuleGenTarget = {})); + var ModuleGenTarget = TypeScript.ModuleGenTarget; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var proto = "__proto__"; + + var BlockIntrinsics = (function () { + function BlockIntrinsics() { + this.prototype = undefined; + this.toString = undefined; + this.toLocaleString = undefined; + this.valueOf = undefined; + this.hasOwnProperty = undefined; + this.propertyIsEnumerable = undefined; + this.isPrototypeOf = undefined; + this["constructor"] = undefined; + + this[proto] = null; + this[proto] = undefined; + } + return BlockIntrinsics; + })(); + + function createIntrinsicsObject() { + return new BlockIntrinsics(); + } + TypeScript.createIntrinsicsObject = createIntrinsicsObject; + + var StringHashTable = (function () { + function StringHashTable() { + this.itemCount = 0; + this.table = createIntrinsicsObject(); + } + StringHashTable.prototype.getAllKeys = function () { + var result = []; + + for (var k in this.table) { + if (this.table[k] !== undefined) { + result.push(k); + } + } + + return result; + }; + + StringHashTable.prototype.add = function (key, data) { + if (this.table[key] !== undefined) { + return false; + } + + this.table[key] = data; + this.itemCount++; + return true; + }; + + StringHashTable.prototype.addOrUpdate = function (key, data) { + if (this.table[key] !== undefined) { + this.table[key] = data; + return false; + } + + this.table[key] = data; + this.itemCount++; + return true; + }; + + StringHashTable.prototype.map = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + fn(k, this.table[k], context); + } + } + }; + + StringHashTable.prototype.every = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + if (!fn(k, this.table[k], context)) { + return false; + } + } + } + + return true; + }; + + StringHashTable.prototype.some = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + if (fn(k, this.table[k], context)) { + return true; + } + } + } + + return false; + }; + + StringHashTable.prototype.count = function () { + return this.itemCount; + }; + + StringHashTable.prototype.lookup = function (key) { + var data = this.table[key]; + return data === undefined ? null : data; + }; + + StringHashTable.prototype.remove = function (key) { + if (this.table[key] !== undefined) { + this.table[key] = undefined; + this.itemCount--; + } + }; + return StringHashTable; + })(); + TypeScript.StringHashTable = StringHashTable; + + var IdentiferNameHashTable = (function (_super) { + __extends(IdentiferNameHashTable, _super); + function IdentiferNameHashTable() { + _super.apply(this, arguments); + } + IdentiferNameHashTable.prototype.getAllKeys = function () { + var result = []; + + _super.prototype.map.call(this, function (k, v, c) { + if (v !== undefined) { + result.push(k.substring(1)); + } + }, null); + + return result; + }; + + IdentiferNameHashTable.prototype.add = function (key, data) { + return _super.prototype.add.call(this, "#" + key, data); + }; + + IdentiferNameHashTable.prototype.addOrUpdate = function (key, data) { + return _super.prototype.addOrUpdate.call(this, "#" + key, data); + }; + + IdentiferNameHashTable.prototype.map = function (fn, context) { + return _super.prototype.map.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.every = function (fn, context) { + return _super.prototype.every.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.some = function (fn, context) { + return _super.prototype.some.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.lookup = function (key) { + return _super.prototype.lookup.call(this, "#" + key); + }; + return IdentiferNameHashTable; + })(StringHashTable); + TypeScript.IdentiferNameHashTable = IdentiferNameHashTable; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function scriptIsElided(sourceUnit) { + return TypeScript.isDTSFile(sourceUnit.fileName()) || moduleMembersAreElided(sourceUnit.moduleElements); + } + TypeScript.scriptIsElided = scriptIsElided; + + function moduleIsElided(declaration) { + return TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) || moduleMembersAreElided(declaration.moduleElements); + } + TypeScript.moduleIsElided = moduleIsElided; + + function moduleMembersAreElided(members) { + for (var i = 0, n = members.childCount(); i < n; i++) { + var member = members.childAt(i); + + if (member.kind() === 130 /* ModuleDeclaration */) { + if (!moduleIsElided(member)) { + return false; + } + } else if (member.kind() !== 128 /* InterfaceDeclaration */) { + return false; + } + } + + return true; + } + + function enumIsElided(declaration) { + if (TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) { + return true; + } + + return false; + } + TypeScript.enumIsElided = enumIsElided; + + function importDeclarationIsElided(importDeclAST, semanticInfoChain, compilationSettings) { + if (typeof compilationSettings === "undefined") { compilationSettings = null; } + var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */; + var importDecl = semanticInfoChain.getDeclForAST(importDeclAST); + var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */); + var isAmdCodeGen = compilationSettings && compilationSettings.moduleGenTarget() == 2 /* Asynchronous */; + + if (!isExternalModuleReference || isExported || !isAmdCodeGen) { + var importSymbol = importDecl.getSymbol(); + if (importDeclAST.moduleReference.kind() !== 245 /* ExternalModuleReference */) { + if (importSymbol.getExportAssignedValueSymbol()) { + return true; + } + var containerSymbol = importSymbol.getExportAssignedContainerSymbol(); + if (containerSymbol && containerSymbol.getInstanceSymbol()) { + return true; + } + } + + return importSymbol.isUsedAsValue(); + } + + return false; + } + TypeScript.importDeclarationIsElided = importDeclarationIsElided; + + function isValidAstNode(ast) { + if (!ast) + return false; + + if (ast.start() === -1 || ast.end() === -1) + return false; + + return true; + } + TypeScript.isValidAstNode = isValidAstNode; + + function getAstAtPosition(script, pos, useTrailingTriviaAsLimChar, forceInclusive) { + if (typeof useTrailingTriviaAsLimChar === "undefined") { useTrailingTriviaAsLimChar = true; } + if (typeof forceInclusive === "undefined") { forceInclusive = false; } + var top = null; + + var pre = function (cur, walker) { + if (isValidAstNode(cur)) { + var isInvalid1 = cur.kind() === 149 /* ExpressionStatement */ && cur.width() === 0; + + if (isInvalid1) { + walker.options.goChildren = false; + } else { + var inclusive = forceInclusive || cur.kind() === 11 /* IdentifierName */ || cur.kind() === 212 /* MemberAccessExpression */ || cur.kind() === 121 /* QualifiedName */ || cur.kind() === 224 /* VariableDeclaration */ || cur.kind() === 225 /* VariableDeclarator */ || cur.kind() === 213 /* InvocationExpression */ || pos === script.end() + script.trailingTriviaWidth(); + + var minChar = cur.start(); + var limChar = cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0) + (inclusive ? 1 : 0); + if (pos >= minChar && pos < limChar) { + if ((cur.kind() !== 1 /* List */ && cur.kind() !== 2 /* SeparatedList */) || cur.end() > cur.start()) { + if (top === null) { + top = cur; + } else if (cur.start() >= top.start() && (cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0)) <= (top.end() + (useTrailingTriviaAsLimChar ? top.trailingTriviaWidth() : 0))) { + if (top.width() !== 0 || cur.width() !== 0) { + top = cur; + } + } + } + } + + walker.options.goChildren = (minChar <= pos && pos <= limChar); + } + } + }; + + TypeScript.getAstWalkerFactory().walk(script, pre); + return top; + } + TypeScript.getAstAtPosition = getAstAtPosition; + + function getExtendsHeritageClause(clauses) { + if (!clauses) { + return null; + } + + return clauses.firstOrDefault(function (c) { + return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 230 /* ExtendsHeritageClause */; + }); + } + TypeScript.getExtendsHeritageClause = getExtendsHeritageClause; + + function getImplementsHeritageClause(clauses) { + if (!clauses) { + return null; + } + + return clauses.firstOrDefault(function (c) { + return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 231 /* ImplementsHeritageClause */; + }); + } + TypeScript.getImplementsHeritageClause = getImplementsHeritageClause; + + function isCallExpression(ast) { + return (ast && ast.kind() === 213 /* InvocationExpression */) || (ast && ast.kind() === 216 /* ObjectCreationExpression */); + } + TypeScript.isCallExpression = isCallExpression; + + function isCallExpressionTarget(ast) { + if (!ast) { + return false; + } + + var current = ast; + + while (current && current.parent) { + if (current.parent.kind() === 212 /* MemberAccessExpression */ && current.parent.name === current) { + current = current.parent; + continue; + } + + break; + } + + if (current && current.parent) { + if (current.parent.kind() === 213 /* InvocationExpression */ || current.parent.kind() === 216 /* ObjectCreationExpression */) { + return current === current.parent.expression; + } + } + + return false; + } + TypeScript.isCallExpressionTarget = isCallExpressionTarget; + + function isNameOfSomeDeclaration(ast) { + if (ast === null || ast.parent === null) { + return false; + } + if (ast.kind() !== 11 /* IdentifierName */) { + return false; + } + + switch (ast.parent.kind()) { + case 131 /* ClassDeclaration */: + return ast.parent.identifier === ast; + case 128 /* InterfaceDeclaration */: + return ast.parent.identifier === ast; + case 132 /* EnumDeclaration */: + return ast.parent.identifier === ast; + case 130 /* ModuleDeclaration */: + return ast.parent.name === ast || ast.parent.stringLiteral === ast; + case 225 /* VariableDeclarator */: + return ast.parent.propertyName === ast; + case 129 /* FunctionDeclaration */: + return ast.parent.identifier === ast; + case 135 /* MemberFunctionDeclaration */: + return ast.parent.propertyName === ast; + case 242 /* Parameter */: + return ast.parent.identifier === ast; + case 238 /* TypeParameter */: + return ast.parent.identifier === ast; + case 240 /* SimplePropertyAssignment */: + return ast.parent.propertyName === ast; + case 241 /* FunctionPropertyAssignment */: + return ast.parent.propertyName === ast; + case 243 /* EnumElement */: + return ast.parent.propertyName === ast; + case 133 /* ImportDeclaration */: + return ast.parent.identifier === ast; + } + + return false; + } + + function isDeclarationASTOrDeclarationNameAST(ast) { + return isNameOfSomeDeclaration(ast) || isDeclarationAST(ast); + } + TypeScript.isDeclarationASTOrDeclarationNameAST = isDeclarationASTOrDeclarationNameAST; + + function isNameOfFunction(ast) { + return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 129 /* FunctionDeclaration */ && ast.parent.identifier === ast; + } + TypeScript.isNameOfFunction = isNameOfFunction; + + function isNameOfMemberFunction(ast) { + return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 135 /* MemberFunctionDeclaration */ && ast.parent.propertyName === ast; + } + TypeScript.isNameOfMemberFunction = isNameOfMemberFunction; + + function isNameOfMemberAccessExpression(ast) { + if (ast && ast.parent && ast.parent.kind() === 212 /* MemberAccessExpression */ && ast.parent.name === ast) { + return true; + } + + return false; + } + TypeScript.isNameOfMemberAccessExpression = isNameOfMemberAccessExpression; + + function isRightSideOfQualifiedName(ast) { + if (ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast) { + return true; + } + + return false; + } + TypeScript.isRightSideOfQualifiedName = isRightSideOfQualifiedName; + + (function (Parameters) { + function fromIdentifier(id) { + return { + length: 1, + lastParameterIsRest: function () { + return false; + }, + ast: id, + astAt: function (index) { + return id; + }, + identifierAt: function (index) { + return id; + }, + typeAt: function (index) { + return null; + }, + initializerAt: function (index) { + return null; + }, + isOptionalAt: function (index) { + return false; + } + }; + } + Parameters.fromIdentifier = fromIdentifier; + + function fromParameter(parameter) { + return { + length: 1, + lastParameterIsRest: function () { + return parameter.dotDotDotToken !== null; + }, + ast: parameter, + astAt: function (index) { + return parameter; + }, + identifierAt: function (index) { + return parameter.identifier; + }, + typeAt: function (index) { + return TypeScript.getType(parameter); + }, + initializerAt: function (index) { + return parameter.equalsValueClause; + }, + isOptionalAt: function (index) { + return parameterIsOptional(parameter); + } + }; + } + Parameters.fromParameter = fromParameter; + + function parameterIsOptional(parameter) { + return parameter.questionToken !== null || parameter.equalsValueClause !== null; + } + + function fromParameterList(list) { + return { + length: list.parameters.nonSeparatorCount(), + lastParameterIsRest: function () { + return TypeScript.lastParameterIsRest(list); + }, + ast: list.parameters, + astAt: function (index) { + return list.parameters.nonSeparatorAt(index); + }, + identifierAt: function (index) { + return list.parameters.nonSeparatorAt(index).identifier; + }, + typeAt: function (index) { + return TypeScript.getType(list.parameters.nonSeparatorAt(index)); + }, + initializerAt: function (index) { + return list.parameters.nonSeparatorAt(index).equalsValueClause; + }, + isOptionalAt: function (index) { + return parameterIsOptional(list.parameters.nonSeparatorAt(index)); + } + }; + } + Parameters.fromParameterList = fromParameterList; + })(TypeScript.Parameters || (TypeScript.Parameters = {})); + var Parameters = TypeScript.Parameters; + + function isDeclarationAST(ast) { + switch (ast.kind()) { + case 225 /* VariableDeclarator */: + return getVariableStatement(ast) !== null; + + case 133 /* ImportDeclaration */: + case 131 /* ClassDeclaration */: + case 128 /* InterfaceDeclaration */: + case 242 /* Parameter */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 144 /* IndexSignature */: + case 129 /* FunctionDeclaration */: + case 130 /* ModuleDeclaration */: + case 124 /* ArrayType */: + case 122 /* ObjectType */: + case 238 /* TypeParameter */: + case 137 /* ConstructorDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + case 136 /* MemberVariableDeclaration */: + case 138 /* IndexMemberDeclaration */: + case 132 /* EnumDeclaration */: + case 243 /* EnumElement */: + case 240 /* SimplePropertyAssignment */: + case 241 /* FunctionPropertyAssignment */: + case 222 /* FunctionExpression */: + case 142 /* CallSignature */: + case 143 /* ConstructSignature */: + case 145 /* MethodSignature */: + case 141 /* PropertySignature */: + return true; + default: + return false; + } + } + TypeScript.isDeclarationAST = isDeclarationAST; + + function docComments(ast) { + if (isDeclarationAST(ast)) { + var preComments = ast.kind() === 225 /* VariableDeclarator */ ? getVariableStatement(ast).preComments() : ast.preComments(); + + if (preComments && preComments.length > 0) { + var preCommentsLength = preComments.length; + var docComments = new Array(); + for (var i = preCommentsLength - 1; i >= 0; i--) { + if (isDocComment(preComments[i])) { + docComments.push(preComments[i]); + continue; + } + + break; + } + + return docComments.reverse(); + } + } + + return TypeScript.sentinelEmptyArray; + } + TypeScript.docComments = docComments; + + function isDocComment(comment) { + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + var fullText = comment.fullText(); + return fullText.charAt(2) === "*" && fullText.charAt(3) !== "/"; + } + + return false; + } + + function getParameterList(ast) { + if (ast) { + switch (ast.kind()) { + case 137 /* ConstructorDeclaration */: + return ast.parameterList; + case 129 /* FunctionDeclaration */: + return getParameterList(ast.callSignature); + case 218 /* ParenthesizedArrowFunctionExpression */: + return getParameterList(ast.callSignature); + case 143 /* ConstructSignature */: + return getParameterList(ast.callSignature); + case 135 /* MemberFunctionDeclaration */: + return getParameterList(ast.callSignature); + case 241 /* FunctionPropertyAssignment */: + return getParameterList(ast.callSignature); + case 222 /* FunctionExpression */: + return getParameterList(ast.callSignature); + case 145 /* MethodSignature */: + return getParameterList(ast.callSignature); + case 125 /* ConstructorType */: + return ast.parameterList; + case 123 /* FunctionType */: + return ast.parameterList; + case 142 /* CallSignature */: + return ast.parameterList; + case 139 /* GetAccessor */: + return ast.parameterList; + case 140 /* SetAccessor */: + return ast.parameterList; + } + } + + return null; + } + TypeScript.getParameterList = getParameterList; + + function getType(ast) { + if (ast) { + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + return getType(ast.callSignature); + case 218 /* ParenthesizedArrowFunctionExpression */: + return getType(ast.callSignature); + case 143 /* ConstructSignature */: + return getType(ast.callSignature); + case 135 /* MemberFunctionDeclaration */: + return getType(ast.callSignature); + case 241 /* FunctionPropertyAssignment */: + return getType(ast.callSignature); + case 222 /* FunctionExpression */: + return getType(ast.callSignature); + case 145 /* MethodSignature */: + return getType(ast.callSignature); + case 142 /* CallSignature */: + return getType(ast.typeAnnotation); + case 144 /* IndexSignature */: + return getType(ast.typeAnnotation); + case 141 /* PropertySignature */: + return getType(ast.typeAnnotation); + case 139 /* GetAccessor */: + return getType(ast.typeAnnotation); + case 242 /* Parameter */: + return getType(ast.typeAnnotation); + case 136 /* MemberVariableDeclaration */: + return getType(ast.variableDeclarator); + case 225 /* VariableDeclarator */: + return getType(ast.typeAnnotation); + case 236 /* CatchClause */: + return getType(ast.typeAnnotation); + case 125 /* ConstructorType */: + return ast.type; + case 123 /* FunctionType */: + return ast.type; + case 244 /* TypeAnnotation */: + return ast.type; + } + } + + return null; + } + TypeScript.getType = getType; + + function getVariableStatement(variableDeclarator) { + if (variableDeclarator && variableDeclarator.parent && variableDeclarator.parent.parent && variableDeclarator.parent.parent.parent && variableDeclarator.parent.kind() === 2 /* SeparatedList */ && variableDeclarator.parent.parent.kind() === 224 /* VariableDeclaration */ && variableDeclarator.parent.parent.parent.kind() === 148 /* VariableStatement */) { + return variableDeclarator.parent.parent.parent; + } + + return null; + } + + function getVariableDeclaratorModifiers(variableDeclarator) { + var variableStatement = getVariableStatement(variableDeclarator); + return variableStatement ? variableStatement.modifiers : TypeScript.sentinelEmptyArray; + } + TypeScript.getVariableDeclaratorModifiers = getVariableDeclaratorModifiers; + + function isIntegerLiteralAST(expression) { + if (expression) { + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + expression = expression.operand; + return expression.kind() === 13 /* NumericLiteral */ && TypeScript.IntegerUtilities.isInteger(expression.text()); + + case 13 /* NumericLiteral */: + var text = expression.text(); + return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text); + } + } + + return false; + } + TypeScript.isIntegerLiteralAST = isIntegerLiteralAST; + + function getEnclosingModuleDeclaration(ast) { + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + return ast; + } + + ast = ast.parent; + } + + return null; + } + TypeScript.getEnclosingModuleDeclaration = getEnclosingModuleDeclaration; + + function isLastNameOfModule(ast, astName) { + if (ast) { + if (ast.stringLiteral) { + return astName === ast.stringLiteral; + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + var nameIndex = moduleNames.indexOf(astName); + + return nameIndex === (moduleNames.length - 1); + } + } + + return false; + } + TypeScript.isLastNameOfModule = isLastNameOfModule; + + function isAnyNameOfModule(ast, astName) { + if (ast) { + if (ast.stringLiteral) { + return ast.stringLiteral === astName; + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + var nameIndex = moduleNames.indexOf(astName); + + return nameIndex >= 0; + } + } + + return false; + } + TypeScript.isAnyNameOfModule = isAnyNameOfModule; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function walkListChildren(preAst, walker) { + for (var i = 0, n = preAst.childCount(); i < n; i++) { + walker.walk(preAst.childAt(i)); + } + } + + function walkThrowStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkPrefixUnaryExpressionChildren(preAst, walker) { + walker.walk(preAst.operand); + } + + function walkPostfixUnaryExpressionChildren(preAst, walker) { + walker.walk(preAst.operand); + } + + function walkDeleteExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkTypeArgumentListChildren(preAst, walker) { + walker.walk(preAst.typeArguments); + } + + function walkTypeOfExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkVoidExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkArgumentListChildren(preAst, walker) { + walker.walk(preAst.typeArgumentList); + walker.walk(preAst.arguments); + } + + function walkArrayLiteralExpressionChildren(preAst, walker) { + walker.walk(preAst.expressions); + } + + function walkSimplePropertyAssignmentChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.expression); + } + + function walkFunctionPropertyAssignmentChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkGetAccessorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.parameterList); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.block); + } + + function walkSeparatedListChildren(preAst, walker) { + for (var i = 0, n = preAst.nonSeparatorCount(); i < n; i++) { + walker.walk(preAst.nonSeparatorAt(i)); + } + } + + function walkSetAccessorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.parameterList); + walker.walk(preAst.block); + } + + function walkObjectLiteralExpressionChildren(preAst, walker) { + walker.walk(preAst.propertyAssignments); + } + + function walkCastExpressionChildren(preAst, walker) { + walker.walk(preAst.type); + walker.walk(preAst.expression); + } + + function walkParenthesizedExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkElementAccessExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentExpression); + } + + function walkMemberAccessExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.name); + } + + function walkQualifiedNameChildren(preAst, walker) { + walker.walk(preAst.left); + walker.walk(preAst.right); + } + + function walkBinaryExpressionChildren(preAst, walker) { + walker.walk(preAst.left); + walker.walk(preAst.right); + } + + function walkEqualsValueClauseChildren(preAst, walker) { + walker.walk(preAst.value); + } + + function walkTypeParameterChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.constraint); + } + + function walkTypeParameterListChildren(preAst, walker) { + walker.walk(preAst.typeParameters); + } + + function walkGenericTypeChildren(preAst, walker) { + walker.walk(preAst.name); + walker.walk(preAst.typeArgumentList); + } + + function walkTypeAnnotationChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkTypeQueryChildren(preAst, walker) { + walker.walk(preAst.name); + } + + function walkInvocationExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentList); + } + + function walkObjectCreationExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentList); + } + + function walkTrinaryExpressionChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.whenTrue); + walker.walk(preAst.whenFalse); + } + + function walkFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkFunctionTypeChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.type); + } + + function walkParenthesizedArrowFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + walker.walk(preAst.expression); + } + + function walkSimpleArrowFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.block); + walker.walk(preAst.expression); + } + + function walkMemberFunctionDeclarationChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkFuncDeclChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkIndexMemberDeclarationChildren(preAst, walker) { + walker.walk(preAst.indexSignature); + } + + function walkIndexSignatureChildren(preAst, walker) { + walker.walk(preAst.parameter); + walker.walk(preAst.typeAnnotation); + } + + function walkCallSignatureChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.typeAnnotation); + } + + function walkConstraintChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkConstructorDeclarationChildren(preAst, walker) { + walker.walk(preAst.parameterList); + walker.walk(preAst.block); + } + + function walkConstructorTypeChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.type); + } + + function walkConstructSignatureChildren(preAst, walker) { + walker.walk(preAst.callSignature); + } + + function walkParameterChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.equalsValueClause); + } + + function walkParameterListChildren(preAst, walker) { + walker.walk(preAst.parameters); + } + + function walkPropertySignatureChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.typeAnnotation); + } + + function walkVariableDeclaratorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.equalsValueClause); + } + + function walkMemberVariableDeclarationChildren(preAst, walker) { + walker.walk(preAst.variableDeclarator); + } + + function walkMethodSignatureChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + } + + function walkReturnStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkForStatementChildren(preAst, walker) { + walker.walk(preAst.variableDeclaration); + walker.walk(preAst.initializer); + walker.walk(preAst.condition); + walker.walk(preAst.incrementor); + walker.walk(preAst.statement); + } + + function walkForInStatementChildren(preAst, walker) { + walker.walk(preAst.variableDeclaration); + walker.walk(preAst.left); + walker.walk(preAst.expression); + walker.walk(preAst.statement); + } + + function walkIfStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + walker.walk(preAst.elseClause); + } + + function walkElseClauseChildren(preAst, walker) { + walker.walk(preAst.statement); + } + + function walkWhileStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkDoStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkBlockChildren(preAst, walker) { + walker.walk(preAst.statements); + } + + function walkVariableDeclarationChildren(preAst, walker) { + walker.walk(preAst.declarators); + } + + function walkCaseSwitchClauseChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.statements); + } + + function walkDefaultSwitchClauseChildren(preAst, walker) { + walker.walk(preAst.statements); + } + + function walkSwitchStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.switchClauses); + } + + function walkTryStatementChildren(preAst, walker) { + walker.walk(preAst.block); + walker.walk(preAst.catchClause); + walker.walk(preAst.finallyClause); + } + + function walkCatchClauseChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.block); + } + + function walkExternalModuleReferenceChildren(preAst, walker) { + walker.walk(preAst.stringLiteral); + } + + function walkFinallyClauseChildren(preAst, walker) { + walker.walk(preAst.block); + } + + function walkClassDeclChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeParameterList); + walker.walk(preAst.heritageClauses); + walker.walk(preAst.classElements); + } + + function walkScriptChildren(preAst, walker) { + walker.walk(preAst.moduleElements); + } + + function walkHeritageClauseChildren(preAst, walker) { + walker.walk(preAst.typeNames); + } + + function walkInterfaceDeclerationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeParameterList); + walker.walk(preAst.heritageClauses); + walker.walk(preAst.body); + } + + function walkObjectTypeChildren(preAst, walker) { + walker.walk(preAst.typeMembers); + } + + function walkArrayTypeChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkModuleDeclarationChildren(preAst, walker) { + walker.walk(preAst.name); + walker.walk(preAst.stringLiteral); + walker.walk(preAst.moduleElements); + } + + function walkModuleNameModuleReferenceChildren(preAst, walker) { + walker.walk(preAst.moduleName); + } + + function walkEnumDeclarationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.enumElements); + } + + function walkEnumElementChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.equalsValueClause); + } + + function walkImportDeclarationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.moduleReference); + } + + function walkExportAssignmentChildren(preAst, walker) { + walker.walk(preAst.identifier); + } + + function walkWithStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkExpressionStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkLabeledStatementChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.statement); + } + + function walkVariableStatementChildren(preAst, walker) { + walker.walk(preAst.declaration); + } + + var childrenWalkers = new Array(246 /* Last */ + 1); + + for (var i = 9 /* FirstToken */, n = 119 /* LastToken */; i <= n; i++) { + childrenWalkers[i] = null; + } + for (var i = 4 /* FirstTrivia */, n = 8 /* LastTrivia */; i <= n; i++) { + childrenWalkers[i] = null; + } + + childrenWalkers[175 /* AddAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[208 /* AddExpression */] = walkBinaryExpressionChildren; + childrenWalkers[180 /* AndAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[60 /* AnyKeyword */] = null; + childrenWalkers[226 /* ArgumentList */] = walkArgumentListChildren; + childrenWalkers[214 /* ArrayLiteralExpression */] = walkArrayLiteralExpressionChildren; + childrenWalkers[124 /* ArrayType */] = walkArrayTypeChildren; + childrenWalkers[219 /* SimpleArrowFunctionExpression */] = walkSimpleArrowFunctionExpressionChildren; + childrenWalkers[218 /* ParenthesizedArrowFunctionExpression */] = walkParenthesizedArrowFunctionExpressionChildren; + childrenWalkers[174 /* AssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[191 /* BitwiseAndExpression */] = walkBinaryExpressionChildren; + childrenWalkers[190 /* BitwiseExclusiveOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[166 /* BitwiseNotExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[189 /* BitwiseOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[146 /* Block */] = walkBlockChildren; + childrenWalkers[61 /* BooleanKeyword */] = null; + childrenWalkers[152 /* BreakStatement */] = null; + childrenWalkers[142 /* CallSignature */] = walkCallSignatureChildren; + childrenWalkers[233 /* CaseSwitchClause */] = walkCaseSwitchClauseChildren; + childrenWalkers[220 /* CastExpression */] = walkCastExpressionChildren; + childrenWalkers[236 /* CatchClause */] = walkCatchClauseChildren; + childrenWalkers[131 /* ClassDeclaration */] = walkClassDeclChildren; + childrenWalkers[173 /* CommaExpression */] = walkBinaryExpressionChildren; + childrenWalkers[186 /* ConditionalExpression */] = walkTrinaryExpressionChildren; + childrenWalkers[239 /* Constraint */] = walkConstraintChildren; + childrenWalkers[137 /* ConstructorDeclaration */] = walkConstructorDeclarationChildren; + childrenWalkers[143 /* ConstructSignature */] = walkConstructSignatureChildren; + childrenWalkers[153 /* ContinueStatement */] = null; + childrenWalkers[125 /* ConstructorType */] = walkConstructorTypeChildren; + childrenWalkers[162 /* DebuggerStatement */] = null; + childrenWalkers[234 /* DefaultSwitchClause */] = walkDefaultSwitchClauseChildren; + childrenWalkers[170 /* DeleteExpression */] = walkDeleteExpressionChildren; + childrenWalkers[178 /* DivideAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[206 /* DivideExpression */] = walkBinaryExpressionChildren; + childrenWalkers[161 /* DoStatement */] = walkDoStatementChildren; + childrenWalkers[221 /* ElementAccessExpression */] = walkElementAccessExpressionChildren; + childrenWalkers[235 /* ElseClause */] = walkElseClauseChildren; + childrenWalkers[156 /* EmptyStatement */] = null; + childrenWalkers[132 /* EnumDeclaration */] = walkEnumDeclarationChildren; + childrenWalkers[243 /* EnumElement */] = walkEnumElementChildren; + childrenWalkers[194 /* EqualsExpression */] = walkBinaryExpressionChildren; + childrenWalkers[232 /* EqualsValueClause */] = walkEqualsValueClauseChildren; + childrenWalkers[192 /* EqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren; + childrenWalkers[181 /* ExclusiveOrAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[134 /* ExportAssignment */] = walkExportAssignmentChildren; + childrenWalkers[149 /* ExpressionStatement */] = walkExpressionStatementChildren; + childrenWalkers[230 /* ExtendsHeritageClause */] = walkHeritageClauseChildren; + childrenWalkers[245 /* ExternalModuleReference */] = walkExternalModuleReferenceChildren; + childrenWalkers[24 /* FalseKeyword */] = null; + childrenWalkers[237 /* FinallyClause */] = walkFinallyClauseChildren; + childrenWalkers[155 /* ForInStatement */] = walkForInStatementChildren; + childrenWalkers[154 /* ForStatement */] = walkForStatementChildren; + childrenWalkers[129 /* FunctionDeclaration */] = walkFuncDeclChildren; + childrenWalkers[222 /* FunctionExpression */] = walkFunctionExpressionChildren; + childrenWalkers[241 /* FunctionPropertyAssignment */] = walkFunctionPropertyAssignmentChildren; + childrenWalkers[123 /* FunctionType */] = walkFunctionTypeChildren; + childrenWalkers[126 /* GenericType */] = walkGenericTypeChildren; + childrenWalkers[139 /* GetAccessor */] = walkGetAccessorChildren; + childrenWalkers[197 /* GreaterThanExpression */] = walkBinaryExpressionChildren; + childrenWalkers[199 /* GreaterThanOrEqualExpression */] = walkBinaryExpressionChildren; + childrenWalkers[147 /* IfStatement */] = walkIfStatementChildren; + childrenWalkers[231 /* ImplementsHeritageClause */] = walkHeritageClauseChildren; + childrenWalkers[133 /* ImportDeclaration */] = walkImportDeclarationChildren; + childrenWalkers[138 /* IndexMemberDeclaration */] = walkIndexMemberDeclarationChildren; + childrenWalkers[144 /* IndexSignature */] = walkIndexSignatureChildren; + childrenWalkers[201 /* InExpression */] = walkBinaryExpressionChildren; + childrenWalkers[200 /* InstanceOfExpression */] = walkBinaryExpressionChildren; + childrenWalkers[128 /* InterfaceDeclaration */] = walkInterfaceDeclerationChildren; + childrenWalkers[213 /* InvocationExpression */] = walkInvocationExpressionChildren; + childrenWalkers[160 /* LabeledStatement */] = walkLabeledStatementChildren; + childrenWalkers[183 /* LeftShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[202 /* LeftShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[196 /* LessThanExpression */] = walkBinaryExpressionChildren; + childrenWalkers[198 /* LessThanOrEqualExpression */] = walkBinaryExpressionChildren; + childrenWalkers[1 /* List */] = walkListChildren; + childrenWalkers[188 /* LogicalAndExpression */] = walkBinaryExpressionChildren; + childrenWalkers[167 /* LogicalNotExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[187 /* LogicalOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[212 /* MemberAccessExpression */] = walkMemberAccessExpressionChildren; + childrenWalkers[135 /* MemberFunctionDeclaration */] = walkMemberFunctionDeclarationChildren; + childrenWalkers[136 /* MemberVariableDeclaration */] = walkMemberVariableDeclarationChildren; + childrenWalkers[145 /* MethodSignature */] = walkMethodSignatureChildren; + childrenWalkers[130 /* ModuleDeclaration */] = walkModuleDeclarationChildren; + childrenWalkers[246 /* ModuleNameModuleReference */] = walkModuleNameModuleReferenceChildren; + childrenWalkers[179 /* ModuloAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[207 /* ModuloExpression */] = walkBinaryExpressionChildren; + childrenWalkers[177 /* MultiplyAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[205 /* MultiplyExpression */] = walkBinaryExpressionChildren; + childrenWalkers[11 /* IdentifierName */] = null; + childrenWalkers[165 /* NegateExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[0 /* None */] = null; + childrenWalkers[195 /* NotEqualsExpression */] = walkBinaryExpressionChildren; + childrenWalkers[193 /* NotEqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren; + childrenWalkers[32 /* NullKeyword */] = null; + childrenWalkers[67 /* NumberKeyword */] = null; + childrenWalkers[13 /* NumericLiteral */] = null; + childrenWalkers[216 /* ObjectCreationExpression */] = walkObjectCreationExpressionChildren; + childrenWalkers[215 /* ObjectLiteralExpression */] = walkObjectLiteralExpressionChildren; + childrenWalkers[122 /* ObjectType */] = walkObjectTypeChildren; + childrenWalkers[223 /* OmittedExpression */] = null; + childrenWalkers[182 /* OrAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[242 /* Parameter */] = walkParameterChildren; + childrenWalkers[227 /* ParameterList */] = walkParameterListChildren; + childrenWalkers[217 /* ParenthesizedExpression */] = walkParenthesizedExpressionChildren; + childrenWalkers[164 /* PlusExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[211 /* PostDecrementExpression */] = walkPostfixUnaryExpressionChildren; + childrenWalkers[210 /* PostIncrementExpression */] = walkPostfixUnaryExpressionChildren; + childrenWalkers[169 /* PreDecrementExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[168 /* PreIncrementExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[141 /* PropertySignature */] = walkPropertySignatureChildren; + childrenWalkers[121 /* QualifiedName */] = walkQualifiedNameChildren; + childrenWalkers[12 /* RegularExpressionLiteral */] = null; + childrenWalkers[150 /* ReturnStatement */] = walkReturnStatementChildren; + childrenWalkers[120 /* SourceUnit */] = walkScriptChildren; + childrenWalkers[2 /* SeparatedList */] = walkSeparatedListChildren; + childrenWalkers[140 /* SetAccessor */] = walkSetAccessorChildren; + childrenWalkers[184 /* SignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[203 /* SignedRightShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[240 /* SimplePropertyAssignment */] = walkSimplePropertyAssignmentChildren; + childrenWalkers[14 /* StringLiteral */] = null; + childrenWalkers[69 /* StringKeyword */] = null; + childrenWalkers[176 /* SubtractAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[209 /* SubtractExpression */] = walkBinaryExpressionChildren; + childrenWalkers[50 /* SuperKeyword */] = null; + childrenWalkers[151 /* SwitchStatement */] = walkSwitchStatementChildren; + childrenWalkers[35 /* ThisKeyword */] = null; + childrenWalkers[157 /* ThrowStatement */] = walkThrowStatementChildren; + childrenWalkers[3 /* TriviaList */] = null; + childrenWalkers[37 /* TrueKeyword */] = null; + childrenWalkers[159 /* TryStatement */] = walkTryStatementChildren; + childrenWalkers[244 /* TypeAnnotation */] = walkTypeAnnotationChildren; + childrenWalkers[228 /* TypeArgumentList */] = walkTypeArgumentListChildren; + childrenWalkers[171 /* TypeOfExpression */] = walkTypeOfExpressionChildren; + childrenWalkers[238 /* TypeParameter */] = walkTypeParameterChildren; + childrenWalkers[229 /* TypeParameterList */] = walkTypeParameterListChildren; + childrenWalkers[127 /* TypeQuery */] = walkTypeQueryChildren; + childrenWalkers[185 /* UnsignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[204 /* UnsignedRightShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[224 /* VariableDeclaration */] = walkVariableDeclarationChildren; + childrenWalkers[225 /* VariableDeclarator */] = walkVariableDeclaratorChildren; + childrenWalkers[148 /* VariableStatement */] = walkVariableStatementChildren; + childrenWalkers[172 /* VoidExpression */] = walkVoidExpressionChildren; + childrenWalkers[41 /* VoidKeyword */] = null; + childrenWalkers[158 /* WhileStatement */] = walkWhileStatementChildren; + childrenWalkers[163 /* WithStatement */] = walkWithStatementChildren; + + for (var e in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind.hasOwnProperty(e) && TypeScript.StringUtilities.isString(TypeScript.SyntaxKind[e])) { + TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + TypeScript.SyntaxKind[e]); + } + } + + var AstWalkOptions = (function () { + function AstWalkOptions() { + this.goChildren = true; + this.stopWalking = false; + } + return AstWalkOptions; + })(); + TypeScript.AstWalkOptions = AstWalkOptions; + + var SimplePreAstWalker = (function () { + function SimplePreAstWalker(pre, state) { + this.pre = pre; + this.state = state; + this.options = new AstWalkOptions(); + } + SimplePreAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + this.pre(ast, this.state); + + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + }; + return SimplePreAstWalker; + })(); + + var SimplePrePostAstWalker = (function () { + function SimplePrePostAstWalker(pre, post, state) { + this.pre = pre; + this.post = post; + this.state = state; + this.options = new AstWalkOptions(); + } + SimplePrePostAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + this.pre(ast, this.state); + + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + + this.post(ast, this.state); + }; + return SimplePrePostAstWalker; + })(); + + var NormalAstWalker = (function () { + function NormalAstWalker(pre, post, state) { + this.pre = pre; + this.post = post; + this.state = state; + this.options = new AstWalkOptions(); + } + NormalAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + if (this.options.stopWalking) { + return; + } + + this.pre(ast, this); + + if (this.options.stopWalking) { + return; + } + + if (this.options.goChildren) { + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + } else { + this.options.goChildren = true; + } + + if (this.post) { + this.post(ast, this); + } + }; + return NormalAstWalker; + })(); + + var AstWalkerFactory = (function () { + function AstWalkerFactory() { + } + AstWalkerFactory.prototype.walk = function (ast, pre, post, state) { + new NormalAstWalker(pre, post, state).walk(ast); + }; + + AstWalkerFactory.prototype.simpleWalk = function (ast, pre, post, state) { + if (post) { + new SimplePrePostAstWalker(pre, post, state).walk(ast); + } else { + new SimplePreAstWalker(pre, state).walk(ast); + } + }; + return AstWalkerFactory; + })(); + TypeScript.AstWalkerFactory = AstWalkerFactory; + + var globalAstWalkerFactory = new AstWalkerFactory(); + + function getAstWalkerFactory() { + return globalAstWalkerFactory; + } + TypeScript.getAstWalkerFactory = getAstWalkerFactory; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Base64Format = (function () { + function Base64Format() { + } + Base64Format.encode = function (inValue) { + if (inValue < 64) { + return Base64Format.encodedValues.charAt(inValue); + } + throw TypeError(inValue + ": not a 64 based value"); + }; + + Base64Format.decodeChar = function (inChar) { + if (inChar.length === 1) { + return Base64Format.encodedValues.indexOf(inChar); + } else { + throw TypeError('"' + inChar + '" must have length 1'); + } + }; + Base64Format.encodedValues = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + return Base64Format; + })(); + + var Base64VLQFormat = (function () { + function Base64VLQFormat() { + } + Base64VLQFormat.encode = function (inValue) { + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } else { + inValue = inValue << 1; + } + + var encodedStr = ""; + do { + var currentDigit = inValue & 31; + inValue = inValue >> 5; + if (inValue > 0) { + currentDigit = currentDigit | 32; + } + encodedStr = encodedStr + Base64Format.encode(currentDigit); + } while(inValue > 0); + + return encodedStr; + }; + + Base64VLQFormat.decode = function (inString) { + var result = 0; + var negative = false; + + var shift = 0; + for (var i = 0; i < inString.length; i++) { + var byte = Base64Format.decodeChar(inString[i]); + if (i === 0) { + if ((byte & 1) === 1) { + negative = true; + } + result = (byte >> 1) & 15; + } else { + result = result | ((byte & 31) << shift); + } + + shift += (i === 0) ? 4 : 5; + + if ((byte & 32) === 32) { + } else { + return { value: negative ? -(result) : result, rest: inString.substr(i + 1) }; + } + } + + throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Base64_value_0_finished_with_a_continuation_bit, [inString])); + }; + return Base64VLQFormat; + })(); + TypeScript.Base64VLQFormat = Base64VLQFormat; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SourceMapPosition = (function () { + function SourceMapPosition() { + } + return SourceMapPosition; + })(); + TypeScript.SourceMapPosition = SourceMapPosition; + + var SourceMapping = (function () { + function SourceMapping() { + this.start = new SourceMapPosition(); + this.end = new SourceMapPosition(); + this.nameIndex = -1; + this.childMappings = []; + } + return SourceMapping; + })(); + TypeScript.SourceMapping = SourceMapping; + + var SourceMapEntry = (function () { + function SourceMapEntry(emittedFile, emittedLine, emittedColumn, sourceFile, sourceLine, sourceColumn, sourceName) { + this.emittedFile = emittedFile; + this.emittedLine = emittedLine; + this.emittedColumn = emittedColumn; + this.sourceFile = sourceFile; + this.sourceLine = sourceLine; + this.sourceColumn = sourceColumn; + this.sourceName = sourceName; + TypeScript.Debug.assert(isFinite(emittedLine)); + TypeScript.Debug.assert(isFinite(emittedColumn)); + TypeScript.Debug.assert(isFinite(sourceColumn)); + TypeScript.Debug.assert(isFinite(sourceLine)); + } + return SourceMapEntry; + })(); + TypeScript.SourceMapEntry = SourceMapEntry; + + var SourceMapper = (function () { + function SourceMapper(jsFile, sourceMapOut, document, jsFilePath, emitOptions, resolvePath) { + this.jsFile = jsFile; + this.sourceMapOut = sourceMapOut; + this.names = []; + this.mappingLevel = []; + this.tsFilePaths = []; + this.allSourceMappings = []; + this.sourceMapEntries = []; + this.setSourceMapOptions(document, jsFilePath, emitOptions, resolvePath); + this.setNewSourceFile(document, emitOptions); + } + SourceMapper.prototype.getOutputFile = function () { + var result = this.sourceMapOut.getOutputFile(); + result.sourceMapEntries = this.sourceMapEntries; + + return result; + }; + + SourceMapper.prototype.increaseMappingLevel = function (ast) { + this.mappingLevel.push(ast); + }; + + SourceMapper.prototype.decreaseMappingLevel = function (ast) { + TypeScript.Debug.assert(this.mappingLevel.length > 0, "Mapping level should never be less than 0. This suggests a missing start call."); + var expectedAst = this.mappingLevel.pop(); + var expectedAstInfo = expectedAst.kind ? TypeScript.SyntaxKind[expectedAst.kind()] : [expectedAst.start(), expectedAst.end()]; + var astInfo = ast.kind ? TypeScript.SyntaxKind[ast.kind()] : [ast.start(), ast.end()]; + TypeScript.Debug.assert(ast === expectedAst, "Provided ast is not the expected AST, Expected: " + expectedAstInfo + " Given: " + astInfo); + }; + + SourceMapper.prototype.setNewSourceFile = function (document, emitOptions) { + var sourceMappings = []; + this.allSourceMappings.push(sourceMappings); + this.currentMappings = [sourceMappings]; + this.currentNameIndex = []; + + this.setNewSourceFilePath(document, emitOptions); + }; + + SourceMapper.prototype.setSourceMapOptions = function (document, jsFilePath, emitOptions, resolvePath) { + var prettyJsFileName = TypeScript.getPrettyName(jsFilePath, false, true); + var prettyMapFileName = prettyJsFileName + SourceMapper.MapFileExtension; + this.jsFileName = prettyJsFileName; + + if (emitOptions.sourceMapRootDirectory()) { + this.sourceMapDirectory = emitOptions.sourceMapRootDirectory(); + if (document.emitToOwnOutputFile()) { + this.sourceMapDirectory = this.sourceMapDirectory + TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath((document.fileName)).replace(emitOptions.commonDirectoryPath(), "")); + } + + if (TypeScript.isRelative(this.sourceMapDirectory)) { + this.sourceMapDirectory = emitOptions.commonDirectoryPath() + this.sourceMapDirectory; + this.sourceMapDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(this.sourceMapDirectory))); + this.sourceMapPath = TypeScript.getRelativePathToFixedPath(TypeScript.getRootFilePath(jsFilePath), this.sourceMapDirectory + prettyMapFileName); + } else { + this.sourceMapPath = this.sourceMapDirectory + prettyMapFileName; + } + } else { + this.sourceMapPath = prettyMapFileName; + this.sourceMapDirectory = TypeScript.getRootFilePath(jsFilePath); + } + this.sourceRoot = emitOptions.sourceRootDirectory(); + }; + + SourceMapper.prototype.setNewSourceFilePath = function (document, emitOptions) { + var tsFilePath = TypeScript.switchToForwardSlashes(document.fileName); + if (emitOptions.sourceRootDirectory()) { + tsFilePath = TypeScript.getRelativePathToFixedPath(emitOptions.commonDirectoryPath(), tsFilePath); + } else { + tsFilePath = TypeScript.getRelativePathToFixedPath(this.sourceMapDirectory, tsFilePath); + } + this.tsFilePaths.push(tsFilePath); + }; + + SourceMapper.prototype.emitSourceMapping = function () { + var _this = this; + TypeScript.Debug.assert(this.mappingLevel.length === 0, "Mapping level is not 0. This suggest a missing end call. Value: " + this.mappingLevel.map(function (item) { + return ['Node of type', TypeScript.SyntaxKind[item.kind()], 'at', item.start(), 'to', item.end()].join(' '); + }).join(', ')); + + this.jsFile.WriteLine("//# sourceMappingURL=" + this.sourceMapPath); + + var mappingsString = ""; + + var prevEmittedColumn = 0; + var prevEmittedLine = 0; + var prevSourceColumn = 0; + var prevSourceLine = 0; + var prevSourceIndex = 0; + var prevNameIndex = 0; + var emitComma = false; + + var recordedPosition = null; + for (var sourceIndex = 0; sourceIndex < this.tsFilePaths.length; sourceIndex++) { + var recordSourceMapping = function (mappedPosition, nameIndex) { + if (recordedPosition !== null && recordedPosition.emittedColumn === mappedPosition.emittedColumn && recordedPosition.emittedLine === mappedPosition.emittedLine) { + return; + } + + if (prevEmittedLine !== mappedPosition.emittedLine) { + while (prevEmittedLine < mappedPosition.emittedLine) { + prevEmittedColumn = 0; + mappingsString = mappingsString + ";"; + prevEmittedLine++; + } + emitComma = false; + } else if (emitComma) { + mappingsString = mappingsString + ","; + } + + _this.sourceMapEntries.push(new SourceMapEntry(_this.jsFileName, mappedPosition.emittedLine + 1, mappedPosition.emittedColumn + 1, _this.tsFilePaths[sourceIndex], mappedPosition.sourceLine, mappedPosition.sourceColumn + 1, nameIndex >= 0 ? _this.names[nameIndex] : undefined)); + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.emittedColumn - prevEmittedColumn); + prevEmittedColumn = mappedPosition.emittedColumn; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(sourceIndex - prevSourceIndex); + prevSourceIndex = sourceIndex; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceLine - 1 - prevSourceLine); + prevSourceLine = mappedPosition.sourceLine - 1; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceColumn - prevSourceColumn); + prevSourceColumn = mappedPosition.sourceColumn; + + if (nameIndex >= 0) { + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(nameIndex - prevNameIndex); + prevNameIndex = nameIndex; + } + + emitComma = true; + recordedPosition = mappedPosition; + }; + + var recordSourceMappingSiblings = function (sourceMappings) { + for (var i = 0; i < sourceMappings.length; i++) { + var sourceMapping = sourceMappings[i]; + recordSourceMapping(sourceMapping.start, sourceMapping.nameIndex); + recordSourceMappingSiblings(sourceMapping.childMappings); + recordSourceMapping(sourceMapping.end, sourceMapping.nameIndex); + } + }; + + recordSourceMappingSiblings(this.allSourceMappings[sourceIndex]); + } + + this.sourceMapOut.Write(JSON.stringify({ + version: 3, + file: this.jsFileName, + sourceRoot: this.sourceRoot, + sources: this.tsFilePaths, + names: this.names, + mappings: mappingsString + })); + + this.sourceMapOut.Close(); + }; + SourceMapper.MapFileExtension = ".map"; + return SourceMapper; + })(); + TypeScript.SourceMapper = SourceMapper; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (EmitContainer) { + EmitContainer[EmitContainer["Prog"] = 0] = "Prog"; + EmitContainer[EmitContainer["Module"] = 1] = "Module"; + EmitContainer[EmitContainer["DynamicModule"] = 2] = "DynamicModule"; + EmitContainer[EmitContainer["Class"] = 3] = "Class"; + EmitContainer[EmitContainer["Constructor"] = 4] = "Constructor"; + EmitContainer[EmitContainer["Function"] = 5] = "Function"; + EmitContainer[EmitContainer["Args"] = 6] = "Args"; + EmitContainer[EmitContainer["Interface"] = 7] = "Interface"; + })(TypeScript.EmitContainer || (TypeScript.EmitContainer = {})); + var EmitContainer = TypeScript.EmitContainer; + + var EmitState = (function () { + function EmitState() { + this.column = 0; + this.line = 0; + this.container = 0 /* Prog */; + } + return EmitState; + })(); + TypeScript.EmitState = EmitState; + + var EmitOptions = (function () { + function EmitOptions(compiler, resolvePath) { + this.resolvePath = resolvePath; + this._diagnostic = null; + this._settings = null; + this._commonDirectoryPath = ""; + this._sharedOutputFile = ""; + this._sourceRootDirectory = ""; + this._sourceMapRootDirectory = ""; + this._outputDirectory = ""; + var settings = compiler.compilationSettings(); + this._settings = settings; + + if (settings.moduleGenTarget() === 0 /* Unspecified */ && compiler._isDynamicModuleCompilation()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_compile_external_modules_unless_the_module_flag_is_provided, null); + return; + } + + if (!settings.mapSourceFiles()) { + if (settings.mapRoot()) { + if (settings.sourceRoot()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } else { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } + } else if (settings.sourceRoot()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } + } + + this._sourceMapRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.mapRoot())); + this._sourceRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.sourceRoot())); + + if (settings.outFileOption() || settings.outDirOption() || settings.mapRoot() || settings.sourceRoot()) { + if (settings.outFileOption()) { + this._sharedOutputFile = TypeScript.switchToForwardSlashes(resolvePath(settings.outFileOption())); + } + + if (settings.outDirOption()) { + this._outputDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(settings.outDirOption()))); + } + + if (this._outputDirectory || this._sourceMapRootDirectory || this.sourceRootDirectory) { + this.determineCommonDirectoryPath(compiler); + } + } + } + EmitOptions.prototype.diagnostic = function () { + return this._diagnostic; + }; + + EmitOptions.prototype.commonDirectoryPath = function () { + return this._commonDirectoryPath; + }; + EmitOptions.prototype.sharedOutputFile = function () { + return this._sharedOutputFile; + }; + EmitOptions.prototype.sourceRootDirectory = function () { + return this._sourceRootDirectory; + }; + EmitOptions.prototype.sourceMapRootDirectory = function () { + return this._sourceMapRootDirectory; + }; + EmitOptions.prototype.outputDirectory = function () { + return this._outputDirectory; + }; + + EmitOptions.prototype.compilationSettings = function () { + return this._settings; + }; + + EmitOptions.prototype.determineCommonDirectoryPath = function (compiler) { + var commonComponents = []; + var commonComponentsLength = -1; + + var fileNames = compiler.fileNames(); + for (var i = 0, len = fileNames.length; i < len; i++) { + var fileName = fileNames[i]; + var document = compiler.getDocument(fileNames[i]); + var sourceUnit = document.sourceUnit(); + + if (!document.isDeclareFile()) { + var fileComponents = TypeScript.filePathComponents(fileName); + if (commonComponentsLength === -1) { + commonComponents = fileComponents; + commonComponentsLength = commonComponents.length; + } else { + var updatedPath = false; + for (var j = 0; j < commonComponentsLength && j < fileComponents.length; j++) { + if (commonComponents[j] !== fileComponents[j]) { + commonComponentsLength = j; + updatedPath = true; + + if (j === 0) { + if (this._outputDirectory || this._sourceRootDirectory || (this._sourceMapRootDirectory && (!this._sharedOutputFile || compiler._isDynamicModuleCompilation()))) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_find_the_common_subdirectory_path_for_the_input_files, null); + return; + } + + return; + } + + break; + } + } + + if (!updatedPath && fileComponents.length < commonComponentsLength) { + commonComponentsLength = fileComponents.length; + } + } + } + } + + this._commonDirectoryPath = commonComponents.slice(0, commonComponentsLength).join("/") + "/"; + }; + return EmitOptions; + })(); + TypeScript.EmitOptions = EmitOptions; + + var Indenter = (function () { + function Indenter() { + this.indentAmt = 0; + } + Indenter.prototype.increaseIndent = function () { + this.indentAmt += Indenter.indentStep; + }; + + Indenter.prototype.decreaseIndent = function () { + this.indentAmt -= Indenter.indentStep; + }; + + Indenter.prototype.getIndent = function () { + var indentString = Indenter.indentStrings[this.indentAmt]; + if (indentString === undefined) { + indentString = ""; + for (var i = 0; i < this.indentAmt; i = i + Indenter.indentStep) { + indentString += Indenter.indentStepString; + } + Indenter.indentStrings[this.indentAmt] = indentString; + } + return indentString; + }; + Indenter.indentStep = 4; + Indenter.indentStepString = " "; + Indenter.indentStrings = []; + return Indenter; + })(); + TypeScript.Indenter = Indenter; + + function lastParameterIsRest(parameterList) { + var parameters = parameterList.parameters; + return parameters.nonSeparatorCount() > 0 && parameters.nonSeparatorAt(parameters.nonSeparatorCount() - 1).dotDotDotToken !== null; + } + TypeScript.lastParameterIsRest = lastParameterIsRest; + + var Emitter = (function () { + function Emitter(emittingFileName, outfile, emitOptions, semanticInfoChain) { + this.emittingFileName = emittingFileName; + this.outfile = outfile; + this.emitOptions = emitOptions; + this.semanticInfoChain = semanticInfoChain; + this.globalThisCapturePrologueEmitted = false; + this.extendsPrologueEmitted = false; + this.thisClassNode = null; + this.inArrowFunction = false; + this.moduleName = ""; + this.emitState = new EmitState(); + this.indenter = new Indenter(); + this.sourceMapper = null; + this.captureThisStmtString = "var _this = this;"; + this.declStack = []; + this.exportAssignmentIdentifier = null; + this.inWithBlock = false; + this.document = null; + this.copyrightElement = null; + } + Emitter.prototype.pushDecl = function (decl) { + if (decl) { + this.declStack[this.declStack.length] = decl; + } + }; + + Emitter.prototype.popDecl = function (decl) { + if (decl) { + this.declStack.length--; + } + }; + + Emitter.prototype.getEnclosingDecl = function () { + var declStackLen = this.declStack.length; + var enclosingDecl = declStackLen > 0 ? this.declStack[declStackLen - 1] : null; + return enclosingDecl; + }; + + Emitter.prototype.setExportAssignmentIdentifier = function (id) { + this.exportAssignmentIdentifier = id; + }; + + Emitter.prototype.getExportAssignmentIdentifier = function () { + return this.exportAssignmentIdentifier; + }; + + Emitter.prototype.setDocument = function (document) { + this.document = document; + }; + + Emitter.prototype.shouldEmitImportDeclaration = function (importDeclAST) { + return TypeScript.importDeclarationIsElided(importDeclAST, this.semanticInfoChain, this.emitOptions.compilationSettings()); + }; + + Emitter.prototype.emitImportDeclaration = function (importDeclAST) { + var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */; + var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST); + var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */); + var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() == 2 /* Asynchronous */; + + this.emitComments(importDeclAST, true); + + var importSymbol = importDecl.getSymbol(); + + var parentSymbol = importSymbol.getContainer(); + var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */; + var associatedParentSymbol = parentSymbol ? parentSymbol.getAssociatedContainerType() : null; + var associatedParentSymbolKind = associatedParentSymbol ? associatedParentSymbol.kind : 0 /* None */; + + var needsPropertyAssignment = false; + var usePropertyAssignmentInsteadOfVarDecl = false; + var moduleNamePrefix; + + if (isExported && (parentKind == 4 /* Container */ || parentKind === 32 /* DynamicModule */ || associatedParentSymbolKind === 4 /* Container */ || associatedParentSymbolKind === 32 /* DynamicModule */)) { + if (importSymbol.getExportAssignedTypeSymbol() || importSymbol.getExportAssignedContainerSymbol()) { + needsPropertyAssignment = true; + } else { + var valueSymbol = importSymbol.getExportAssignedValueSymbol(); + if (valueSymbol && (valueSymbol.kind == 65536 /* Method */ || valueSymbol.kind == 16384 /* Function */)) { + needsPropertyAssignment = true; + } else { + usePropertyAssignmentInsteadOfVarDecl = true; + } + } + + if (this.emitState.container === 2 /* DynamicModule */) { + moduleNamePrefix = "exports."; + } else { + moduleNamePrefix = this.moduleName + "."; + } + } + + if (isAmdCodeGen && isExternalModuleReference) { + needsPropertyAssignment = true; + } else { + this.recordSourceMappingStart(importDeclAST); + if (usePropertyAssignmentInsteadOfVarDecl) { + this.writeToOutput(moduleNamePrefix); + } else { + this.writeToOutput("var "); + } + this.writeToOutput(importDeclAST.identifier.text() + " = "); + var aliasAST = importDeclAST.moduleReference; + + if (isExternalModuleReference) { + this.writeToOutput("require(" + aliasAST.stringLiteral.text() + ")"); + } else { + this.emitJavascript(aliasAST.moduleName, false); + } + + this.recordSourceMappingEnd(importDeclAST); + this.writeToOutput(";"); + + if (needsPropertyAssignment) { + this.writeLineToOutput(""); + this.emitIndent(); + } + } + + if (needsPropertyAssignment) { + this.writeToOutputWithSourceMapRecord(moduleNamePrefix + importDeclAST.identifier.text() + " = " + importDeclAST.identifier.text(), importDeclAST); + this.writeToOutput(";"); + } + this.emitComments(importDeclAST, false); + }; + + Emitter.prototype.createSourceMapper = function (document, jsFileName, jsFile, sourceMapOut, resolvePath) { + this.sourceMapper = new TypeScript.SourceMapper(jsFile, sourceMapOut, document, jsFileName, this.emitOptions, resolvePath); + }; + + Emitter.prototype.setSourceMapperNewSourceFile = function (document) { + this.sourceMapper.setNewSourceFile(document, this.emitOptions); + }; + + Emitter.prototype.updateLineAndColumn = function (s) { + var lineNumbers = TypeScript.TextUtilities.parseLineStarts(s); + if (lineNumbers.length > 1) { + this.emitState.line += lineNumbers.length - 1; + this.emitState.column = s.length - lineNumbers[lineNumbers.length - 1]; + } else { + this.emitState.column += s.length; + } + }; + + Emitter.prototype.writeToOutputWithSourceMapRecord = function (s, astSpan) { + this.recordSourceMappingStart(astSpan); + this.writeToOutput(s); + this.recordSourceMappingEnd(astSpan); + }; + + Emitter.prototype.writeToOutput = function (s) { + this.outfile.Write(s); + this.updateLineAndColumn(s); + }; + + Emitter.prototype.writeLineToOutput = function (s, force) { + if (typeof force === "undefined") { force = false; } + if (!force && s === "" && this.emitState.column === 0) { + return; + } + + this.outfile.WriteLine(s); + this.updateLineAndColumn(s); + this.emitState.column = 0; + this.emitState.line++; + }; + + Emitter.prototype.writeCaptureThisStatement = function (ast) { + this.emitIndent(); + this.writeToOutputWithSourceMapRecord(this.captureThisStmtString, ast); + this.writeLineToOutput(""); + }; + + Emitter.prototype.setContainer = function (c) { + var temp = this.emitState.container; + this.emitState.container = c; + return temp; + }; + + Emitter.prototype.getIndentString = function () { + return this.indenter.getIndent(); + }; + + Emitter.prototype.emitIndent = function () { + this.writeToOutput(this.getIndentString()); + }; + + Emitter.prototype.emitComment = function (comment, trailing, first) { + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var text = getTrimmedTextLines(comment); + var emitColumn = this.emitState.column; + + if (emitColumn === 0) { + this.emitIndent(); + } else if (trailing && first) { + this.writeToOutput(" "); + } + + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + this.recordSourceMappingStart(comment); + this.writeToOutput(text[0]); + + if (text.length > 1 || comment.endsLine) { + for (var i = 1; i < text.length; i++) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput(text[i]); + } + this.recordSourceMappingEnd(comment); + this.writeLineToOutput(""); + } else { + this.recordSourceMappingEnd(comment); + this.writeToOutput(" "); + return; + } + } else { + this.recordSourceMappingStart(comment); + this.writeToOutput(text[0]); + this.recordSourceMappingEnd(comment); + this.writeLineToOutput(""); + } + + if (!trailing && emitColumn != 0) { + this.emitIndent(); + } + }; + + Emitter.prototype.emitComments = function (ast, pre, onlyPinnedOrTripleSlashComments) { + if (typeof onlyPinnedOrTripleSlashComments === "undefined") { onlyPinnedOrTripleSlashComments = false; } + var _this = this; + if (ast && ast.kind() !== 146 /* Block */) { + if (ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ || ast.parent.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + return; + } + } + + if (pre) { + var preComments = ast.preComments(); + + if (preComments && ast === this.copyrightElement) { + var copyrightComments = this.getCopyrightComments(); + preComments = preComments.slice(copyrightComments.length); + } + + if (onlyPinnedOrTripleSlashComments) { + preComments = TypeScript.ArrayUtilities.where(preComments, function (c) { + return _this.isPinnedOrTripleSlash(c); + }); + } + + this.emitCommentsArray(preComments, false); + } else { + this.emitCommentsArray(ast.postComments(), true); + } + }; + + Emitter.prototype.isPinnedOrTripleSlash = function (comment) { + var fullText = comment.fullText(); + if (fullText.match(TypeScript.tripleSlashReferenceRegExp)) { + return true; + } else { + return fullText.indexOf("/*!") === 0; + } + }; + + Emitter.prototype.emitCommentsArray = function (comments, trailing) { + if (!this.emitOptions.compilationSettings().removeComments() && comments) { + for (var i = 0, n = comments.length; i < n; i++) { + this.emitComment(comments[i], trailing, i === 0); + } + } + }; + + Emitter.prototype.emitObjectLiteralExpression = function (objectLiteral) { + this.recordSourceMappingStart(objectLiteral); + + this.writeToOutput("{"); + this.emitCommaSeparatedList(objectLiteral, objectLiteral.propertyAssignments, " ", true); + this.writeToOutput("}"); + + this.recordSourceMappingEnd(objectLiteral); + }; + + Emitter.prototype.emitArrayLiteralExpression = function (arrayLiteral) { + this.recordSourceMappingStart(arrayLiteral); + + this.writeToOutput("["); + this.emitCommaSeparatedList(arrayLiteral, arrayLiteral.expressions, "", true); + this.writeToOutput("]"); + + this.recordSourceMappingEnd(arrayLiteral); + }; + + Emitter.prototype.emitObjectCreationExpression = function (objectCreationExpression) { + this.recordSourceMappingStart(objectCreationExpression); + this.writeToOutput("new "); + var target = objectCreationExpression.expression; + + this.emit(target); + if (objectCreationExpression.argumentList) { + this.recordSourceMappingStart(objectCreationExpression.argumentList); + this.writeToOutput("("); + this.emitCommaSeparatedList(objectCreationExpression.argumentList, objectCreationExpression.argumentList.arguments, "", false); + this.writeToOutputWithSourceMapRecord(")", objectCreationExpression.argumentList.closeParenToken); + this.recordSourceMappingEnd(objectCreationExpression.argumentList); + } + + this.recordSourceMappingEnd(objectCreationExpression); + }; + + Emitter.prototype.getConstantDecl = function (dotExpr) { + var pullSymbol = this.semanticInfoChain.getSymbolForAST(dotExpr); + if (pullSymbol && pullSymbol.kind === 67108864 /* EnumMember */) { + var pullDecls = pullSymbol.getDeclarations(); + if (pullDecls.length === 1) { + var pullDecl = pullDecls[0]; + if (pullDecl.kind === 67108864 /* EnumMember */) { + return pullDecl; + } + } + } + + return null; + }; + + Emitter.prototype.tryEmitConstant = function (dotExpr) { + var propertyName = dotExpr.name; + var boundDecl = this.getConstantDecl(dotExpr); + if (boundDecl) { + var value = boundDecl.constantValue; + if (value !== null) { + this.recordSourceMappingStart(dotExpr); + this.writeToOutput(value.toString()); + var comment = " /* "; + comment += propertyName.text(); + comment += " */"; + this.writeToOutput(comment); + this.recordSourceMappingEnd(dotExpr); + return true; + } + } + + return false; + }; + + Emitter.prototype.emitInvocationExpression = function (callNode) { + this.recordSourceMappingStart(callNode); + var target = callNode.expression; + var args = callNode.argumentList.arguments; + + if (target.kind() === 212 /* MemberAccessExpression */ && target.expression.kind() === 50 /* SuperKeyword */) { + this.emit(target); + this.writeToOutput(".call"); + this.recordSourceMappingStart(args); + this.writeToOutput("("); + this.emitThis(); + if (args && args.nonSeparatorCount() > 0) { + this.writeToOutput(", "); + this.emitCommaSeparatedList(callNode.argumentList, args, "", false); + } + } else { + if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) { + this.writeToOutput("_super.call"); + } else { + this.emitJavascript(target, false); + } + this.recordSourceMappingStart(args); + this.writeToOutput("("); + if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) { + this.writeToOutput("this"); + if (args && args.nonSeparatorCount() > 0) { + this.writeToOutput(", "); + } + } + this.emitCommaSeparatedList(callNode.argumentList, args, "", false); + } + + this.writeToOutputWithSourceMapRecord(")", callNode.argumentList.closeParenToken); + this.recordSourceMappingEnd(args); + this.recordSourceMappingEnd(callNode); + }; + + Emitter.prototype.emitParameterList = function (list) { + this.writeToOutput("("); + this.emitCommentsArray(list.openParenTrailingComments, true); + this.emitFunctionParameters(TypeScript.Parameters.fromParameterList(list)); + this.writeToOutput(")"); + }; + + Emitter.prototype.emitFunctionParameters = function (parameters) { + var argsLen = 0; + + if (parameters) { + this.emitComments(parameters.ast, true); + + var tempContainer = this.setContainer(6 /* Args */); + argsLen = parameters.length; + var printLen = argsLen; + if (parameters.lastParameterIsRest()) { + printLen--; + } + for (var i = 0; i < printLen; i++) { + var arg = parameters.astAt(i); + this.emit(arg); + + if (i < (printLen - 1)) { + this.writeToOutput(", "); + } + } + this.setContainer(tempContainer); + + this.emitComments(parameters.ast, false); + } + }; + + Emitter.prototype.emitFunctionBodyStatements = function (name, funcDecl, parameterList, block, bodyExpression) { + this.writeLineToOutput(" {"); + if (name) { + this.recordSourceMappingNameStart(name); + } + + this.indenter.increaseIndent(); + + if (parameterList) { + this.emitDefaultValueAssignments(parameterList); + this.emitRestParameterInitializer(parameterList); + } + + if (this.shouldCaptureThis(funcDecl)) { + this.writeCaptureThisStatement(funcDecl); + } + + if (block) { + this.emitList(block.statements); + this.emitCommentsArray(block.closeBraceLeadingComments, false); + } else { + this.emitIndent(); + this.emitCommentsArray(bodyExpression.preComments(), false); + this.writeToOutput("return "); + this.emit(bodyExpression); + this.writeLineToOutput(";"); + this.emitCommentsArray(bodyExpression.postComments(), true); + } + + this.indenter.decreaseIndent(); + this.emitIndent(); + + if (block) { + this.writeToOutputWithSourceMapRecord("}", block.closeBraceToken); + } else { + this.writeToOutputWithSourceMapRecord("}", bodyExpression); + } + + if (name) { + this.recordSourceMappingNameEnd(); + } + }; + + Emitter.prototype.emitDefaultValueAssignments = function (parameters) { + var n = parameters.length; + if (parameters.lastParameterIsRest()) { + n--; + } + + for (var i = 0; i < n; i++) { + var arg = parameters.astAt(i); + var id = parameters.identifierAt(i); + var equalsValueClause = parameters.initializerAt(i); + if (equalsValueClause) { + this.emitIndent(); + this.recordSourceMappingStart(arg); + this.writeToOutput("if (typeof " + id.text() + " === \"undefined\") { "); + this.writeToOutputWithSourceMapRecord(id.text(), id); + this.emitJavascript(equalsValueClause, false); + this.writeLineToOutput("; }"); + this.recordSourceMappingEnd(arg); + } + } + }; + + Emitter.prototype.emitRestParameterInitializer = function (parameters) { + if (parameters.lastParameterIsRest()) { + var n = parameters.length; + var lastArg = parameters.astAt(n - 1); + var id = parameters.identifierAt(n - 1); + this.emitIndent(); + this.recordSourceMappingStart(lastArg); + this.writeToOutput("var "); + this.writeToOutputWithSourceMapRecord(id.text(), id); + this.writeLineToOutput(" = [];"); + this.recordSourceMappingEnd(lastArg); + this.emitIndent(); + this.writeToOutput("for ("); + this.writeToOutputWithSourceMapRecord("var _i = 0;", lastArg); + this.writeToOutput(" "); + this.writeToOutputWithSourceMapRecord("_i < (arguments.length - " + (n - 1) + ")", lastArg); + this.writeToOutput("; "); + this.writeToOutputWithSourceMapRecord("_i++", lastArg); + this.writeLineToOutput(") {"); + this.indenter.increaseIndent(); + this.emitIndent(); + + this.writeToOutputWithSourceMapRecord(id.text() + "[_i] = arguments[_i + " + (n - 1) + "];", lastArg); + this.writeLineToOutput(""); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("}"); + } + }; + + Emitter.prototype.getImportDecls = function (fileName) { + var topLevelDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName); + var result = []; + + var dynamicModuleDecl = topLevelDecl.getChildDecls()[0]; + var queue = dynamicModuleDecl.getChildDecls(); + + for (var i = 0, n = queue.length; i < n; i++) { + var decl = queue[i]; + + if (decl.kind & 128 /* TypeAlias */) { + var importStatementAST = this.semanticInfoChain.getASTForDecl(decl); + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var symbol = decl.getSymbol(); + var typeSymbol = symbol && symbol.type; + if (typeSymbol && typeSymbol !== this.semanticInfoChain.anyTypeSymbol && !typeSymbol.isError()) { + result.push(decl); + } + } + } + } + + return result; + }; + + Emitter.prototype.getModuleImportAndDependencyList = function (sourceUnit) { + var importList = ""; + var dependencyList = ""; + + var importDecls = this.getImportDecls(this.document.fileName); + + if (importDecls.length) { + for (var i = 0; i < importDecls.length; i++) { + var importStatementDecl = importDecls[i]; + var importStatementSymbol = importStatementDecl.getSymbol(); + var importStatementAST = this.semanticInfoChain.getASTForDecl(importStatementDecl); + + if (importStatementSymbol.isUsedAsValue()) { + if (i <= importDecls.length - 1) { + dependencyList += ", "; + importList += ", "; + } + + importList += importStatementDecl.name; + dependencyList += importStatementAST.moduleReference.stringLiteral.text(); + } + } + } + + var amdDependencies = this.document.amdDependencies(); + for (var i = 0; i < amdDependencies.length; i++) { + dependencyList += ", \"" + amdDependencies[i] + "\""; + } + + return { + importList: importList, + dependencyList: dependencyList + }; + }; + + Emitter.prototype.shouldCaptureThis = function (ast) { + if (ast.kind() === 120 /* SourceUnit */) { + var scriptDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName); + return TypeScript.hasFlag(scriptDecl.flags, 262144 /* MustCaptureThis */); + } + + var decl = this.semanticInfoChain.getDeclForAST(ast); + if (decl) { + return TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */); + } + + return false; + }; + + Emitter.prototype.emitEnum = function (moduleDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.pushDecl(pullDecl); + + var svModuleName = this.moduleName; + this.moduleName = moduleDecl.identifier.text(); + + var temp = this.setContainer(1 /* Module */); + var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */); + + if (!isExported) { + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("var "); + this.recordSourceMappingStart(moduleDecl.identifier); + this.writeToOutput(this.moduleName); + this.recordSourceMappingEnd(moduleDecl.identifier); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(moduleDecl); + this.emitIndent(); + } + + this.writeToOutput("("); + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("function ("); + this.writeToOutputWithSourceMapRecord(this.moduleName, moduleDecl.identifier); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart(this.moduleName); + + this.indenter.increaseIndent(); + + if (this.shouldCaptureThis(moduleDecl)) { + this.writeCaptureThisStatement(moduleDecl); + } + + this.emitSeparatedList(moduleDecl.enumElements); + this.indenter.decreaseIndent(); + this.emitIndent(); + + var parentIsDynamic = temp === 2 /* DynamicModule */; + if (temp === 0 /* Prog */ && isExported) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));"); + } else if (isExported || temp === 0 /* Prog */) { + var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName; + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));"); + } else if (!isExported && temp !== 0 /* Prog */) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));"); + } else { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")();"); + } + + this.recordSourceMappingEnd(moduleDecl); + if (temp !== 0 /* Prog */ && isExported) { + this.recordSourceMappingStart(moduleDecl); + if (parentIsDynamic) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";"); + } else { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";"); + } + this.recordSourceMappingEnd(moduleDecl); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + + this.popDecl(pullDecl); + }; + + Emitter.prototype.getModuleDeclToVerifyChildNameCollision = function (moduleDecl, changeNameIfAnyDeclarationInContext) { + if (TypeScript.ArrayUtilities.contains(this.declStack, moduleDecl)) { + return moduleDecl; + } else if (changeNameIfAnyDeclarationInContext) { + var symbol = moduleDecl.getSymbol(); + if (symbol) { + var otherDecls = symbol.getDeclarations(); + for (var i = 0; i < otherDecls.length; i++) { + if (TypeScript.ArrayUtilities.contains(this.declStack, otherDecls[i])) { + return otherDecls[i]; + } + } + } + } + + return null; + }; + + Emitter.prototype.hasChildNameCollision = function (moduleName, childDecls) { + var _this = this; + return TypeScript.ArrayUtilities.any(childDecls, function (childDecl) { + if (childDecl.name == moduleName) { + var childAST = _this.semanticInfoChain.getASTForDecl(childDecl); + if (_this.shouldEmit(childAST)) { + return true; + } + } + return false; + }); + }; + + Emitter.prototype.getModuleName = function (moduleDecl, changeNameIfAnyDeclarationInContext) { + var moduleName = moduleDecl.name; + var moduleDisplayName = moduleDecl.getDisplayName(); + + moduleDecl = this.getModuleDeclToVerifyChildNameCollision(moduleDecl, changeNameIfAnyDeclarationInContext); + if (moduleDecl) { + var childDecls = moduleDecl.getChildDecls(); + + while (this.hasChildNameCollision(moduleName, childDecls)) { + moduleName = "_" + moduleName; + moduleDisplayName = "_" + moduleDisplayName; + } + } + + return moduleDisplayName; + }; + + Emitter.prototype.emitModuleDeclarationWorker = function (moduleDecl) { + if (moduleDecl.stringLiteral) { + this.emitSingleModuleDeclaration(moduleDecl, moduleDecl.stringLiteral); + } else { + var moduleNames = TypeScript.getModuleNames(moduleDecl.name); + this.emitSingleModuleDeclaration(moduleDecl, moduleNames[0]); + } + }; + + Emitter.prototype.emitSingleModuleDeclaration = function (moduleDecl, moduleName) { + var isLastName = TypeScript.isLastNameOfModule(moduleDecl, moduleName); + + if (isLastName) { + this.emitComments(moduleDecl, true); + } + + var pullDecl = this.semanticInfoChain.getDeclForAST(moduleName); + this.pushDecl(pullDecl); + + var svModuleName = this.moduleName; + + if (moduleDecl.stringLiteral) { + this.moduleName = moduleDecl.stringLiteral.valueText(); + if (TypeScript.isTSFile(this.moduleName)) { + this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length); + } + } else { + this.moduleName = moduleName.text(); + } + + var temp = this.setContainer(1 /* Module */); + var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */); + + if (!isExported) { + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("var "); + this.recordSourceMappingStart(moduleName); + this.writeToOutput(this.moduleName); + this.recordSourceMappingEnd(moduleName); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(moduleDecl); + this.emitIndent(); + } + + this.writeToOutput("("); + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("function ("); + + this.moduleName = this.getModuleName(pullDecl); + this.writeToOutputWithSourceMapRecord(this.moduleName, moduleName); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart(moduleName.text()); + + this.indenter.increaseIndent(); + + if (this.shouldCaptureThis(moduleDecl)) { + this.writeCaptureThisStatement(moduleDecl); + } + + if (moduleName === moduleDecl.stringLiteral) { + this.emitList(moduleDecl.moduleElements); + } else { + var moduleNames = TypeScript.getModuleNames(moduleDecl.name); + var nameIndex = moduleNames.indexOf(moduleName); + TypeScript.Debug.assert(nameIndex >= 0); + + if (isLastName) { + this.emitList(moduleDecl.moduleElements); + } else { + this.emitIndent(); + this.emitSingleModuleDeclaration(moduleDecl, moduleNames[nameIndex + 1]); + this.writeLineToOutput(""); + } + } + + this.moduleName = moduleName.text(); + this.indenter.decreaseIndent(); + this.emitIndent(); + + var parentIsDynamic = temp === 2 /* DynamicModule */; + this.recordSourceMappingStart(moduleDecl.endingToken); + if (temp === 0 /* Prog */ && isExported) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));"); + } else if (isExported || temp === 0 /* Prog */) { + var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName; + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));"); + } else if (!isExported && temp !== 0 /* Prog */) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));"); + } else { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")();"); + } + + this.recordSourceMappingEnd(moduleDecl); + if (temp !== 0 /* Prog */ && isExported) { + this.recordSourceMappingStart(moduleDecl); + if (parentIsDynamic) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";"); + } else { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";"); + } + this.recordSourceMappingEnd(moduleDecl); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + + this.popDecl(pullDecl); + + if (isLastName) { + this.emitComments(moduleDecl, false); + } + }; + + Emitter.prototype.emitEnumElement = function (varDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + TypeScript.Debug.assert(pullDecl && pullDecl.kind === 67108864 /* EnumMember */); + + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + var name = varDecl.propertyName.text(); + var quoted = TypeScript.isQuoted(name); + this.writeToOutput(this.moduleName); + this.writeToOutput('['); + this.writeToOutput(this.moduleName); + this.writeToOutput('['); + this.writeToOutput(quoted ? name : '"' + name + '"'); + this.writeToOutput(']'); + + if (varDecl.equalsValueClause) { + this.emit(varDecl.equalsValueClause); + } else if (pullDecl.constantValue !== null) { + this.writeToOutput(' = '); + this.writeToOutput(pullDecl.constantValue.toString()); + } else { + this.writeToOutput(' = null'); + } + + this.writeToOutput('] = '); + this.writeToOutput(quoted ? name : '"' + name + '"'); + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + this.writeToOutput(';'); + }; + + Emitter.prototype.emitElementAccessExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.emit(expression.expression); + this.writeToOutput("["); + this.emit(expression.argumentExpression); + this.writeToOutput("]"); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitSimpleArrowFunctionExpression = function (arrowFunction) { + this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.Parameters.fromIdentifier(arrowFunction.identifier), arrowFunction.block, arrowFunction.expression); + }; + + Emitter.prototype.emitParenthesizedArrowFunctionExpression = function (arrowFunction) { + this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.Parameters.fromParameterList(arrowFunction.callSignature.parameterList), arrowFunction.block, arrowFunction.expression); + }; + + Emitter.prototype.emitAnyArrowFunctionExpression = function (arrowFunction, funcName, parameters, block, expression) { + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = true; + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(arrowFunction); + + var pullDecl = this.semanticInfoChain.getDeclForAST(arrowFunction); + this.pushDecl(pullDecl); + + this.emitComments(arrowFunction, true); + + this.recordSourceMappingStart(arrowFunction); + this.writeToOutput("function "); + this.writeToOutput("("); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcName, arrowFunction, parameters, block, expression); + + this.recordSourceMappingEnd(arrowFunction); + + this.recordSourceMappingEnd(arrowFunction); + + this.emitComments(arrowFunction, false); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + }; + + Emitter.prototype.emitConstructor = function (funcDecl) { + if (!funcDecl.block) { + return; + } + var temp = this.setContainer(4 /* Constructor */); + + this.recordSourceMappingStart(funcDecl); + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.emitComments(funcDecl, true); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + this.writeToOutput(this.thisClassNode.identifier.text()); + this.writeToOutput("("); + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.parameterList); + this.emitFunctionParameters(parameters); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart("constructor"); + this.indenter.increaseIndent(); + + this.emitDefaultValueAssignments(parameters); + this.emitRestParameterInitializer(parameters); + + if (this.shouldCaptureThis(funcDecl)) { + this.writeCaptureThisStatement(funcDecl); + } + + this.emitConstructorStatements(funcDecl); + this.emitCommentsArray(funcDecl.block.closeBraceLeadingComments, false); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("}", funcDecl.block.closeBraceToken); + + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + this.setContainer(temp); + }; + + Emitter.prototype.emitGetAccessor = function (accessor) { + this.recordSourceMappingStart(accessor); + this.writeToOutput("get "); + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(accessor); + + var pullDecl = this.semanticInfoChain.getDeclForAST(accessor); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(accessor); + + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain); + var container = accessorSymbol.getContainer(); + var containerKind = container.kind; + + this.recordSourceMappingNameStart(accessor.propertyName.text()); + this.writeToOutput(accessor.propertyName.text()); + this.writeToOutput("("); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, accessor, TypeScript.Parameters.fromParameterList(accessor.parameterList), accessor.block, null); + + this.recordSourceMappingEnd(accessor); + + this.recordSourceMappingEnd(accessor); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.recordSourceMappingEnd(accessor); + }; + + Emitter.prototype.emitSetAccessor = function (accessor) { + this.recordSourceMappingStart(accessor); + this.writeToOutput("set "); + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(accessor); + + var pullDecl = this.semanticInfoChain.getDeclForAST(accessor); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(accessor); + + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain); + var container = accessorSymbol.getContainer(); + var containerKind = container.kind; + + this.recordSourceMappingNameStart(accessor.propertyName.text()); + this.writeToOutput(accessor.propertyName.text()); + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(accessor.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, accessor, parameters, accessor.block, null); + + this.recordSourceMappingEnd(accessor); + + this.recordSourceMappingEnd(accessor); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.recordSourceMappingEnd(accessor); + }; + + Emitter.prototype.emitFunctionExpression = function (funcDecl) { + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + + var funcName = funcDecl.identifier ? funcDecl.identifier.text() : null; + + this.recordSourceMappingStart(funcDecl); + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + if (funcDecl.identifier) { + this.recordSourceMappingStart(funcDecl.identifier); + this.writeToOutput(funcDecl.identifier.text()); + this.recordSourceMappingEnd(funcDecl.identifier); + } + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcName, funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + }; + + Emitter.prototype.emitFunction = function (funcDecl) { + if (funcDecl.block === null) { + return; + } + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + + var funcName = funcDecl.identifier.text(); + + this.recordSourceMappingStart(funcDecl); + + var printName = funcDecl.identifier !== null; + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.emitComments(funcDecl, true); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + if (printName) { + var id = funcDecl.identifier.text(); + if (id) { + if (funcDecl.identifier) { + this.recordSourceMappingStart(funcDecl.identifier); + } + this.writeToOutput(id); + if (funcDecl.identifier) { + this.recordSourceMappingEnd(funcDecl.identifier); + } + } + } + + this.emitParameterList(funcDecl.callSignature.parameterList); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionBodyStatements(funcDecl.identifier.text(), funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + + if (funcDecl.block) { + var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + if ((this.emitState.container === 1 /* Module */ || this.emitState.container === 2 /* DynamicModule */) && pullFunctionDecl && TypeScript.hasFlag(pullFunctionDecl.flags, 1 /* Exported */)) { + this.writeLineToOutput(""); + this.emitIndent(); + var modName = this.emitState.container === 1 /* Module */ ? this.moduleName : "exports"; + this.recordSourceMappingStart(funcDecl); + this.writeToOutput(modName + "." + funcName + " = " + funcName + ";"); + this.recordSourceMappingEnd(funcDecl); + } + } + }; + + Emitter.prototype.emitAmbientVarDecl = function (varDecl) { + this.recordSourceMappingStart(this.currentVariableDeclaration); + if (varDecl.equalsValueClause) { + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName); + this.emitJavascript(varDecl.equalsValueClause, false); + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + } + }; + + Emitter.prototype.emitVarDeclVar = function () { + if (this.currentVariableDeclaration) { + this.writeToOutput("var "); + } + }; + + Emitter.prototype.emitVariableDeclaration = function (declaration) { + var varDecl = declaration.declarators.nonSeparatorAt(0); + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */; + + this.emitComments(declaration, true); + + var pullVarDecl = this.semanticInfoChain.getDeclForAST(varDecl); + var isAmbientWithoutInit = pullVarDecl && TypeScript.hasFlag(pullVarDecl.flags, 8 /* Ambient */) && varDecl.equalsValueClause === null; + if (!isAmbientWithoutInit) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.currentVariableDeclaration = declaration; + + for (var i = 0, n = declaration.declarators.nonSeparatorCount(); i < n; i++) { + var declarator = declaration.declarators.nonSeparatorAt(i); + + if (i > 0) { + this.writeToOutput(", "); + } + + this.emit(declarator); + } + this.currentVariableDeclaration = prevVariableDeclaration; + + this.recordSourceMappingEnd(declaration); + } + + this.emitComments(declaration, false); + }; + + Emitter.prototype.emitMemberVariableDeclaration = function (varDecl) { + TypeScript.Debug.assert(!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause); + + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + this.pushDecl(pullDecl); + + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.variableDeclarator.propertyName.text(); + var quotedOrNumber = TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */; + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentDecl = pullDecl && pullDecl.getParentDecl(); + + if (quotedOrNumber) { + this.writeToOutput("this["); + } else { + this.writeToOutput("this."); + } + + this.writeToOutputWithSourceMapRecord(varDecl.variableDeclarator.propertyName.text(), varDecl.variableDeclarator.propertyName); + + if (quotedOrNumber) { + this.writeToOutput("]"); + } + + if (varDecl.variableDeclarator.equalsValueClause) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.emit(varDecl.variableDeclarator.equalsValueClause); + this.currentVariableDeclaration = prevVariableDeclaration; + } + + if (this.emitState.container !== 6 /* Args */) { + this.writeToOutput(";"); + } + + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitVariableDeclarator = function (varDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + this.pushDecl(pullDecl); + if (pullDecl && (pullDecl.flags & 8 /* Ambient */) === 8 /* Ambient */) { + this.emitAmbientVarDecl(varDecl); + } else { + this.emitComments(varDecl, true); + this.recordSourceMappingStart(this.currentVariableDeclaration); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.propertyName.text(); + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentDecl = pullDecl && pullDecl.getParentDecl(); + var parentIsModule = parentDecl && (parentDecl.flags & 102400 /* SomeInitializedModule */); + + if (parentIsModule) { + if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + this.emitVarDeclVar(); + } else { + if (this.emitState.container === 2 /* DynamicModule */) { + this.writeToOutput("exports."); + } else { + this.writeToOutput(this.moduleName + "."); + } + } + } else { + this.emitVarDeclVar(); + } + + this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName); + + if (varDecl.equalsValueClause) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.emit(varDecl.equalsValueClause); + this.currentVariableDeclaration = prevVariableDeclaration; + } + + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + } + this.currentVariableDeclaration = undefined; + this.popDecl(pullDecl); + }; + + Emitter.prototype.symbolIsUsedInItsEnclosingContainer = function (symbol, dynamic) { + if (typeof dynamic === "undefined") { dynamic = false; } + var symDecls = symbol.getDeclarations(); + + if (symDecls.length) { + var enclosingDecl = this.getEnclosingDecl(); + if (enclosingDecl) { + var parentDecl = symDecls[0].getParentDecl(); + if (parentDecl) { + var symbolDeclarationEnclosingContainer = parentDecl; + var enclosingContainer = enclosingDecl; + + while (symbolDeclarationEnclosingContainer) { + if (symbolDeclarationEnclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) { + break; + } + symbolDeclarationEnclosingContainer = symbolDeclarationEnclosingContainer.getParentDecl(); + } + + if (symbolDeclarationEnclosingContainer) { + while (enclosingContainer) { + if (enclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) { + break; + } + + enclosingContainer = enclosingContainer.getParentDecl(); + } + } + + if (symbolDeclarationEnclosingContainer && enclosingContainer) { + var same = symbolDeclarationEnclosingContainer === enclosingContainer; + + if (!same && symbol.anyDeclHasFlag(32768 /* InitializedModule */)) { + same = symbolDeclarationEnclosingContainer === enclosingContainer.getParentDecl(); + } + + return same; + } + } + } + } + + return false; + }; + + Emitter.prototype.getPotentialDeclPathInfoForEmit = function (pullSymbol) { + var decl = pullSymbol.getDeclarations()[0]; + var parentDecl = decl.getParentDecl(); + var symbolContainerDeclPath = parentDecl ? parentDecl.getParentPath() : []; + + var enclosingContextDeclPath = this.declStack; + var commonNodeIndex = -1; + + if (enclosingContextDeclPath.length) { + for (var i = symbolContainerDeclPath.length - 1; i >= 0; i--) { + var symbolContainerDeclPathNode = symbolContainerDeclPath[i]; + for (var j = enclosingContextDeclPath.length - 1; j >= 0; j--) { + var enclosingContextDeclPathNode = enclosingContextDeclPath[j]; + if (symbolContainerDeclPathNode === enclosingContextDeclPathNode) { + commonNodeIndex = i; + break; + } + } + + if (commonNodeIndex >= 0) { + break; + } + } + } + + var startingIndex = symbolContainerDeclPath.length - 1; + for (var i = startingIndex - 1; i > commonNodeIndex; i--) { + if (symbolContainerDeclPath[i + 1].flags & 1 /* Exported */) { + startingIndex = i; + } else { + break; + } + } + return { potentialPath: symbolContainerDeclPath, startingIndex: startingIndex }; + }; + + Emitter.prototype.emitDottedNameFromDeclPath = function (declPath, startingIndex, lastIndex) { + for (var i = startingIndex; i <= lastIndex; i++) { + if (declPath[i].kind === 32 /* DynamicModule */ || declPath[i].flags & 65536 /* InitializedDynamicModule */) { + this.writeToOutput("exports."); + } else { + this.writeToOutput(this.getModuleName(declPath[i], true) + "."); + } + } + }; + + Emitter.prototype.emitSymbolContainerNameInEnclosingContext = function (pullSymbol) { + var declPathInfo = this.getPotentialDeclPathInfoForEmit(pullSymbol); + var potentialDeclPath = declPathInfo.potentialPath; + var startingIndex = declPathInfo.startingIndex; + + this.emitDottedNameFromDeclPath(potentialDeclPath, startingIndex, potentialDeclPath.length - 1); + }; + + Emitter.prototype.getSymbolForEmit = function (ast) { + var pullSymbol = this.semanticInfoChain.getSymbolForAST(ast); + var pullSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(ast); + if (pullSymbol && pullSymbolAlias) { + var symbolToCompare = TypeScript.isTypesOnlyLocation(ast) ? pullSymbolAlias.getExportAssignedTypeSymbol() : pullSymbolAlias.getExportAssignedValueSymbol(); + + if (pullSymbol == symbolToCompare) { + pullSymbol = pullSymbolAlias; + pullSymbolAlias = null; + } + } + return { symbol: pullSymbol, aliasSymbol: pullSymbolAlias }; + }; + + Emitter.prototype.emitName = function (name, addThis) { + this.emitComments(name, true); + this.recordSourceMappingStart(name); + if (name.text().length > 0) { + var symbolForEmit = this.getSymbolForEmit(name); + var pullSymbol = symbolForEmit.symbol; + if (!pullSymbol) { + pullSymbol = this.semanticInfoChain.anyTypeSymbol; + } + var pullSymbolAlias = symbolForEmit.aliasSymbol; + var pullSymbolKind = pullSymbol.kind; + var isLocalAlias = pullSymbolAlias && (pullSymbolAlias.getDeclarations()[0].getParentDecl() == this.getEnclosingDecl()); + if (addThis && (this.emitState.container !== 6 /* Args */) && pullSymbol) { + var pullSymbolContainer = pullSymbol.getContainer(); + + if (pullSymbolContainer) { + var pullSymbolContainerKind = pullSymbolContainer.kind; + + if (pullSymbolContainerKind === 8 /* Class */) { + if (pullSymbol.anyDeclHasFlag(16 /* Static */)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbolKind === 4096 /* Property */) { + this.emitThis(); + this.writeToOutput("."); + } + } else if (TypeScript.PullHelpers.symbolIsModule(pullSymbolContainer) || pullSymbolContainerKind === 64 /* Enum */ || pullSymbolContainer.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) { + if (pullSymbolKind === 4096 /* Property */ || pullSymbolKind === 67108864 /* EnumMember */) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && pullSymbolKind === 512 /* Variable */ && !pullSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(pullSymbol)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } + } else if (pullSymbolContainerKind === 32 /* DynamicModule */ || pullSymbolContainer.anyDeclHasFlag(65536 /* InitializedDynamicModule */)) { + if (pullSymbolKind === 4096 /* Property */) { + this.writeToOutput("exports."); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !isLocalAlias && !pullSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */) && pullSymbol.kind !== 32768 /* ConstructorMethod */ && pullSymbol.kind !== 8 /* Class */ && pullSymbol.kind !== 64 /* Enum */) { + this.writeToOutput("exports."); + } + } + } + } + + this.writeToOutput(name.text()); + } + + this.recordSourceMappingEnd(name); + this.emitComments(name, false); + }; + + Emitter.prototype.recordSourceMappingNameStart = function (name) { + if (this.sourceMapper) { + var nameIndex = -1; + if (name) { + if (this.sourceMapper.currentNameIndex.length > 0) { + var parentNameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1]; + if (parentNameIndex != -1) { + name = this.sourceMapper.names[parentNameIndex] + "." + name; + } + } + + var nameIndex = this.sourceMapper.names.length - 1; + for (nameIndex; nameIndex >= 0; nameIndex--) { + if (this.sourceMapper.names[nameIndex] == name) { + break; + } + } + + if (nameIndex == -1) { + nameIndex = this.sourceMapper.names.length; + this.sourceMapper.names.push(name); + } + } + this.sourceMapper.currentNameIndex.push(nameIndex); + } + }; + + Emitter.prototype.recordSourceMappingNameEnd = function () { + if (this.sourceMapper) { + this.sourceMapper.currentNameIndex.pop(); + } + }; + + Emitter.prototype.recordSourceMappingStart = function (ast) { + if (this.sourceMapper && TypeScript.isValidAstNode(ast)) { + var lineCol = { line: -1, character: -1 }; + var sourceMapping = new TypeScript.SourceMapping(); + sourceMapping.start.emittedColumn = this.emitState.column; + sourceMapping.start.emittedLine = this.emitState.line; + + var lineMap = this.document.lineMap(); + lineMap.fillLineAndCharacterFromPosition(ast.start(), lineCol); + sourceMapping.start.sourceColumn = lineCol.character; + sourceMapping.start.sourceLine = lineCol.line + 1; + lineMap.fillLineAndCharacterFromPosition(ast.end(), lineCol); + sourceMapping.end.sourceColumn = lineCol.character; + sourceMapping.end.sourceLine = lineCol.line + 1; + + TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedLine)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceLine)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceLine)); + + if (this.sourceMapper.currentNameIndex.length > 0) { + sourceMapping.nameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1]; + } + + var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; + siblings.push(sourceMapping); + this.sourceMapper.currentMappings.push(sourceMapping.childMappings); + this.sourceMapper.increaseMappingLevel(ast); + } + }; + + Emitter.prototype.recordSourceMappingEnd = function (ast) { + if (this.sourceMapper && TypeScript.isValidAstNode(ast)) { + this.sourceMapper.currentMappings.pop(); + + var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; + var sourceMapping = siblings[siblings.length - 1]; + + sourceMapping.end.emittedColumn = this.emitState.column; + sourceMapping.end.emittedLine = this.emitState.line; + + TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedLine)); + + this.sourceMapper.decreaseMappingLevel(ast); + } + }; + + Emitter.prototype.getOutputFiles = function () { + var result = []; + if (this.sourceMapper !== null) { + this.sourceMapper.emitSourceMapping(); + result.push(this.sourceMapper.getOutputFile()); + } + + result.push(this.outfile.getOutputFile()); + return result; + }; + + Emitter.prototype.emitParameterPropertyAndMemberVariableAssignments = function () { + var constructorDecl = getLastConstructor(this.thisClassNode); + + if (constructorDecl && constructorDecl.parameterList) { + for (var i = 0, n = constructorDecl.parameterList.parameters.nonSeparatorCount(); i < n; i++) { + var parameter = constructorDecl.parameterList.parameters.nonSeparatorAt(i); + var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter); + if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) { + this.emitIndent(); + this.recordSourceMappingStart(parameter); + this.writeToOutputWithSourceMapRecord("this." + parameter.identifier.text(), parameter.identifier); + this.writeToOutput(" = "); + this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter.identifier); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(parameter); + } + } + } + + for (var i = 0, n = this.thisClassNode.classElements.childCount(); i < n; i++) { + if (this.thisClassNode.classElements.childAt(i).kind() === 136 /* MemberVariableDeclaration */) { + var varDecl = this.thisClassNode.classElements.childAt(i); + if (!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) { + this.emitIndent(); + this.emitMemberVariableDeclaration(varDecl); + this.writeLineToOutput(""); + } + } + } + }; + + Emitter.prototype.isOnSameLine = function (pos1, pos2) { + var lineMap = this.document.lineMap(); + return lineMap.getLineNumberFromPosition(pos1) === lineMap.getLineNumberFromPosition(pos2); + }; + + Emitter.prototype.emitCommaSeparatedList = function (parent, list, buffer, preserveNewLines) { + if (list === null || list.nonSeparatorCount() === 0) { + return; + } + + var startLine = preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(0).end()); + + if (preserveNewLines) { + this.indenter.increaseIndent(); + } + + if (startLine) { + this.writeLineToOutput(""); + } else { + this.writeToOutput(buffer); + } + + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + var emitNode = list.nonSeparatorAt(i); + + this.emitJavascript(emitNode, startLine); + + if (i < (n - 1)) { + startLine = preserveNewLines && !this.isOnSameLine(emitNode.end(), list.nonSeparatorAt(i + 1).start()); + if (startLine) { + this.writeLineToOutput(","); + } else { + this.writeToOutput(", "); + } + } + } + + if (preserveNewLines) { + this.indenter.decreaseIndent(); + } + + if (preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(list.nonSeparatorCount() - 1).end())) { + this.writeLineToOutput(""); + this.emitIndent(); + } else { + this.writeToOutput(buffer); + } + }; + + Emitter.prototype.emitList = function (list, useNewLineSeparator, startInclusive, endExclusive) { + if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; } + if (typeof startInclusive === "undefined") { startInclusive = 0; } + if (typeof endExclusive === "undefined") { endExclusive = list.childCount(); } + if (list === null) { + return; + } + + this.emitComments(list, true); + var lastEmittedNode = null; + + for (var i = startInclusive; i < endExclusive; i++) { + var node = list.childAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + if (useNewLineSeparator) { + this.writeLineToOutput(""); + } + + lastEmittedNode = node; + } + } + + this.emitComments(list, false); + }; + + Emitter.prototype.emitSeparatedList = function (list, useNewLineSeparator, startInclusive, endExclusive) { + if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; } + if (typeof startInclusive === "undefined") { startInclusive = 0; } + if (typeof endExclusive === "undefined") { endExclusive = list.nonSeparatorCount(); } + if (list === null) { + return; + } + + this.emitComments(list, true); + var lastEmittedNode = null; + + for (var i = startInclusive; i < endExclusive; i++) { + var node = list.nonSeparatorAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + if (useNewLineSeparator) { + this.writeLineToOutput(""); + } + + lastEmittedNode = node; + } + } + + this.emitComments(list, false); + }; + + Emitter.prototype.isDirectivePrologueElement = function (node) { + if (node.kind() === 149 /* ExpressionStatement */) { + var exprStatement = node; + return exprStatement.expression.kind() === 14 /* StringLiteral */; + } + + return false; + }; + + Emitter.prototype.emitSpaceBetweenConstructs = function (node1, node2) { + if (node1 === null || node2 === null) { + return; + } + + if (node1.start() === -1 || node1.end() === -1 || node2.start() === -1 || node2.end() === -1) { + return; + } + + var lineMap = this.document.lineMap(); + var node1EndLine = lineMap.getLineNumberFromPosition(node1.end()); + var node2StartLine = lineMap.getLineNumberFromPosition(node2.start()); + + if ((node2StartLine - node1EndLine) > 1) { + this.writeLineToOutput("", true); + } + }; + + Emitter.prototype.getCopyrightComments = function () { + var preComments = this.copyrightElement.preComments(); + if (preComments) { + var lineMap = this.document.lineMap(); + + var copyrightComments = []; + var lastComment = null; + + for (var i = 0, n = preComments.length; i < n; i++) { + var comment = preComments[i]; + + if (lastComment) { + var lastCommentLine = lineMap.getLineNumberFromPosition(lastComment.end()); + var commentLine = lineMap.getLineNumberFromPosition(comment.start()); + + if (commentLine >= lastCommentLine + 2) { + return copyrightComments; + } + } + + copyrightComments.push(comment); + lastComment = comment; + } + + var lastCommentLine = lineMap.getLineNumberFromPosition(TypeScript.ArrayUtilities.last(copyrightComments).end()); + var astLine = lineMap.getLineNumberFromPosition(this.copyrightElement.start()); + if (astLine >= lastCommentLine + 2) { + return copyrightComments; + } + } + + return []; + }; + + Emitter.prototype.emitPossibleCopyrightHeaders = function (script) { + var list = script.moduleElements; + if (list.childCount() > 0) { + var firstElement = list.childAt(0); + + this.copyrightElement = firstElement; + this.emitCommentsArray(this.getCopyrightComments(), false); + } + }; + + Emitter.prototype.emitScriptElements = function (sourceUnit) { + var list = sourceUnit.moduleElements; + + this.emitPossibleCopyrightHeaders(sourceUnit); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var node = list.childAt(i); + + if (!this.isDirectivePrologueElement(node)) { + break; + } + + this.emitJavascript(node, true); + this.writeLineToOutput(""); + } + + this.emitPrologue(sourceUnit); + + var isExternalModule = this.document.isExternalModule(); + var isNonElidedExternalModule = isExternalModule && !TypeScript.scriptIsElided(sourceUnit); + if (isNonElidedExternalModule) { + this.recordSourceMappingStart(sourceUnit); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + var dependencyList = "[\"require\", \"exports\""; + var importList = "require, exports"; + + var importAndDependencyList = this.getModuleImportAndDependencyList(sourceUnit); + importList += importAndDependencyList.importList; + dependencyList += importAndDependencyList.dependencyList + "]"; + + this.writeLineToOutput("define(" + dependencyList + "," + " function(" + importList + ") {"); + } + } + + if (isExternalModule) { + var temp = this.setContainer(2 /* DynamicModule */); + + var svModuleName = this.moduleName; + this.moduleName = sourceUnit.fileName(); + if (TypeScript.isTSFile(this.moduleName)) { + this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length); + } + + this.setExportAssignmentIdentifier(null); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + this.indenter.increaseIndent(); + } + + var externalModule = this.semanticInfoChain.getDeclForAST(this.document.sourceUnit()); + + if (TypeScript.hasFlag(externalModule.flags, 262144 /* MustCaptureThis */)) { + this.writeCaptureThisStatement(sourceUnit); + } + + this.pushDecl(externalModule); + } + + this.emitList(list, true, i, n); + + if (isExternalModule) { + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + this.indenter.decreaseIndent(); + } + + if (isNonElidedExternalModule) { + var exportAssignmentIdentifier = this.getExportAssignmentIdentifier(); + var exportAssignmentValueSymbol = externalModule.getSymbol().getExportAssignedValueSymbol(); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + if (exportAssignmentIdentifier && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) { + this.indenter.increaseIndent(); + this.emitIndent(); + this.writeLineToOutput("return " + exportAssignmentIdentifier + ";"); + this.indenter.decreaseIndent(); + } + this.writeToOutput("});"); + } else if (exportAssignmentIdentifier && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) { + this.emitIndent(); + this.writeToOutput("module.exports = " + exportAssignmentIdentifier + ";"); + } + + this.recordSourceMappingEnd(sourceUnit); + this.writeLineToOutput(""); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + this.popDecl(externalModule); + } + }; + + Emitter.prototype.emitConstructorStatements = function (funcDecl) { + var list = funcDecl.block.statements; + + if (list === null) { + return; + } + + this.emitComments(list, true); + + var emitPropertyAssignmentsAfterSuperCall = TypeScript.getExtendsHeritageClause(this.thisClassNode.heritageClauses) !== null; + var propertyAssignmentIndex = emitPropertyAssignmentsAfterSuperCall ? 1 : 0; + var lastEmittedNode = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + if (i === propertyAssignmentIndex) { + this.emitParameterPropertyAndMemberVariableAssignments(); + } + + var node = list.childAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + this.writeLineToOutput(""); + + lastEmittedNode = node; + } + } + + if (i === propertyAssignmentIndex) { + this.emitParameterPropertyAndMemberVariableAssignments(); + } + + this.emitComments(list, false); + }; + + Emitter.prototype.emitJavascript = function (ast, startLine) { + if (ast === null) { + return; + } + + if (startLine && this.indenter.indentAmt > 0) { + this.emitIndent(); + } + + this.emit(ast); + }; + + Emitter.prototype.emitAccessorMemberDeclaration = function (funcDecl, name, className, isProto) { + if (funcDecl.kind() !== 139 /* GetAccessor */) { + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain); + if (accessorSymbol.getGetter()) { + return; + } + } + + this.emitIndent(); + this.recordSourceMappingStart(funcDecl); + + this.writeToOutput("Object.defineProperty(" + className); + if (isProto) { + this.writeToOutput(".prototype, "); + } else { + this.writeToOutput(", "); + } + + var functionName = name.text(); + if (TypeScript.isQuoted(functionName)) { + this.writeToOutput(functionName); + } else { + this.writeToOutput('"' + functionName + '"'); + } + + this.writeLineToOutput(", {"); + + this.indenter.increaseIndent(); + + var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain); + if (accessors.getter) { + this.emitIndent(); + this.recordSourceMappingStart(accessors.getter); + this.emitComments(accessors.getter, true); + this.writeToOutput("get: "); + this.emitAccessorBody(accessors.getter, accessors.getter.parameterList, accessors.getter.block); + this.writeLineToOutput(","); + } + + if (accessors.setter) { + this.emitIndent(); + this.recordSourceMappingStart(accessors.setter); + this.emitComments(accessors.setter, true); + this.writeToOutput("set: "); + this.emitAccessorBody(accessors.setter, accessors.setter.parameterList, accessors.setter.block); + this.writeLineToOutput(","); + } + + this.emitIndent(); + this.writeLineToOutput("enumerable: true,"); + this.emitIndent(); + this.writeLineToOutput("configurable: true"); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("});"); + this.recordSourceMappingEnd(funcDecl); + }; + + Emitter.prototype.emitAccessorBody = function (funcDecl, parameterList, block) { + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, funcDecl, parameters, block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitClass = function (classDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(classDecl); + this.pushDecl(pullDecl); + + var svClassNode = this.thisClassNode; + this.thisClassNode = classDecl; + var className = classDecl.identifier.text(); + this.emitComments(classDecl, true); + var temp = this.setContainer(3 /* Class */); + + this.recordSourceMappingStart(classDecl); + this.writeToOutput("var " + className); + + var hasBaseClass = TypeScript.getExtendsHeritageClause(classDecl.heritageClauses) !== null; + var baseTypeReference = null; + var varDecl = null; + + if (hasBaseClass) { + this.writeLineToOutput(" = (function (_super) {"); + } else { + this.writeLineToOutput(" = (function () {"); + } + + this.recordSourceMappingNameStart(className); + this.indenter.increaseIndent(); + + if (hasBaseClass) { + baseTypeReference = TypeScript.getExtendsHeritageClause(classDecl.heritageClauses).typeNames.nonSeparatorAt(0); + this.emitIndent(); + this.writeLineToOutput("__extends(" + className + ", _super);"); + } + + this.emitIndent(); + + var constrDecl = getLastConstructor(classDecl); + + if (constrDecl) { + this.emit(constrDecl); + this.writeLineToOutput(""); + } else { + this.recordSourceMappingStart(classDecl); + + this.indenter.increaseIndent(); + this.writeLineToOutput("function " + classDecl.identifier.text() + "() {"); + this.recordSourceMappingNameStart("constructor"); + if (hasBaseClass) { + this.emitIndent(); + this.writeLineToOutput("_super.apply(this, arguments);"); + } + + if (this.shouldCaptureThis(classDecl)) { + this.writeCaptureThisStatement(classDecl); + } + + this.emitParameterPropertyAndMemberVariableAssignments(); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("}"); + + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(classDecl); + } + + this.emitClassMembers(classDecl); + + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("return " + className + ";", classDecl.closeBraceToken); + this.writeLineToOutput(""); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingStart(classDecl); + this.writeToOutput(")("); + if (hasBaseClass) { + this.emitJavascript(baseTypeReference, false); + } + this.writeToOutput(");"); + this.recordSourceMappingEnd(classDecl); + + if ((temp === 1 /* Module */ || temp === 2 /* DynamicModule */) && TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + this.writeLineToOutput(""); + this.emitIndent(); + var modName = temp === 1 /* Module */ ? this.moduleName : "exports"; + this.writeToOutputWithSourceMapRecord(modName + "." + className + " = " + className + ";", classDecl); + } + + this.recordSourceMappingEnd(classDecl); + this.emitComments(classDecl, false); + this.setContainer(temp); + this.thisClassNode = svClassNode; + + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitClassMembers = function (classDecl) { + var lastEmittedMember = null; + + for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) { + var memberDecl = classDecl.classElements.childAt(i); + + if (memberDecl.kind() === 139 /* GetAccessor */) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + var getter = memberDecl; + this.emitAccessorMemberDeclaration(getter, getter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(getter.modifiers, 16 /* Static */)); + lastEmittedMember = memberDecl; + } else if (memberDecl.kind() === 140 /* SetAccessor */) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + var setter = memberDecl; + this.emitAccessorMemberDeclaration(setter, setter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(setter.modifiers, 16 /* Static */)); + lastEmittedMember = memberDecl; + } else if (memberDecl.kind() === 135 /* MemberFunctionDeclaration */) { + var memberFunction = memberDecl; + + if (memberFunction.block) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + + this.emitClassMemberFunctionDeclaration(classDecl, memberFunction); + lastEmittedMember = memberDecl; + } + } + } + + for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) { + var memberDecl = classDecl.classElements.childAt(i); + + if (memberDecl.kind() === 136 /* MemberVariableDeclaration */) { + var varDecl = memberDecl; + + if (TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) { + this.emitSpaceBetweenConstructs(lastEmittedMember, varDecl); + + this.emitIndent(); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.variableDeclarator.propertyName.text(); + if (TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */) { + this.writeToOutput(classDecl.identifier.text() + "[" + varDeclName + "]"); + } else { + this.writeToOutput(classDecl.identifier.text() + "." + varDeclName); + } + + this.emit(varDecl.variableDeclarator.equalsValueClause); + + this.recordSourceMappingEnd(varDecl); + this.writeLineToOutput(";"); + + lastEmittedMember = varDecl; + } + } + } + }; + + Emitter.prototype.emitClassMemberFunctionDeclaration = function (classDecl, funcDecl) { + this.emitIndent(); + this.recordSourceMappingStart(funcDecl); + this.emitComments(funcDecl, true); + var functionName = funcDecl.propertyName.text(); + + this.writeToOutput(classDecl.identifier.text()); + + if (!TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) { + this.writeToOutput(".prototype"); + } + + if (TypeScript.isQuoted(functionName) || funcDecl.propertyName.kind() !== 11 /* IdentifierName */) { + this.writeToOutput("[" + functionName + "] = "); + } else { + this.writeToOutput("." + functionName + " = "); + } + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + this.emitParameterList(funcDecl.callSignature.parameterList); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionBodyStatements(funcDecl.propertyName.text(), funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.recordSourceMappingEnd(funcDecl); + this.popDecl(pullDecl); + + this.writeLineToOutput(";"); + }; + + Emitter.prototype.requiresExtendsBlock = function (moduleElements) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + + if (moduleElement.kind() === 130 /* ModuleDeclaration */) { + var moduleAST = moduleElement; + + if (!TypeScript.hasModifier(moduleAST.modifiers, 8 /* Ambient */) && this.requiresExtendsBlock(moduleAST.moduleElements)) { + return true; + } + } else if (moduleElement.kind() === 131 /* ClassDeclaration */) { + var classDeclaration = moduleElement; + + if (!TypeScript.hasModifier(classDeclaration.modifiers, 8 /* Ambient */) && TypeScript.getExtendsHeritageClause(classDeclaration.heritageClauses) !== null) { + return true; + } + } + } + + return false; + }; + + Emitter.prototype.emitPrologue = function (sourceUnit) { + if (!this.extendsPrologueEmitted) { + if (this.requiresExtendsBlock(sourceUnit.moduleElements)) { + this.extendsPrologueEmitted = true; + this.writeLineToOutput("var __extends = this.__extends || function (d, b) {"); + this.writeLineToOutput(" for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];"); + this.writeLineToOutput(" function __() { this.constructor = d; }"); + this.writeLineToOutput(" __.prototype = b.prototype;"); + this.writeLineToOutput(" d.prototype = new __();"); + this.writeLineToOutput("};"); + } + } + + if (!this.globalThisCapturePrologueEmitted) { + if (this.shouldCaptureThis(sourceUnit)) { + this.globalThisCapturePrologueEmitted = true; + this.writeLineToOutput(this.captureThisStmtString); + } + } + }; + + Emitter.prototype.emitThis = function () { + if (!this.inWithBlock && this.inArrowFunction) { + this.writeToOutput("_this"); + } else { + this.writeToOutput("this"); + } + }; + + Emitter.prototype.emitBlockOrStatement = function (node) { + if (node.kind() === 146 /* Block */) { + this.emit(node); + } else { + this.writeLineToOutput(""); + this.indenter.increaseIndent(); + this.emitJavascript(node, true); + this.indenter.decreaseIndent(); + } + }; + + Emitter.prototype.emitLiteralExpression = function (expression) { + switch (expression.kind()) { + case 32 /* NullKeyword */: + this.writeToOutputWithSourceMapRecord("null", expression); + break; + case 24 /* FalseKeyword */: + this.writeToOutputWithSourceMapRecord("false", expression); + break; + case 37 /* TrueKeyword */: + this.writeToOutputWithSourceMapRecord("true", expression); + break; + default: + throw TypeScript.Errors.abstract(); + } + }; + + Emitter.prototype.emitThisExpression = function (expression) { + if (!this.inWithBlock && this.inArrowFunction) { + this.writeToOutputWithSourceMapRecord("_this", expression); + } else { + this.writeToOutputWithSourceMapRecord("this", expression); + } + }; + + Emitter.prototype.emitSuperExpression = function (expression) { + this.writeToOutputWithSourceMapRecord("_super.prototype", expression); + }; + + Emitter.prototype.emitParenthesizedExpression = function (parenthesizedExpression) { + if (parenthesizedExpression.expression.kind() === 220 /* CastExpression */ && parenthesizedExpression.openParenTrailingComments === null) { + this.emit(parenthesizedExpression.expression); + } else { + this.recordSourceMappingStart(parenthesizedExpression); + this.writeToOutput("("); + this.emitCommentsArray(parenthesizedExpression.openParenTrailingComments, false); + this.emit(parenthesizedExpression.expression); + this.writeToOutput(")"); + this.recordSourceMappingEnd(parenthesizedExpression); + } + }; + + Emitter.prototype.emitCastExpression = function (expression) { + this.emit(expression.expression); + }; + + Emitter.prototype.emitPrefixUnaryExpression = function (expression) { + var nodeType = expression.kind(); + + this.recordSourceMappingStart(expression); + switch (nodeType) { + case 167 /* LogicalNotExpression */: + this.writeToOutput("!"); + this.emit(expression.operand); + break; + case 166 /* BitwiseNotExpression */: + this.writeToOutput("~"); + this.emit(expression.operand); + break; + case 165 /* NegateExpression */: + this.writeToOutput("-"); + if (expression.operand.kind() === 165 /* NegateExpression */ || expression.operand.kind() === 169 /* PreDecrementExpression */) { + this.writeToOutput(" "); + } + this.emit(expression.operand); + break; + case 164 /* PlusExpression */: + this.writeToOutput("+"); + if (expression.operand.kind() === 164 /* PlusExpression */ || expression.operand.kind() === 168 /* PreIncrementExpression */) { + this.writeToOutput(" "); + } + this.emit(expression.operand); + break; + case 168 /* PreIncrementExpression */: + this.writeToOutput("++"); + this.emit(expression.operand); + break; + case 169 /* PreDecrementExpression */: + this.writeToOutput("--"); + this.emit(expression.operand); + break; + default: + throw TypeScript.Errors.abstract(); + } + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitPostfixUnaryExpression = function (expression) { + var nodeType = expression.kind(); + + this.recordSourceMappingStart(expression); + switch (nodeType) { + case 210 /* PostIncrementExpression */: + this.emit(expression.operand); + this.writeToOutput("++"); + break; + case 211 /* PostDecrementExpression */: + this.emit(expression.operand); + this.writeToOutput("--"); + break; + default: + throw TypeScript.Errors.abstract(); + } + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitTypeOfExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("typeof "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitDeleteExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("delete "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitVoidExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("void "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.canEmitDottedNameMemberAccessExpression = function (expression) { + var memberExpressionNodeType = expression.expression.kind(); + + if (memberExpressionNodeType == 11 /* IdentifierName */ || memberExpressionNodeType == 212 /* MemberAccessExpression */) { + var memberAccessSymbol = this.getSymbolForEmit(expression).symbol; + var memberAccessExpressionSymbol = this.getSymbolForEmit(expression.expression).symbol; + if (memberAccessSymbol && memberAccessExpressionSymbol && !this.semanticInfoChain.getAliasSymbolForAST(expression.expression) && (TypeScript.PullHelpers.symbolIsModule(memberAccessExpressionSymbol) || memberAccessExpressionSymbol.kind === 64 /* Enum */ || memberAccessExpressionSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */))) { + var memberAccessSymbolKind = memberAccessSymbol.kind; + if (memberAccessSymbolKind === 4096 /* Property */ || memberAccessSymbolKind === 67108864 /* EnumMember */ || (memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && memberAccessSymbolKind === 512 /* Variable */ && !memberAccessSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) || ((memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(memberAccessSymbol)))) { + if (memberExpressionNodeType == 212 /* MemberAccessExpression */) { + return this.canEmitDottedNameMemberAccessExpression(expression.expression); + } + + return true; + } + } + } + + return false; + }; + + Emitter.prototype.emitDottedNameMemberAccessExpressionWorker = function (expression, potentialPath, startingIndex, lastIndex) { + this.recordSourceMappingStart(expression); + if (expression.expression.kind() == 212 /* MemberAccessExpression */) { + this.emitDottedNameMemberAccessExpressionRecurse(expression.expression, potentialPath, startingIndex, lastIndex - 1); + } else { + this.emitComments(expression.expression, true); + this.recordSourceMappingStart(expression.expression); + + this.emitDottedNameFromDeclPath(potentialPath, startingIndex, lastIndex - 2); + + this.writeToOutput(expression.expression.text()); + + this.recordSourceMappingEnd(expression.expression); + this.emitComments(expression.expression, false); + } + + this.writeToOutput("."); + this.emitName(expression.name, false); + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitDottedNameMemberAccessExpressionRecurse = function (expression, potentialPath, startingIndex, lastIndex) { + this.emitComments(expression, true); + + if (lastIndex - startingIndex < 1) { + startingIndex = lastIndex - 1; + TypeScript.Debug.assert(startingIndex >= 0); + } + + this.emitDottedNameMemberAccessExpressionWorker(expression, potentialPath, startingIndex, lastIndex); + this.emitComments(expression, false); + }; + + Emitter.prototype.emitDottedNameMemberAccessExpression = function (expression) { + var memberAccessSymbol = this.getSymbolForEmit(expression).symbol; + + var potentialDeclInfo = this.getPotentialDeclPathInfoForEmit(memberAccessSymbol); + this.emitDottedNameMemberAccessExpressionWorker(expression, potentialDeclInfo.potentialPath, potentialDeclInfo.startingIndex, potentialDeclInfo.potentialPath.length); + }; + + Emitter.prototype.emitMemberAccessExpression = function (expression) { + if (!this.tryEmitConstant(expression)) { + if (this.canEmitDottedNameMemberAccessExpression(expression)) { + this.emitDottedNameMemberAccessExpression(expression); + } else { + this.recordSourceMappingStart(expression); + this.emit(expression.expression); + this.writeToOutput("."); + this.emitName(expression.name, false); + this.recordSourceMappingEnd(expression); + } + } + }; + + Emitter.prototype.emitQualifiedName = function (name) { + this.recordSourceMappingStart(name); + + this.emit(name.left); + this.writeToOutput("."); + this.emitName(name.right, false); + + this.recordSourceMappingEnd(name); + }; + + Emitter.prototype.emitBinaryExpression = function (expression) { + this.recordSourceMappingStart(expression); + switch (expression.kind()) { + case 173 /* CommaExpression */: + this.emit(expression.left); + this.writeToOutput(", "); + this.emit(expression.right); + break; + default: { + this.emit(expression.left); + var binOp = TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(expression.kind())); + if (binOp === "instanceof") { + this.writeToOutput(" instanceof "); + } else if (binOp === "in") { + this.writeToOutput(" in "); + } else { + this.writeToOutput(" " + binOp + " "); + } + this.emit(expression.right); + } + } + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitSimplePropertyAssignment = function (property) { + this.recordSourceMappingStart(property); + this.emit(property.propertyName); + this.writeToOutput(": "); + this.emit(property.expression); + this.recordSourceMappingEnd(property); + }; + + Emitter.prototype.emitFunctionPropertyAssignment = function (funcProp) { + this.recordSourceMappingStart(funcProp); + + this.emit(funcProp.propertyName); + this.writeToOutput(": "); + + var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcProp); + + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + var funcName = funcProp.propertyName; + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcProp); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcProp); + this.writeToOutput("function "); + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(funcProp.callSignature.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcProp.propertyName.text(), funcProp, parameters, funcProp.block, null); + + this.recordSourceMappingEnd(funcProp); + + this.recordSourceMappingEnd(funcProp); + + this.emitComments(funcProp, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + + this.recordSourceMappingEnd(funcProp); + }; + + Emitter.prototype.emitConditionalExpression = function (expression) { + this.emit(expression.condition); + this.writeToOutput(" ? "); + this.emit(expression.whenTrue); + this.writeToOutput(" : "); + this.emit(expression.whenFalse); + }; + + Emitter.prototype.emitThrowStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("throw "); + this.emit(statement.expression); + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitExpressionStatement = function (statement) { + var isArrowExpression = statement.expression.kind() === 219 /* SimpleArrowFunctionExpression */ || statement.expression.kind() === 218 /* ParenthesizedArrowFunctionExpression */; + + this.recordSourceMappingStart(statement); + if (isArrowExpression) { + this.writeToOutput("("); + } + + this.emit(statement.expression); + + if (isArrowExpression) { + this.writeToOutput(")"); + } + + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitLabeledStatement = function (statement) { + this.writeToOutputWithSourceMapRecord(statement.identifier.text(), statement.identifier); + this.writeLineToOutput(":"); + this.emitJavascript(statement.statement, true); + }; + + Emitter.prototype.emitBlock = function (block) { + this.recordSourceMappingStart(block); + this.writeLineToOutput(" {"); + this.indenter.increaseIndent(); + if (block.statements) { + this.emitList(block.statements); + } + this.emitCommentsArray(block.closeBraceLeadingComments, false); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutput("}"); + this.recordSourceMappingEnd(block); + }; + + Emitter.prototype.emitBreakStatement = function (jump) { + this.recordSourceMappingStart(jump); + this.writeToOutput("break"); + + if (jump.identifier) { + this.writeToOutput(" " + jump.identifier.text()); + } + + this.recordSourceMappingEnd(jump); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitContinueStatement = function (jump) { + this.recordSourceMappingStart(jump); + this.writeToOutput("continue"); + + if (jump.identifier) { + this.writeToOutput(" " + jump.identifier.text()); + } + + this.recordSourceMappingEnd(jump); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitWhileStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("while ("); + this.emit(statement.condition); + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitDoStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("do"); + this.emitBlockOrStatement(statement.statement); + this.writeToOutputWithSourceMapRecord(" while", statement.whileKeyword); + this.writeToOutput('('); + this.emit(statement.condition); + this.writeToOutput(")"); + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitIfStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("if ("); + this.emit(statement.condition); + this.writeToOutput(")"); + + this.emitBlockOrStatement(statement.statement); + + if (statement.elseClause) { + if (statement.statement.kind() !== 146 /* Block */) { + this.writeLineToOutput(""); + this.emitIndent(); + } else { + this.writeToOutput(" "); + } + + this.emit(statement.elseClause); + } + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitElseClause = function (elseClause) { + if (elseClause.statement.kind() === 147 /* IfStatement */) { + this.writeToOutput("else "); + this.emit(elseClause.statement); + } else { + this.writeToOutput("else"); + this.emitBlockOrStatement(elseClause.statement); + } + }; + + Emitter.prototype.emitReturnStatement = function (statement) { + this.recordSourceMappingStart(statement); + if (statement.expression) { + this.writeToOutput("return "); + this.emit(statement.expression); + } else { + this.writeToOutput("return"); + } + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitForInStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("for ("); + if (statement.left) { + this.emit(statement.left); + } else { + this.emit(statement.variableDeclaration); + } + this.writeToOutput(" in "); + this.emit(statement.expression); + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitForStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("for ("); + if (statement.variableDeclaration) { + this.emit(statement.variableDeclaration); + } else if (statement.initializer) { + this.emit(statement.initializer); + } + + this.writeToOutput("; "); + this.emitJavascript(statement.condition, false); + this.writeToOutput(";"); + if (statement.incrementor) { + this.writeToOutput(" "); + this.emitJavascript(statement.incrementor, false); + } + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitWithStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("with ("); + if (statement.condition) { + this.emit(statement.condition); + } + + this.writeToOutput(")"); + var prevInWithBlock = this.inWithBlock; + this.inWithBlock = true; + this.emitBlockOrStatement(statement.statement); + this.inWithBlock = prevInWithBlock; + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitSwitchStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("switch ("); + this.emit(statement.expression); + this.recordSourceMappingStart(statement.closeParenToken); + this.writeToOutput(")"); + this.recordSourceMappingEnd(statement.closeParenToken); + this.writeLineToOutput(" {"); + this.indenter.increaseIndent(); + this.emitList(statement.switchClauses, false); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutput("}"); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitCaseSwitchClause = function (clause) { + this.recordSourceMappingStart(clause); + this.writeToOutput("case "); + this.emit(clause.expression); + this.writeToOutput(":"); + + this.emitSwitchClauseBody(clause.statements); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitSwitchClauseBody = function (body) { + if (body.childCount() === 1 && body.childAt(0).kind() === 146 /* Block */) { + this.emit(body.childAt(0)); + this.writeLineToOutput(""); + } else { + this.writeLineToOutput(""); + this.indenter.increaseIndent(); + this.emit(body); + this.indenter.decreaseIndent(); + } + }; + + Emitter.prototype.emitDefaultSwitchClause = function (clause) { + this.recordSourceMappingStart(clause); + this.writeToOutput("default:"); + + this.emitSwitchClauseBody(clause.statements); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitTryStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("try "); + this.emit(statement.block); + this.emitJavascript(statement.catchClause, false); + + if (statement.finallyClause) { + this.emit(statement.finallyClause); + } + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitCatchClause = function (clause) { + this.writeToOutput(" "); + this.recordSourceMappingStart(clause); + this.writeToOutput("catch ("); + this.emit(clause.identifier); + this.writeToOutput(")"); + this.emit(clause.block); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitFinallyClause = function (clause) { + this.writeToOutput(" finally"); + this.emit(clause.block); + }; + + Emitter.prototype.emitDebuggerStatement = function (statement) { + this.writeToOutputWithSourceMapRecord("debugger", statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitNumericLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitRegularExpressionLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitStringLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitEqualsValueClause = function (clause) { + this.writeToOutput(" = "); + this.emit(clause.value); + }; + + Emitter.prototype.emitParameter = function (parameter) { + this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter); + }; + + Emitter.prototype.emitConstructorDeclaration = function (declaration) { + if (declaration.block) { + this.emitConstructor(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitFunctionDeclaration = function (declaration) { + return declaration.preComments() !== null || (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null); + }; + + Emitter.prototype.emitFunctionDeclaration = function (declaration) { + if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null) { + this.emitFunction(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.emitSourceUnit = function (sourceUnit) { + if (!this.document.isDeclareFile()) { + var pullDecl = this.semanticInfoChain.getDeclForAST(sourceUnit); + this.pushDecl(pullDecl); + this.emitScriptElements(sourceUnit); + this.popDecl(pullDecl); + } + }; + + Emitter.prototype.shouldEmitEnumDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.enumIsElided(declaration); + }; + + Emitter.prototype.emitEnumDeclaration = function (declaration) { + if (!TypeScript.enumIsElided(declaration)) { + this.emitComments(declaration, true); + this.emitEnum(declaration); + this.emitComments(declaration, false); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitModuleDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.moduleIsElided(declaration); + }; + + Emitter.prototype.emitModuleDeclaration = function (declaration) { + if (!TypeScript.moduleIsElided(declaration)) { + this.emitModuleDeclarationWorker(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitClassDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */); + }; + + Emitter.prototype.emitClassDeclaration = function (declaration) { + if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) { + this.emitClass(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitInterfaceDeclaration = function (declaration) { + return declaration.preComments() !== null; + }; + + Emitter.prototype.emitInterfaceDeclaration = function (declaration) { + this.emitComments(declaration, true, true); + }; + + Emitter.prototype.firstVariableDeclarator = function (statement) { + return statement.declaration.declarators.nonSeparatorAt(0); + }; + + Emitter.prototype.isNotAmbientOrHasInitializer = function (variableStatement) { + return !TypeScript.hasModifier(variableStatement.modifiers, 8 /* Ambient */) || this.firstVariableDeclarator(variableStatement).equalsValueClause !== null; + }; + + Emitter.prototype.shouldEmitVariableStatement = function (statement) { + return statement.preComments() !== null || this.isNotAmbientOrHasInitializer(statement); + }; + + Emitter.prototype.emitVariableStatement = function (statement) { + if (this.isNotAmbientOrHasInitializer(statement)) { + this.emitComments(statement, true); + this.emit(statement.declaration); + this.writeToOutput(";"); + this.emitComments(statement, false); + } else { + this.emitComments(statement, true, true); + } + }; + + Emitter.prototype.emitGenericType = function (type) { + this.emit(type.name); + }; + + Emitter.prototype.shouldEmit = function (ast) { + if (!ast) { + return false; + } + + switch (ast.kind()) { + case 133 /* ImportDeclaration */: + return this.shouldEmitImportDeclaration(ast); + case 131 /* ClassDeclaration */: + return this.shouldEmitClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.shouldEmitInterfaceDeclaration(ast); + case 129 /* FunctionDeclaration */: + return this.shouldEmitFunctionDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.shouldEmitModuleDeclaration(ast); + case 148 /* VariableStatement */: + return this.shouldEmitVariableStatement(ast); + case 223 /* OmittedExpression */: + return false; + case 132 /* EnumDeclaration */: + return this.shouldEmitEnumDeclaration(ast); + } + + return true; + }; + + Emitter.prototype.emit = function (ast) { + if (!ast) { + return; + } + + switch (ast.kind()) { + case 2 /* SeparatedList */: + return this.emitSeparatedList(ast); + case 1 /* List */: + return this.emitList(ast); + case 120 /* SourceUnit */: + return this.emitSourceUnit(ast); + case 133 /* ImportDeclaration */: + return this.emitImportDeclaration(ast); + case 134 /* ExportAssignment */: + return this.setExportAssignmentIdentifier(ast.identifier.text()); + case 131 /* ClassDeclaration */: + return this.emitClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.emitInterfaceDeclaration(ast); + case 11 /* IdentifierName */: + return this.emitName(ast, true); + case 225 /* VariableDeclarator */: + return this.emitVariableDeclarator(ast); + case 219 /* SimpleArrowFunctionExpression */: + return this.emitSimpleArrowFunctionExpression(ast); + case 218 /* ParenthesizedArrowFunctionExpression */: + return this.emitParenthesizedArrowFunctionExpression(ast); + case 129 /* FunctionDeclaration */: + return this.emitFunctionDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.emitModuleDeclaration(ast); + case 224 /* VariableDeclaration */: + return this.emitVariableDeclaration(ast); + case 126 /* GenericType */: + return this.emitGenericType(ast); + case 137 /* ConstructorDeclaration */: + return this.emitConstructorDeclaration(ast); + case 132 /* EnumDeclaration */: + return this.emitEnumDeclaration(ast); + case 243 /* EnumElement */: + return this.emitEnumElement(ast); + case 222 /* FunctionExpression */: + return this.emitFunctionExpression(ast); + case 148 /* VariableStatement */: + return this.emitVariableStatement(ast); + } + + this.emitComments(ast, true); + this.emitWorker(ast); + this.emitComments(ast, false); + }; + + Emitter.prototype.emitWorker = function (ast) { + if (!ast) { + return; + } + + switch (ast.kind()) { + case 13 /* NumericLiteral */: + return this.emitNumericLiteral(ast); + case 12 /* RegularExpressionLiteral */: + return this.emitRegularExpressionLiteral(ast); + case 14 /* StringLiteral */: + return this.emitStringLiteral(ast); + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + case 37 /* TrueKeyword */: + return this.emitLiteralExpression(ast); + case 35 /* ThisKeyword */: + return this.emitThisExpression(ast); + case 50 /* SuperKeyword */: + return this.emitSuperExpression(ast); + case 217 /* ParenthesizedExpression */: + return this.emitParenthesizedExpression(ast); + case 214 /* ArrayLiteralExpression */: + return this.emitArrayLiteralExpression(ast); + case 211 /* PostDecrementExpression */: + case 210 /* PostIncrementExpression */: + return this.emitPostfixUnaryExpression(ast); + case 167 /* LogicalNotExpression */: + case 166 /* BitwiseNotExpression */: + case 165 /* NegateExpression */: + case 164 /* PlusExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return this.emitPrefixUnaryExpression(ast); + case 213 /* InvocationExpression */: + return this.emitInvocationExpression(ast); + case 221 /* ElementAccessExpression */: + return this.emitElementAccessExpression(ast); + case 212 /* MemberAccessExpression */: + return this.emitMemberAccessExpression(ast); + case 121 /* QualifiedName */: + return this.emitQualifiedName(ast); + case 173 /* CommaExpression */: + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 187 /* LogicalOrExpression */: + case 188 /* LogicalAndExpression */: + case 189 /* BitwiseOrExpression */: + case 190 /* BitwiseExclusiveOrExpression */: + case 191 /* BitwiseAndExpression */: + case 192 /* EqualsWithTypeConversionExpression */: + case 193 /* NotEqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + case 196 /* LessThanExpression */: + case 197 /* GreaterThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 200 /* InstanceOfExpression */: + case 201 /* InExpression */: + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + case 208 /* AddExpression */: + case 209 /* SubtractExpression */: + return this.emitBinaryExpression(ast); + case 186 /* ConditionalExpression */: + return this.emitConditionalExpression(ast); + case 232 /* EqualsValueClause */: + return this.emitEqualsValueClause(ast); + case 242 /* Parameter */: + return this.emitParameter(ast); + case 146 /* Block */: + return this.emitBlock(ast); + case 235 /* ElseClause */: + return this.emitElseClause(ast); + case 147 /* IfStatement */: + return this.emitIfStatement(ast); + case 149 /* ExpressionStatement */: + return this.emitExpressionStatement(ast); + case 139 /* GetAccessor */: + return this.emitGetAccessor(ast); + case 140 /* SetAccessor */: + return this.emitSetAccessor(ast); + case 157 /* ThrowStatement */: + return this.emitThrowStatement(ast); + case 150 /* ReturnStatement */: + return this.emitReturnStatement(ast); + case 216 /* ObjectCreationExpression */: + return this.emitObjectCreationExpression(ast); + case 151 /* SwitchStatement */: + return this.emitSwitchStatement(ast); + case 233 /* CaseSwitchClause */: + return this.emitCaseSwitchClause(ast); + case 234 /* DefaultSwitchClause */: + return this.emitDefaultSwitchClause(ast); + case 152 /* BreakStatement */: + return this.emitBreakStatement(ast); + case 153 /* ContinueStatement */: + return this.emitContinueStatement(ast); + case 154 /* ForStatement */: + return this.emitForStatement(ast); + case 155 /* ForInStatement */: + return this.emitForInStatement(ast); + case 158 /* WhileStatement */: + return this.emitWhileStatement(ast); + case 163 /* WithStatement */: + return this.emitWithStatement(ast); + case 220 /* CastExpression */: + return this.emitCastExpression(ast); + case 215 /* ObjectLiteralExpression */: + return this.emitObjectLiteralExpression(ast); + case 240 /* SimplePropertyAssignment */: + return this.emitSimplePropertyAssignment(ast); + case 241 /* FunctionPropertyAssignment */: + return this.emitFunctionPropertyAssignment(ast); + case 156 /* EmptyStatement */: + return this.writeToOutputWithSourceMapRecord(";", ast); + case 159 /* TryStatement */: + return this.emitTryStatement(ast); + case 236 /* CatchClause */: + return this.emitCatchClause(ast); + case 237 /* FinallyClause */: + return this.emitFinallyClause(ast); + case 160 /* LabeledStatement */: + return this.emitLabeledStatement(ast); + case 161 /* DoStatement */: + return this.emitDoStatement(ast); + case 171 /* TypeOfExpression */: + return this.emitTypeOfExpression(ast); + case 170 /* DeleteExpression */: + return this.emitDeleteExpression(ast); + case 172 /* VoidExpression */: + return this.emitVoidExpression(ast); + case 162 /* DebuggerStatement */: + return this.emitDebuggerStatement(ast); + } + }; + return Emitter; + })(); + TypeScript.Emitter = Emitter; + + function getLastConstructor(classDecl) { + return classDecl.classElements.lastOrDefault(function (e) { + return e.kind() === 137 /* ConstructorDeclaration */; + }); + } + TypeScript.getLastConstructor = getLastConstructor; + + function getTrimmedTextLines(comment) { + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + return comment.fullText().split("\n").map(function (s) { + return s.trim(); + }); + } else { + return [comment.fullText().trim()]; + } + } + TypeScript.getTrimmedTextLines = getTrimmedTextLines; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var MemberName = (function () { + function MemberName() { + this.prefix = ""; + this.suffix = ""; + } + MemberName.prototype.isString = function () { + return false; + }; + MemberName.prototype.isArray = function () { + return false; + }; + MemberName.prototype.isMarker = function () { + return !this.isString() && !this.isArray(); + }; + + MemberName.prototype.toString = function () { + return MemberName.memberNameToString(this); + }; + + MemberName.memberNameToString = function (memberName, markerInfo, markerBaseLength) { + if (typeof markerBaseLength === "undefined") { markerBaseLength = 0; } + var result = memberName.prefix; + + if (memberName.isString()) { + result += memberName.text; + } else if (memberName.isArray()) { + var ar = memberName; + for (var index = 0; index < ar.entries.length; index++) { + if (ar.entries[index].isMarker()) { + if (markerInfo) { + markerInfo.push(markerBaseLength + result.length); + } + continue; + } + + result += MemberName.memberNameToString(ar.entries[index], markerInfo, markerBaseLength + result.length); + result += ar.delim; + } + } + + result += memberName.suffix; + return result; + }; + + MemberName.create = function (arg1, arg2, arg3) { + if (typeof arg1 === "string") { + return new MemberNameString(arg1); + } else { + var result = new MemberNameArray(); + if (arg2) + result.prefix = arg2; + if (arg3) + result.suffix = arg3; + result.entries.push(arg1); + return result; + } + }; + return MemberName; + })(); + TypeScript.MemberName = MemberName; + + var MemberNameString = (function (_super) { + __extends(MemberNameString, _super); + function MemberNameString(text) { + _super.call(this); + this.text = text; + } + MemberNameString.prototype.isString = function () { + return true; + }; + return MemberNameString; + })(MemberName); + TypeScript.MemberNameString = MemberNameString; + + var MemberNameArray = (function (_super) { + __extends(MemberNameArray, _super); + function MemberNameArray() { + _super.call(this); + this.delim = ""; + this.entries = []; + } + MemberNameArray.prototype.isArray = function () { + return true; + }; + + MemberNameArray.prototype.add = function (entry) { + this.entries.push(entry); + }; + + MemberNameArray.prototype.addAll = function (entries) { + for (var i = 0; i < entries.length; i++) { + this.entries.push(entries[i]); + } + }; + return MemberNameArray; + })(MemberName); + TypeScript.MemberNameArray = MemberNameArray; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function stripStartAndEndQuotes(str) { + var firstCharCode = str && str.charCodeAt(0); + if (str && str.length >= 2 && firstCharCode === str.charCodeAt(str.length - 1) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) { + return str.substring(1, str.length - 1); + } + + return str; + } + TypeScript.stripStartAndEndQuotes = stripStartAndEndQuotes; + + function isSingleQuoted(str) { + return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 39 /* singleQuote */; + } + TypeScript.isSingleQuoted = isSingleQuoted; + + function isDoubleQuoted(str) { + return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 34 /* doubleQuote */; + } + TypeScript.isDoubleQuoted = isDoubleQuoted; + + function isQuoted(str) { + return isDoubleQuoted(str) || isSingleQuoted(str); + } + TypeScript.isQuoted = isQuoted; + + function quoteStr(str) { + return "\"" + str + "\""; + } + TypeScript.quoteStr = quoteStr; + + var switchToForwardSlashesRegEx = /\\/g; + function switchToForwardSlashes(path) { + return path.replace(switchToForwardSlashesRegEx, "/"); + } + TypeScript.switchToForwardSlashes = switchToForwardSlashes; + + function trimModName(modName) { + if (modName.length > 5 && modName.substring(modName.length - 5, modName.length) === ".d.ts") { + return modName.substring(0, modName.length - 5); + } + if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".ts") { + return modName.substring(0, modName.length - 3); + } + + if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".js") { + return modName.substring(0, modName.length - 3); + } + + return modName; + } + TypeScript.trimModName = trimModName; + + function getDeclareFilePath(fname) { + return isTSFile(fname) ? changePathToDTS(fname) : changePathToDTS(fname); + } + TypeScript.getDeclareFilePath = getDeclareFilePath; + + function isFileOfExtension(fname, ext) { + var invariantFname = fname.toLocaleUpperCase(); + var invariantExt = ext.toLocaleUpperCase(); + var extLength = invariantExt.length; + return invariantFname.length > extLength && invariantFname.substring(invariantFname.length - extLength, invariantFname.length) === invariantExt; + } + + function isTSFile(fname) { + return isFileOfExtension(fname, ".ts"); + } + TypeScript.isTSFile = isTSFile; + + function isDTSFile(fname) { + return isFileOfExtension(fname, ".d.ts"); + } + TypeScript.isDTSFile = isDTSFile; + + function getPrettyName(modPath, quote, treatAsFileName) { + if (typeof quote === "undefined") { quote = true; } + if (typeof treatAsFileName === "undefined") { treatAsFileName = false; } + var modName = treatAsFileName ? switchToForwardSlashes(modPath) : trimModName(stripStartAndEndQuotes(modPath)); + var components = this.getPathComponents(modName); + return components.length ? (quote ? quoteStr(components[components.length - 1]) : components[components.length - 1]) : modPath; + } + TypeScript.getPrettyName = getPrettyName; + + function getPathComponents(path) { + return path.split("/"); + } + TypeScript.getPathComponents = getPathComponents; + + function getRelativePathToFixedPath(fixedModFilePath, absoluteModPath, isAbsoultePathURL) { + if (typeof isAbsoultePathURL === "undefined") { isAbsoultePathURL = true; } + absoluteModPath = switchToForwardSlashes(absoluteModPath); + + var modComponents = this.getPathComponents(absoluteModPath); + var fixedModComponents = this.getPathComponents(fixedModFilePath); + + var joinStartIndex = 0; + for (; joinStartIndex < modComponents.length && joinStartIndex < fixedModComponents.length; joinStartIndex++) { + if (fixedModComponents[joinStartIndex] !== modComponents[joinStartIndex]) { + break; + } + } + + if (joinStartIndex !== 0) { + var relativePath = ""; + var relativePathComponents = modComponents.slice(joinStartIndex, modComponents.length); + for (; joinStartIndex < fixedModComponents.length; joinStartIndex++) { + if (fixedModComponents[joinStartIndex] !== "") { + relativePath = relativePath + "../"; + } + } + + return relativePath + relativePathComponents.join("/"); + } + + if (isAbsoultePathURL && absoluteModPath.indexOf("://") === -1) { + absoluteModPath = "file:///" + absoluteModPath; + } + + return absoluteModPath; + } + TypeScript.getRelativePathToFixedPath = getRelativePathToFixedPath; + + function changePathToDTS(modPath) { + return trimModName(stripStartAndEndQuotes(modPath)) + ".d.ts"; + } + TypeScript.changePathToDTS = changePathToDTS; + + function isRelative(path) { + return path.length > 0 && path.charAt(0) === "."; + } + TypeScript.isRelative = isRelative; + function isRooted(path) { + return path.length > 0 && (path.charAt(0) === "\\" || path.charAt(0) === "/" || (path.indexOf(":\\") !== -1) || (path.indexOf(":/") !== -1)); + } + TypeScript.isRooted = isRooted; + + function getRootFilePath(outFname) { + if (outFname === "") { + return outFname; + } else { + var isPath = outFname.indexOf("/") !== -1; + return isPath ? filePath(outFname) : ""; + } + } + TypeScript.getRootFilePath = getRootFilePath; + + function filePathComponents(fullPath) { + fullPath = switchToForwardSlashes(fullPath); + var components = getPathComponents(fullPath); + return components.slice(0, components.length - 1); + } + TypeScript.filePathComponents = filePathComponents; + + function filePath(fullPath) { + var path = filePathComponents(fullPath); + return path.join("/") + "/"; + } + TypeScript.filePath = filePath; + + function convertToDirectoryPath(dirPath) { + if (dirPath && dirPath.charAt(dirPath.length - 1) !== "/") { + dirPath += "/"; + } + + return dirPath; + } + TypeScript.convertToDirectoryPath = convertToDirectoryPath; + + var normalizePathRegEx = /^\\\\[^\\]/; + function normalizePath(path) { + if (normalizePathRegEx.test(path)) { + path = "file:" + path; + } + var parts = this.getPathComponents(switchToForwardSlashes(path)); + var normalizedParts = []; + + for (var i = 0; i < parts.length; i++) { + var part = parts[i]; + if (part === ".") { + continue; + } + + if (normalizedParts.length > 0 && TypeScript.ArrayUtilities.last(normalizedParts) !== ".." && part === "..") { + normalizedParts.pop(); + continue; + } + + normalizedParts.push(part); + } + + return normalizedParts.join("/"); + } + TypeScript.normalizePath = normalizePath; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + + + function isNoDefaultLibMatch(comment) { + var isNoDefaultLibRegex = /^(\/\/\/\s*/gim; + return isNoDefaultLibRegex.exec(comment); + } + + TypeScript.tripleSlashReferenceRegExp = /^(\/\/\/\s*/; + + function getFileReferenceFromReferencePath(fileName, lineMap, position, comment, diagnostics) { + var simpleReferenceRegEx = /^\/\/\/\s*= 7 && fullReference[6] === "true"; + if (isResident) { + TypeScript.CompilerDiagnostics.debugPrint(path + " is resident"); + } + return { + line: 0, + character: 0, + position: 0, + length: 0, + path: TypeScript.switchToForwardSlashes(adjustedPath), + isResident: isResident + }; + } + } + } + + return null; + } + + var scannerWindow = TypeScript.ArrayUtilities.createArray(2048, 0); + var scannerDiagnostics = []; + + function processImports(lineMap, scanner, token, importedFiles) { + var position = 0; + var lineChar = { line: -1, character: -1 }; + + var start = new Date().getTime(); + + while (token.tokenKind !== 10 /* EndOfFileToken */) { + if (token.tokenKind === 49 /* ImportKeyword */) { + var importStart = position + token.leadingTriviaWidth(); + token = scanner.scan(scannerDiagnostics, false); + + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 107 /* EqualsToken */) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 65 /* ModuleKeyword */ || token.tokenKind === 66 /* RequireKeyword */) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 72 /* OpenParenToken */) { + var afterOpenParenPosition = scanner.absoluteIndex(); + token = scanner.scan(scannerDiagnostics, false); + + lineMap.fillLineAndCharacterFromPosition(importStart, lineChar); + + if (token.tokenKind === 14 /* StringLiteral */) { + var ref = { + line: lineChar.line, + character: lineChar.character, + position: afterOpenParenPosition + token.leadingTriviaWidth(), + length: token.width(), + path: TypeScript.stripStartAndEndQuotes(TypeScript.switchToForwardSlashes(token.text())), + isResident: false + }; + importedFiles.push(ref); + } + } + } + } + } + } + + position = scanner.absoluteIndex(); + token = scanner.scan(scannerDiagnostics, false); + } + + var totalTime = new Date().getTime() - start; + TypeScript.fileResolutionScanImportsTime += totalTime; + } + + function processTripleSlashDirectives(fileName, lineMap, firstToken) { + var leadingTrivia = firstToken.leadingTrivia(); + + var position = 0; + var lineChar = { line: -1, character: -1 }; + var noDefaultLib = false; + var diagnostics = []; + var referencedFiles = []; + + for (var i = 0, n = leadingTrivia.count(); i < n; i++) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + + if (trivia.kind() === 7 /* SingleLineCommentTrivia */) { + var triviaText = trivia.fullText(); + var referencedCode = getFileReferenceFromReferencePath(fileName, lineMap, position, triviaText, diagnostics); + + if (referencedCode) { + lineMap.fillLineAndCharacterFromPosition(position, lineChar); + referencedCode.position = position; + referencedCode.length = trivia.fullWidth(); + referencedCode.line = lineChar.line; + referencedCode.character = lineChar.character; + + referencedFiles.push(referencedCode); + } + + var isNoDefaultLib = isNoDefaultLibMatch(triviaText); + if (isNoDefaultLib) { + noDefaultLib = isNoDefaultLib[3] === "true"; + } + } + + position += trivia.fullWidth(); + } + + return { noDefaultLib: noDefaultLib, diagnostics: diagnostics, referencedFiles: referencedFiles }; + } + + function preProcessFile(fileName, sourceText, readImportFiles) { + if (typeof readImportFiles === "undefined") { readImportFiles = true; } + var text = TypeScript.SimpleText.fromScriptSnapshot(sourceText); + var scanner = new TypeScript.Scanner(fileName, text, 1 /* EcmaScript5 */, scannerWindow); + + var firstToken = scanner.scan(scannerDiagnostics, false); + + var importedFiles = []; + if (readImportFiles) { + processImports(text.lineMap(), scanner, firstToken, importedFiles); + } + + var properties = processTripleSlashDirectives(fileName, text.lineMap(), firstToken); + + scannerDiagnostics.length = 0; + return { referencedFiles: properties.referencedFiles, importedFiles: importedFiles, isLibFile: properties.noDefaultLib, diagnostics: properties.diagnostics }; + } + TypeScript.preProcessFile = preProcessFile; + + function getParseOptions(settings) { + return new TypeScript.ParseOptions(settings.codeGenTarget(), settings.allowAutomaticSemicolonInsertion()); + } + TypeScript.getParseOptions = getParseOptions; + + function getReferencedFiles(fileName, sourceText) { + return preProcessFile(fileName, sourceText, false).referencedFiles; + } + TypeScript.getReferencedFiles = getReferencedFiles; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ReferenceResolutionResult = (function () { + function ReferenceResolutionResult() { + this.resolvedFiles = []; + this.diagnostics = []; + this.seenNoDefaultLibTag = false; + } + return ReferenceResolutionResult; + })(); + TypeScript.ReferenceResolutionResult = ReferenceResolutionResult; + + var ReferenceLocation = (function () { + function ReferenceLocation(filePath, lineMap, position, length, isImported) { + this.filePath = filePath; + this.lineMap = lineMap; + this.position = position; + this.length = length; + this.isImported = isImported; + } + return ReferenceLocation; + })(); + + var ReferenceResolver = (function () { + function ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution) { + this.useCaseSensitiveFileResolution = useCaseSensitiveFileResolution; + this.inputFileNames = inputFileNames; + this.host = host; + this.visited = {}; + } + ReferenceResolver.resolve = function (inputFileNames, host, useCaseSensitiveFileResolution) { + var resolver = new ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution); + return resolver.resolveInputFiles(); + }; + + ReferenceResolver.prototype.resolveInputFiles = function () { + var _this = this; + var result = new ReferenceResolutionResult(); + + if (!this.inputFileNames || this.inputFileNames.length <= 0) { + return result; + } + + var referenceLocation = new ReferenceLocation(null, null, 0, 0, false); + this.inputFileNames.forEach(function (fileName) { + return _this.resolveIncludedFile(fileName, referenceLocation, result); + }); + + return result; + }; + + ReferenceResolver.prototype.resolveIncludedFile = function (path, referenceLocation, resolutionResult) { + var normalizedPath = this.getNormalizedFilePath(path, referenceLocation.filePath); + + if (this.isSameFile(normalizedPath, referenceLocation.filePath)) { + if (!referenceLocation.isImported) { + resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.A_file_cannot_have_a_reference_to_itself, null)); + } + + return normalizedPath; + } + + if (!TypeScript.isTSFile(normalizedPath) && !TypeScript.isDTSFile(normalizedPath)) { + var dtsFile = normalizedPath + ".d.ts"; + var tsFile = normalizedPath + ".ts"; + + if (this.host.fileExists(dtsFile)) { + normalizedPath = dtsFile; + } else { + normalizedPath = tsFile; + } + } + + if (!this.host.fileExists(normalizedPath)) { + if (!referenceLocation.isImported) { + resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.Cannot_resolve_referenced_file_0, [path])); + } + + return normalizedPath; + } + + return this.resolveFile(normalizedPath, resolutionResult); + }; + + ReferenceResolver.prototype.resolveImportedFile = function (path, referenceLocation, resolutionResult) { + var isRelativePath = TypeScript.isRelative(path); + var isRootedPath = isRelativePath ? false : TypeScript.isRooted(path); + + if (isRelativePath || isRootedPath) { + return this.resolveIncludedFile(path, referenceLocation, resolutionResult); + } else { + var parentDirectory = this.host.getParentDirectory(referenceLocation.filePath); + var searchFilePath = null; + var dtsFileName = path + ".d.ts"; + var tsFilePath = path + ".ts"; + + var start = new Date().getTime(); + + do { + var currentFilePath = this.host.resolveRelativePath(dtsFileName, parentDirectory); + if (this.host.fileExists(currentFilePath)) { + searchFilePath = currentFilePath; + break; + } + + currentFilePath = this.host.resolveRelativePath(tsFilePath, parentDirectory); + if (this.host.fileExists(currentFilePath)) { + searchFilePath = currentFilePath; + break; + } + + parentDirectory = this.host.getParentDirectory(parentDirectory); + } while(parentDirectory); + + TypeScript.fileResolutionImportFileSearchTime += new Date().getTime() - start; + + if (!searchFilePath) { + return path; + } + + return this.resolveFile(searchFilePath, resolutionResult); + } + }; + + ReferenceResolver.prototype.resolveFile = function (normalizedPath, resolutionResult) { + var _this = this; + var visitedPath = this.isVisited(normalizedPath); + if (!visitedPath) { + this.recordVisitedFile(normalizedPath); + + var start = new Date().getTime(); + var scriptSnapshot = this.host.getScriptSnapshot(normalizedPath); + var totalTime = new Date().getTime() - start; + TypeScript.fileResolutionIOTime += totalTime; + + var lineMap = TypeScript.LineMap1.fromScriptSnapshot(scriptSnapshot); + var preprocessedFileInformation = TypeScript.preProcessFile(normalizedPath, scriptSnapshot); + resolutionResult.diagnostics.push.apply(resolutionResult.diagnostics, preprocessedFileInformation.diagnostics); + + if (preprocessedFileInformation.isLibFile) { + resolutionResult.seenNoDefaultLibTag = true; + } + + var normalizedReferencePaths = []; + preprocessedFileInformation.referencedFiles.forEach(function (fileReference) { + var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileReference.position, fileReference.length, false); + var normalizedReferencePath = _this.resolveIncludedFile(fileReference.path, currentReferenceLocation, resolutionResult); + normalizedReferencePaths.push(normalizedReferencePath); + }); + + var normalizedImportPaths = []; + for (var i = 0; i < preprocessedFileInformation.importedFiles.length; i++) { + var fileImport = preprocessedFileInformation.importedFiles[i]; + var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileImport.position, fileImport.length, true); + var normalizedImportPath = this.resolveImportedFile(fileImport.path, currentReferenceLocation, resolutionResult); + normalizedImportPaths.push(normalizedImportPath); + } + + resolutionResult.resolvedFiles.push({ + path: normalizedPath, + referencedFiles: normalizedReferencePaths, + importedFiles: normalizedImportPaths + }); + } else { + normalizedPath = visitedPath; + } + + return normalizedPath; + }; + + ReferenceResolver.prototype.getNormalizedFilePath = function (path, parentFilePath) { + var parentFileDirectory = parentFilePath ? this.host.getParentDirectory(parentFilePath) : ""; + var normalizedPath = this.host.resolveRelativePath(path, parentFileDirectory); + return normalizedPath; + }; + + ReferenceResolver.prototype.getUniqueFileId = function (filePath) { + return this.useCaseSensitiveFileResolution ? filePath : filePath.toLocaleUpperCase(); + }; + + ReferenceResolver.prototype.recordVisitedFile = function (filePath) { + this.visited[this.getUniqueFileId(filePath)] = filePath; + }; + + ReferenceResolver.prototype.isVisited = function (filePath) { + return this.visited[this.getUniqueFileId(filePath)]; + }; + + ReferenceResolver.prototype.isSameFile = function (filePath1, filePath2) { + if (!filePath1 || !filePath2) { + return false; + } + + if (this.useCaseSensitiveFileResolution) { + return filePath1 === filePath2; + } else { + return filePath1.toLocaleUpperCase() === filePath2.toLocaleUpperCase(); + } + }; + return ReferenceResolver; + })(); + TypeScript.ReferenceResolver = ReferenceResolver; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextWriter = (function () { + function TextWriter(name, writeByteOrderMark, outputFileType) { + this.name = name; + this.writeByteOrderMark = writeByteOrderMark; + this.outputFileType = outputFileType; + this.contents = ""; + this.onNewLine = true; + } + TextWriter.prototype.Write = function (s) { + this.contents += s; + this.onNewLine = false; + }; + + TextWriter.prototype.WriteLine = function (s) { + this.contents += s; + this.contents += TypeScript.newLine(); + this.onNewLine = true; + }; + + TextWriter.prototype.Close = function () { + }; + + TextWriter.prototype.getOutputFile = function () { + return new TypeScript.OutputFile(this.name, this.writeByteOrderMark, this.contents, this.outputFileType); + }; + return TextWriter; + })(); + TypeScript.TextWriter = TextWriter; + + var DeclarationEmitter = (function () { + function DeclarationEmitter(emittingFileName, document, compiler, emitOptions, semanticInfoChain) { + this.emittingFileName = emittingFileName; + this.document = document; + this.compiler = compiler; + this.emitOptions = emitOptions; + this.semanticInfoChain = semanticInfoChain; + this.declFile = null; + this.indenter = new TypeScript.Indenter(); + this.emittedReferencePaths = false; + this.declFile = new TextWriter(emittingFileName, this.document.byteOrderMark !== 0 /* None */, 2 /* Declaration */); + } + DeclarationEmitter.prototype.getOutputFile = function () { + return this.declFile.getOutputFile(); + }; + + DeclarationEmitter.prototype.emitDeclarations = function (sourceUnit) { + this.emitDeclarationsForSourceUnit(sourceUnit); + }; + + DeclarationEmitter.prototype.emitDeclarationsForList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + this.emitDeclarationsForAST(list.childAt(i)); + } + }; + + DeclarationEmitter.prototype.emitSeparatedList = function (list) { + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + this.emitDeclarationsForAST(list.nonSeparatorAt(i)); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForAST = function (ast) { + switch (ast.kind()) { + case 148 /* VariableStatement */: + return this.emitDeclarationsForVariableStatement(ast); + case 141 /* PropertySignature */: + return this.emitPropertySignature(ast); + case 225 /* VariableDeclarator */: + return this.emitVariableDeclarator(ast, true, true); + case 136 /* MemberVariableDeclaration */: + return this.emitDeclarationsForMemberVariableDeclaration(ast); + case 137 /* ConstructorDeclaration */: + return this.emitDeclarationsForConstructorDeclaration(ast); + case 139 /* GetAccessor */: + return this.emitDeclarationsForGetAccessor(ast); + case 140 /* SetAccessor */: + return this.emitDeclarationsForSetAccessor(ast); + case 138 /* IndexMemberDeclaration */: + return this.emitIndexMemberDeclaration(ast); + case 144 /* IndexSignature */: + return this.emitIndexSignature(ast); + case 142 /* CallSignature */: + return this.emitCallSignature(ast); + case 143 /* ConstructSignature */: + return this.emitConstructSignature(ast); + case 145 /* MethodSignature */: + return this.emitMethodSignature(ast); + case 129 /* FunctionDeclaration */: + return this.emitDeclarationsForFunctionDeclaration(ast); + case 135 /* MemberFunctionDeclaration */: + return this.emitMemberFunctionDeclaration(ast); + case 131 /* ClassDeclaration */: + return this.emitDeclarationsForClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.emitDeclarationsForInterfaceDeclaration(ast); + case 133 /* ImportDeclaration */: + return this.emitDeclarationsForImportDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.emitDeclarationsForModuleDeclaration(ast); + case 132 /* EnumDeclaration */: + return this.emitDeclarationsForEnumDeclaration(ast); + case 134 /* ExportAssignment */: + return this.emitDeclarationsForExportAssignment(ast); + } + }; + + DeclarationEmitter.prototype.getIndentString = function (declIndent) { + if (typeof declIndent === "undefined") { declIndent = false; } + return this.indenter.getIndent(); + }; + + DeclarationEmitter.prototype.emitIndent = function () { + this.declFile.Write(this.getIndentString()); + }; + + DeclarationEmitter.prototype.canEmitDeclarations = function (declAST) { + var container = this.getEnclosingContainer(declAST); + if (container.kind() === 130 /* ModuleDeclaration */ || container.kind() === 120 /* SourceUnit */) { + var pullDecl = this.semanticInfoChain.getDeclForAST(declAST); + if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + var start = new Date().getTime(); + var declSymbol = this.semanticInfoChain.getSymbolForAST(declAST); + var result = declSymbol && declSymbol.isExternallyVisible(); + TypeScript.declarationEmitIsExternallyVisibleTime += new Date().getTime() - start; + + return result; + } + } + + return true; + }; + + DeclarationEmitter.prototype.getDeclFlagsString = function (pullDecl, typeString) { + var result = this.getIndentString(); + var pullFlags = pullDecl.flags; + + if (TypeScript.hasFlag(pullFlags, 16 /* Static */)) { + if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) { + result += "private "; + } + result += "static "; + } else { + if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) { + result += "private "; + } else if (TypeScript.hasFlag(pullFlags, 4 /* Public */)) { + result += "public "; + } else { + var emitDeclare = !TypeScript.hasFlag(pullFlags, 1 /* Exported */); + + var declAST = this.semanticInfoChain.getASTForDecl(pullDecl); + var container = this.getEnclosingContainer(declAST); + + if (container.kind() === 130 /* ModuleDeclaration */ && TypeScript.isAnyNameOfModule(container, declAST)) { + container = this.getEnclosingContainer(container); + } + + var isExternalModule = container.kind() === 120 /* SourceUnit */ && this.document.isExternalModule(); + + if (isExternalModule && TypeScript.hasFlag(pullFlags, 1 /* Exported */)) { + result += "export "; + emitDeclare = true; + } + + if (isExternalModule || container.kind() == 120 /* SourceUnit */) { + if (emitDeclare && typeString !== "interface" && typeString != "import") { + result += "declare "; + } + } + + result += typeString + " "; + } + } + + return result; + }; + + DeclarationEmitter.prototype.emitDeclFlags = function (declarationAST, typeString) { + this.declFile.Write(this.getDeclFlagsString(this.semanticInfoChain.getDeclForAST(declarationAST), typeString)); + }; + + DeclarationEmitter.prototype.emitTypeNamesMember = function (memberName, emitIndent) { + if (typeof emitIndent === "undefined") { emitIndent = false; } + if (memberName.prefix === "{ ") { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.WriteLine("{"); + this.indenter.increaseIndent(); + emitIndent = true; + } else if (memberName.prefix !== "") { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.Write(memberName.prefix); + emitIndent = false; + } + + if (memberName.isString()) { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.Write(memberName.text); + } else if (memberName.isArray()) { + var ar = memberName; + for (var index = 0; index < ar.entries.length; index++) { + this.emitTypeNamesMember(ar.entries[index], emitIndent); + if (ar.delim === "; ") { + this.declFile.WriteLine(";"); + } + } + } + + if (memberName.suffix === "}") { + this.indenter.decreaseIndent(); + this.emitIndent(); + this.declFile.Write(memberName.suffix); + } else { + this.declFile.Write(memberName.suffix); + } + }; + + DeclarationEmitter.prototype.emitTypeSignature = function (ast, type) { + var declarationContainerAst = this.getEnclosingContainer(ast); + + var start = new Date().getTime(); + var declarationContainerDecl = this.semanticInfoChain.getDeclForAST(declarationContainerAst); + + var declarationPullSymbol = declarationContainerDecl.getSymbol(); + TypeScript.declarationEmitTypeSignatureTime += new Date().getTime() - start; + + var typeNameMembers = type.getScopedNameEx(declarationPullSymbol); + this.emitTypeNamesMember(typeNameMembers); + }; + + DeclarationEmitter.prototype.emitComment = function (comment) { + var text = TypeScript.getTrimmedTextLines(comment); + if (this.declFile.onNewLine) { + this.emitIndent(); + } else if (comment.kind() !== 6 /* MultiLineCommentTrivia */) { + this.declFile.WriteLine(""); + this.emitIndent(); + } + + this.declFile.Write(text[0]); + + for (var i = 1; i < text.length; i++) { + this.declFile.WriteLine(""); + this.emitIndent(); + this.declFile.Write(text[i]); + } + + if (comment.endsLine || comment.kind() !== 6 /* MultiLineCommentTrivia */) { + this.declFile.WriteLine(""); + } else { + this.declFile.Write(" "); + } + }; + + DeclarationEmitter.prototype.emitDeclarationComments = function (astOrSymbol, endLine) { + if (typeof endLine === "undefined") { endLine = true; } + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var declComments = astOrSymbol.docComments ? astOrSymbol.docComments() : TypeScript.docComments(astOrSymbol); + this.writeDeclarationComments(declComments, endLine); + }; + + DeclarationEmitter.prototype.writeDeclarationComments = function (declComments, endLine) { + if (typeof endLine === "undefined") { endLine = true; } + if (declComments.length > 0) { + for (var i = 0; i < declComments.length; i++) { + this.emitComment(declComments[i]); + } + + if (endLine) { + if (!this.declFile.onNewLine) { + this.declFile.WriteLine(""); + } + } else { + if (this.declFile.onNewLine) { + this.emitIndent(); + } + } + } + }; + + DeclarationEmitter.prototype.emitTypeOfVariableDeclaratorOrParameter = function (boundDecl) { + var start = new Date().getTime(); + var decl = this.semanticInfoChain.getDeclForAST(boundDecl); + var pullSymbol = decl.getSymbol(); + TypeScript.declarationEmitGetBoundDeclTypeTime += new Date().getTime() - start; + + var type = pullSymbol.type; + TypeScript.Debug.assert(type); + + this.declFile.Write(": "); + this.emitTypeSignature(boundDecl, type); + }; + + DeclarationEmitter.prototype.emitPropertySignature = function (varDecl) { + this.emitDeclarationComments(varDecl); + this.emitIndent(); + this.declFile.Write(varDecl.propertyName.text()); + if (varDecl.questionToken) { + this.declFile.Write("?"); + } + + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitVariableDeclarator = function (varDecl, isFirstVarInList, isLastVarInList) { + if (this.canEmitDeclarations(varDecl)) { + this.emitDeclarationComments(varDecl); + + if (isFirstVarInList) { + this.emitDeclFlags(varDecl, "var"); + } + + this.declFile.Write(varDecl.propertyName.text()); + + if (!TypeScript.hasModifier(TypeScript.getVariableDeclaratorModifiers(varDecl), 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + } + + if (isLastVarInList) { + this.declFile.WriteLine(";"); + } else { + this.declFile.Write(", "); + } + } + }; + + DeclarationEmitter.prototype.emitClassElementModifiers = function (modifiers) { + if (TypeScript.hasModifier(modifiers, 16 /* Static */)) { + if (TypeScript.hasModifier(modifiers, 2 /* Private */)) { + this.declFile.Write("private "); + } + this.declFile.Write("static "); + } else { + if (TypeScript.hasModifier(modifiers, 2 /* Private */)) { + this.declFile.Write("private "); + } else { + this.declFile.Write("public "); + } + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForMemberVariableDeclaration = function (varDecl) { + if (this.canEmitDeclarations(varDecl)) { + this.emitDeclarationComments(varDecl); + + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(varDecl.modifiers); + ; + + this.declFile.Write(varDecl.variableDeclarator.propertyName.text()); + + if (!TypeScript.hasModifier(varDecl.modifiers, 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + } + + this.declFile.WriteLine(";"); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForVariableStatement = function (variableStatement) { + this.emitDeclarationsForVariableDeclaration(variableStatement.declaration); + }; + + DeclarationEmitter.prototype.emitDeclarationsForVariableDeclaration = function (variableDeclaration) { + var varListCount = variableDeclaration.declarators.nonSeparatorCount(); + for (var i = 0; i < varListCount; i++) { + this.emitVariableDeclarator(variableDeclaration.declarators.nonSeparatorAt(i), i == 0, i == varListCount - 1); + } + }; + + DeclarationEmitter.prototype.emitArgDecl = function (argDecl, id, isOptional, isPrivate) { + this.indenter.increaseIndent(); + + this.emitDeclarationComments(argDecl, false); + this.declFile.Write(id.text()); + if (isOptional) { + this.declFile.Write("?"); + } + + this.indenter.decreaseIndent(); + + if (!isPrivate) { + this.emitTypeOfVariableDeclaratorOrParameter(argDecl); + } + }; + + DeclarationEmitter.prototype.isOverloadedCallSignature = function (funcDecl) { + var start = new Date().getTime(); + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSymbol = functionDecl.getSymbol(); + TypeScript.declarationEmitIsOverloadedCallSignatureTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + var signatures = funcTypeSymbol.getCallSignatures(); + var result = signatures && signatures.length > 1; + + return result; + }; + + DeclarationEmitter.prototype.emitDeclarationsForConstructorDeclaration = function (funcDecl) { + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + if (funcDecl.block) { + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } + } + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("constructor"); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.parameterList)); + this.declFile.Write(")"); + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitParameterList = function (isPrivate, parameterList) { + this.declFile.Write("("); + this.emitParameters(isPrivate, TypeScript.Parameters.fromParameterList(parameterList)); + this.declFile.Write(")"); + }; + + DeclarationEmitter.prototype.emitParameters = function (isPrivate, parameterList) { + var hasLastParameterRestParameter = parameterList.lastParameterIsRest(); + var argsLen = parameterList.length; + if (hasLastParameterRestParameter) { + argsLen--; + } + + for (var i = 0; i < argsLen; i++) { + this.emitArgDecl(parameterList.astAt(i), parameterList.identifierAt(i), parameterList.isOptionalAt(i), isPrivate); + if (i < (argsLen - 1)) { + this.declFile.Write(", "); + } + } + + if (hasLastParameterRestParameter) { + if (parameterList.length > 1) { + this.declFile.Write(", ..."); + } else { + this.declFile.Write("..."); + } + + var index = parameterList.length - 1; + this.emitArgDecl(parameterList.astAt(index), parameterList.identifierAt(index), parameterList.isOptionalAt(index), isPrivate); + } + }; + + DeclarationEmitter.prototype.emitMemberFunctionDeclaration = function (funcDecl) { + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + if (funcDecl.block) { + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } else if (this.isOverloadedCallSignature(funcDecl)) { + return; + } + } else if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */) && this.isOverloadedCallSignature(funcDecl)) { + var callSignatures = funcTypeSymbol.getCallSignatures(); + TypeScript.Debug.assert(callSignatures && callSignatures.length > 1); + var firstSignature = callSignatures[0].isDefinition() ? callSignatures[1] : callSignatures[0]; + var firstSignatureDecl = firstSignature.getDeclarations()[0]; + var firstFuncDecl = this.semanticInfoChain.getASTForDecl(firstSignatureDecl); + if (firstFuncDecl !== funcDecl) { + return; + } + } + + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitDeclarationComments(funcDecl); + + this.emitDeclFlags(funcDecl, "function"); + var id = funcDecl.propertyName.text(); + this.declFile.Write(id); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + var isPrivate = TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */); + + this.emitParameterList(isPrivate, funcDecl.callSignature.parameterList); + + if (!isPrivate) { + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + this.emitTypeSignature(funcDecl, returnType); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitCallSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + this.emitDeclarationComments(funcDecl); + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.typeParameterList, funcSignature); + + this.emitIndent(); + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitConstructSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("new"); + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitMethodSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write(funcDecl.propertyName.text()); + if (funcDecl.questionToken) { + this.declFile.Write("? "); + } + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForFunctionDeclaration = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + if (funcDecl.block) { + var funcTypeSymbol = funcSymbol.type; + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } else if (this.isOverloadedCallSignature(funcDecl)) { + return; + } + } + + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + this.emitDeclarationComments(funcDecl); + + var id = funcDecl.identifier.text(); + this.emitDeclFlags(funcDecl, "function"); + if (id !== "" || !funcDecl.identifier || funcDecl.identifier.text().length > 0) { + this.declFile.Write(id); + } else if (funcPullDecl.kind === 2097152 /* ConstructSignature */) { + this.declFile.Write("new"); + } + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitIndexMemberDeclaration = function (funcDecl) { + this.emitDeclarationsForAST(funcDecl.indexSignature); + }; + + DeclarationEmitter.prototype.emitIndexSignature = function (funcDecl) { + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("["); + this.emitParameters(false, TypeScript.Parameters.fromParameter(funcDecl.parameter)); + this.declFile.Write("]"); + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + this.emitTypeSignature(funcDecl, returnType); + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitBaseList = function (bases, useExtendsList) { + if (bases && (bases.nonSeparatorCount() > 0)) { + var qual = useExtendsList ? "extends" : "implements"; + this.declFile.Write(" " + qual + " "); + var basesLen = bases.nonSeparatorCount(); + for (var i = 0; i < basesLen; i++) { + if (i > 0) { + this.declFile.Write(", "); + } + var base = bases.nonSeparatorAt(i); + var baseType = this.semanticInfoChain.getSymbolForAST(base); + this.emitTypeSignature(base, baseType); + } + } + }; + + DeclarationEmitter.prototype.emitAccessorDeclarationComments = function (funcDecl) { + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var start = new Date().getTime(); + var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain); + TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime(); + + var comments = []; + if (accessors.getter) { + comments = comments.concat(TypeScript.docComments(accessors.getter)); + } + if (accessors.setter) { + comments = comments.concat(TypeScript.docComments(accessors.setter)); + } + + this.writeDeclarationComments(comments); + }; + + DeclarationEmitter.prototype.emitDeclarationsForGetAccessor = function (funcDecl) { + this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName); + }; + + DeclarationEmitter.prototype.emitDeclarationsForSetAccessor = function (funcDecl) { + this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName); + }; + + DeclarationEmitter.prototype.emitMemberAccessorDeclaration = function (funcDecl, modifiers, name) { + var start = new Date().getTime(); + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain); + TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime(); + + if (funcDecl.kind() === 140 /* SetAccessor */ && accessorSymbol.getGetter()) { + return; + } + + var isPrivate = TypeScript.hasModifier(modifiers, 2 /* Private */); + this.emitAccessorDeclarationComments(funcDecl); + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(modifiers); + this.declFile.Write(name.text()); + if (!isPrivate) { + this.declFile.Write(" : "); + var type = accessorSymbol.type; + this.emitTypeSignature(funcDecl, type); + } + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) { + if (funcDecl.parameterList) { + var argsLen = funcDecl.parameterList.parameters.nonSeparatorCount(); + if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) { + argsLen--; + } + + for (var i = 0; i < argsLen; i++) { + var parameter = funcDecl.parameterList.parameters.nonSeparatorAt(i); + var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter); + if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.emitDeclarationComments(parameter); + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(parameter.modifiers); + this.declFile.Write(parameter.identifier.text()); + + if (!TypeScript.hasModifier(parameter.modifiers, 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(parameter); + } + this.declFile.WriteLine(";"); + } + } + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForClassDeclaration = function (classDecl) { + if (!this.canEmitDeclarations(classDecl)) { + return; + } + + var className = classDecl.identifier.text(); + this.emitDeclarationComments(classDecl); + var classPullDecl = this.semanticInfoChain.getDeclForAST(classDecl); + this.emitDeclFlags(classDecl, "class"); + this.declFile.Write(className); + + this.emitTypeParameters(classDecl.typeParameterList); + this.emitHeritageClauses(classDecl.heritageClauses); + this.declFile.WriteLine(" {"); + + this.indenter.increaseIndent(); + var constructorDecl = TypeScript.getLastConstructor(classDecl); + if (constructorDecl) { + this.emitClassMembersFromConstructorDefinition(constructorDecl); + } + + this.emitDeclarationsForList(classDecl.classElements); + + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitHeritageClauses = function (clauses) { + if (clauses) { + for (var i = 0, n = clauses.childCount(); i < n; i++) { + this.emitHeritageClause(clauses.childAt(i)); + } + } + }; + + DeclarationEmitter.prototype.emitHeritageClause = function (clause) { + this.emitBaseList(clause.typeNames, clause.kind() === 230 /* ExtendsHeritageClause */); + }; + + DeclarationEmitter.prototype.getEnclosingContainer = function (ast) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 131 /* ClassDeclaration */ || ast.kind() === 128 /* InterfaceDeclaration */ || ast.kind() === 130 /* ModuleDeclaration */ || ast.kind() === 120 /* SourceUnit */) { + return ast; + } + + ast = ast.parent; + } + + return null; + }; + + DeclarationEmitter.prototype.emitTypeParameters = function (typeParams, funcSignature) { + if (!typeParams || !typeParams.typeParameters.nonSeparatorCount()) { + return; + } + + this.declFile.Write("<"); + var containerAst = this.getEnclosingContainer(typeParams); + + var start = new Date().getTime(); + var containerDecl = this.semanticInfoChain.getDeclForAST(containerAst); + var containerSymbol = containerDecl.getSymbol(); + TypeScript.declarationEmitGetTypeParameterSymbolTime += new Date().getTime() - start; + + var typars; + if (funcSignature) { + typars = funcSignature.getTypeParameters(); + } else { + typars = containerSymbol.getTypeArgumentsOrTypeParameters(); + } + + for (var i = 0; i < typars.length; i++) { + if (i) { + this.declFile.Write(", "); + } + + var memberName = typars[i].getScopedNameEx(containerSymbol, false, true); + this.emitTypeNamesMember(memberName); + } + + this.declFile.Write(">"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForInterfaceDeclaration = function (interfaceDecl) { + if (!this.canEmitDeclarations(interfaceDecl)) { + return; + } + + var interfaceName = interfaceDecl.identifier.text(); + this.emitDeclarationComments(interfaceDecl); + var interfacePullDecl = this.semanticInfoChain.getDeclForAST(interfaceDecl); + this.emitDeclFlags(interfaceDecl, "interface"); + this.declFile.Write(interfaceName); + + this.emitTypeParameters(interfaceDecl.typeParameterList); + this.emitHeritageClauses(interfaceDecl.heritageClauses); + this.declFile.WriteLine(" {"); + + this.indenter.increaseIndent(); + + this.emitSeparatedList(interfaceDecl.body.typeMembers); + + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForImportDeclaration = function (importDeclAST) { + var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST); + var importSymbol = importDecl.getSymbol(); + var isExportedImportDecl = TypeScript.hasModifier(importDeclAST.modifiers, 1 /* Exported */); + + if (isExportedImportDecl || importSymbol.typeUsedExternally() || TypeScript.PullContainerSymbol.usedAsSymbol(importSymbol.getContainer(), importSymbol)) { + this.emitDeclarationComments(importDeclAST); + this.emitIndent(); + if (isExportedImportDecl) { + this.declFile.Write("export "); + } + this.declFile.Write("import "); + this.declFile.Write(importDeclAST.identifier.text() + " = "); + if (importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + this.declFile.WriteLine("require(" + importDeclAST.moduleReference.stringLiteral.text() + ");"); + } else { + this.declFile.WriteLine(this.getFullName(importDeclAST.moduleReference.moduleName) + ";"); + } + } + }; + + DeclarationEmitter.prototype.getFullName = function (name) { + if (name.kind() === 11 /* IdentifierName */) { + return name.text(); + } else { + var dotExpr = name; + return this.getFullName(dotExpr.left) + "." + this.getFullName(dotExpr.right); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForEnumDeclaration = function (moduleDecl) { + if (!this.canEmitDeclarations(moduleDecl)) { + return; + } + + this.emitDeclarationComments(moduleDecl); + var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.emitDeclFlags(moduleDecl, "enum"); + this.declFile.WriteLine(moduleDecl.identifier.text() + " {"); + + this.indenter.increaseIndent(); + var membersLen = moduleDecl.enumElements.nonSeparatorCount(); + for (var j = 0; j < membersLen; j++) { + var memberDecl = moduleDecl.enumElements.nonSeparatorAt(j); + var enumElement = memberDecl; + var enumElementDecl = this.semanticInfoChain.getDeclForAST(enumElement); + this.emitDeclarationComments(enumElement); + this.emitIndent(); + this.declFile.Write(enumElement.propertyName.text()); + if (enumElementDecl.constantValue != null) { + this.declFile.Write(" = " + enumElementDecl.constantValue); + } + this.declFile.WriteLine(","); + } + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForModuleDeclaration = function (moduleDecl) { + if (!this.canEmitDeclarations(moduleDecl)) { + return; + } + + var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.emitDeclarationComments(moduleDecl); + + var name = moduleDecl.stringLiteral || TypeScript.ArrayUtilities.first(TypeScript.getModuleNames(moduleDecl.name)); + this.emitDeclFlags(name, "module"); + + if (moduleDecl.stringLiteral) { + this.declFile.Write(moduleDecl.stringLiteral.text()); + } else { + this.declFile.Write(this.getFullName(moduleDecl.name)); + } + + this.declFile.WriteLine(" {"); + this.indenter.increaseIndent(); + + this.emitDeclarationsForList(moduleDecl.moduleElements); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForExportAssignment = function (ast) { + this.emitIndent(); + this.declFile.Write("export = "); + this.declFile.Write(ast.identifier.text()); + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.resolveScriptReference = function (document, reference) { + if (!this.emitOptions.compilationSettings().noResolve() || TypeScript.isRooted(reference)) { + return reference; + } + + var documentDir = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath(document.fileName))); + var resolvedReferencePath = this.emitOptions.resolvePath(documentDir + reference); + return resolvedReferencePath; + }; + + DeclarationEmitter.prototype.emitReferencePaths = function (sourceUnit) { + if (this.emittedReferencePaths) { + return; + } + + var documents = []; + if (this.document.emitToOwnOutputFile()) { + var scriptReferences = this.document.referencedFiles; + var addedGlobalDocument = false; + for (var j = 0; j < scriptReferences.length; j++) { + var currentReference = this.resolveScriptReference(this.document, scriptReferences[j]); + var document = this.compiler.getDocument(currentReference); + + if (document && (document.emitToOwnOutputFile() || document.isDeclareFile() || !addedGlobalDocument)) { + documents = documents.concat(document); + + if (!document.isDeclareFile() && document.isExternalModule()) { + addedGlobalDocument = true; + } + } + } + } else { + var fileNames = this.compiler.fileNames(); + for (var i = 0; i < fileNames.length; i++) { + var doc = this.compiler.getDocument(fileNames[i]); + if (!doc.isDeclareFile() && !doc.isExternalModule()) { + var scriptReferences = doc.referencedFiles; + for (var j = 0; j < scriptReferences.length; j++) { + var currentReference = this.resolveScriptReference(doc, scriptReferences[j]); + var document = this.compiler.getDocument(currentReference); + + if (document && (document.isDeclareFile() || document.isExternalModule())) { + for (var k = 0; k < documents.length; k++) { + if (documents[k] == document) { + break; + } + } + + if (k == documents.length) { + documents = documents.concat(document); + } + } + } + } + } + } + + var emittingFilePath = documents.length ? TypeScript.getRootFilePath(this.emittingFileName) : null; + for (var i = 0; i < documents.length; i++) { + var document = documents[i]; + var declFileName; + if (document.isDeclareFile()) { + declFileName = document.fileName; + } else { + declFileName = this.compiler.mapOutputFileName(document, this.emitOptions, TypeScript.TypeScriptCompiler.mapToDTSFileName); + } + + declFileName = TypeScript.getRelativePathToFixedPath(emittingFilePath, declFileName, false); + this.declFile.WriteLine('/// '); + } + + this.emittedReferencePaths = true; + }; + + DeclarationEmitter.prototype.emitDeclarationsForSourceUnit = function (sourceUnit) { + this.emitReferencePaths(sourceUnit); + this.emitDeclarationsForList(sourceUnit.moduleElements); + }; + return DeclarationEmitter; + })(); + TypeScript.DeclarationEmitter = DeclarationEmitter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var BloomFilter = (function () { + function BloomFilter(expectedCount) { + var m = Math.max(1, BloomFilter.computeM(expectedCount)); + var k = Math.max(1, BloomFilter.computeK(expectedCount)); + ; + + var sizeInEvenBytes = (m + 7) & ~7; + + this.bitArray = []; + for (var i = 0, len = sizeInEvenBytes; i < len; i++) { + this.bitArray[i] = false; + } + this.hashFunctionCount = k; + } + BloomFilter.computeM = function (expectedCount) { + var p = BloomFilter.falsePositiveProbability; + var n = expectedCount; + + var numerator = n * Math.log(p); + var denominator = Math.log(1.0 / Math.pow(2.0, Math.log(2.0))); + return Math.ceil(numerator / denominator); + }; + + BloomFilter.computeK = function (expectedCount) { + var n = expectedCount; + var m = BloomFilter.computeM(expectedCount); + + var temp = Math.log(2.0) * m / n; + return Math.round(temp); + }; + + BloomFilter.prototype.computeHash = function (key, seed) { + return TypeScript.Hash.computeMurmur2StringHashCode(key, seed); + }; + + BloomFilter.prototype.addKeys = function (keys) { + for (var name in keys) { + if (keys[name]) { + this.add(name); + } + } + }; + + BloomFilter.prototype.add = function (value) { + for (var i = 0; i < this.hashFunctionCount; i++) { + var hash = this.computeHash(value, i); + hash = hash % this.bitArray.length; + this.bitArray[Math.abs(hash)] = true; + } + }; + + BloomFilter.prototype.probablyContains = function (value) { + for (var i = 0; i < this.hashFunctionCount; i++) { + var hash = this.computeHash(value, i); + hash = hash % this.bitArray.length; + if (!this.bitArray[Math.abs(hash)]) { + return false; + } + } + + return true; + }; + + BloomFilter.prototype.isEquivalent = function (filter) { + return BloomFilter.isEquivalent(this.bitArray, filter.bitArray) && this.hashFunctionCount == filter.hashFunctionCount; + }; + + BloomFilter.isEquivalent = function (array1, array2) { + if (array1.length != array2.length) { + return false; + } + + for (var i = 0; i < array1.length; i++) { + if (array1[i] != array2[i]) { + return false; + } + } + + return true; + }; + BloomFilter.falsePositiveProbability = 0.0001; + return BloomFilter; + })(); + TypeScript.BloomFilter = BloomFilter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var IdentifierWalker = (function (_super) { + __extends(IdentifierWalker, _super); + function IdentifierWalker(list) { + _super.call(this); + this.list = list; + } + IdentifierWalker.prototype.visitToken = function (token) { + this.list[token.text()] = true; + }; + return IdentifierWalker; + })(TypeScript.SyntaxWalker); + TypeScript.IdentifierWalker = IdentifierWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CompilationSettings = (function () { + function CompilationSettings() { + this.propagateEnumConstants = false; + this.removeComments = false; + this.watch = false; + this.noResolve = false; + this.allowAutomaticSemicolonInsertion = true; + this.noImplicitAny = false; + this.noLib = false; + this.codeGenTarget = 0 /* EcmaScript3 */; + this.moduleGenTarget = 0 /* Unspecified */; + this.outFileOption = ""; + this.outDirOption = ""; + this.mapSourceFiles = false; + this.mapRoot = ""; + this.sourceRoot = ""; + this.generateDeclarationFiles = false; + this.useCaseSensitiveFileResolution = false; + this.gatherDiagnostics = false; + this.codepage = null; + } + return CompilationSettings; + })(); + TypeScript.CompilationSettings = CompilationSettings; + + var ImmutableCompilationSettings = (function () { + function ImmutableCompilationSettings(propagateEnumConstants, removeComments, watch, noResolve, allowAutomaticSemicolonInsertion, noImplicitAny, noLib, codeGenTarget, moduleGenTarget, outFileOption, outDirOption, mapSourceFiles, mapRoot, sourceRoot, generateDeclarationFiles, useCaseSensitiveFileResolution, gatherDiagnostics, codepage) { + this._propagateEnumConstants = propagateEnumConstants; + this._removeComments = removeComments; + this._watch = watch; + this._noResolve = noResolve; + this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion; + this._noImplicitAny = noImplicitAny; + this._noLib = noLib; + this._codeGenTarget = codeGenTarget; + this._moduleGenTarget = moduleGenTarget; + this._outFileOption = outFileOption; + this._outDirOption = outDirOption; + this._mapSourceFiles = mapSourceFiles; + this._mapRoot = mapRoot; + this._sourceRoot = sourceRoot; + this._generateDeclarationFiles = generateDeclarationFiles; + this._useCaseSensitiveFileResolution = useCaseSensitiveFileResolution; + this._gatherDiagnostics = gatherDiagnostics; + this._codepage = codepage; + } + ImmutableCompilationSettings.prototype.propagateEnumConstants = function () { + return this._propagateEnumConstants; + }; + ImmutableCompilationSettings.prototype.removeComments = function () { + return this._removeComments; + }; + ImmutableCompilationSettings.prototype.watch = function () { + return this._watch; + }; + ImmutableCompilationSettings.prototype.noResolve = function () { + return this._noResolve; + }; + ImmutableCompilationSettings.prototype.allowAutomaticSemicolonInsertion = function () { + return this._allowAutomaticSemicolonInsertion; + }; + ImmutableCompilationSettings.prototype.noImplicitAny = function () { + return this._noImplicitAny; + }; + ImmutableCompilationSettings.prototype.noLib = function () { + return this._noLib; + }; + ImmutableCompilationSettings.prototype.codeGenTarget = function () { + return this._codeGenTarget; + }; + ImmutableCompilationSettings.prototype.moduleGenTarget = function () { + return this._moduleGenTarget; + }; + ImmutableCompilationSettings.prototype.outFileOption = function () { + return this._outFileOption; + }; + ImmutableCompilationSettings.prototype.outDirOption = function () { + return this._outDirOption; + }; + ImmutableCompilationSettings.prototype.mapSourceFiles = function () { + return this._mapSourceFiles; + }; + ImmutableCompilationSettings.prototype.mapRoot = function () { + return this._mapRoot; + }; + ImmutableCompilationSettings.prototype.sourceRoot = function () { + return this._sourceRoot; + }; + ImmutableCompilationSettings.prototype.generateDeclarationFiles = function () { + return this._generateDeclarationFiles; + }; + ImmutableCompilationSettings.prototype.useCaseSensitiveFileResolution = function () { + return this._useCaseSensitiveFileResolution; + }; + ImmutableCompilationSettings.prototype.gatherDiagnostics = function () { + return this._gatherDiagnostics; + }; + ImmutableCompilationSettings.prototype.codepage = function () { + return this._codepage; + }; + + ImmutableCompilationSettings.defaultSettings = function () { + if (!ImmutableCompilationSettings._defaultSettings) { + ImmutableCompilationSettings._defaultSettings = ImmutableCompilationSettings.fromCompilationSettings(new CompilationSettings()); + } + + return ImmutableCompilationSettings._defaultSettings; + }; + + ImmutableCompilationSettings.fromCompilationSettings = function (settings) { + return new ImmutableCompilationSettings(settings.propagateEnumConstants, settings.removeComments, settings.watch, settings.noResolve, settings.allowAutomaticSemicolonInsertion, settings.noImplicitAny, settings.noLib, settings.codeGenTarget, settings.moduleGenTarget, settings.outFileOption, settings.outDirOption, settings.mapSourceFiles, settings.mapRoot, settings.sourceRoot, settings.generateDeclarationFiles, settings.useCaseSensitiveFileResolution, settings.gatherDiagnostics, settings.codepage); + }; + + ImmutableCompilationSettings.prototype.toCompilationSettings = function () { + var result = new CompilationSettings(); + + for (var name in this) { + if (this.hasOwnProperty(name) && TypeScript.StringUtilities.startsWith(name, "_")) { + result[name.substr(1)] = this[name]; + } + } + + return result; + }; + return ImmutableCompilationSettings; + })(); + TypeScript.ImmutableCompilationSettings = ImmutableCompilationSettings; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (PullElementFlags) { + PullElementFlags[PullElementFlags["None"] = 0] = "None"; + PullElementFlags[PullElementFlags["Exported"] = 1] = "Exported"; + PullElementFlags[PullElementFlags["Private"] = 1 << 1] = "Private"; + PullElementFlags[PullElementFlags["Public"] = 1 << 2] = "Public"; + PullElementFlags[PullElementFlags["Ambient"] = 1 << 3] = "Ambient"; + PullElementFlags[PullElementFlags["Static"] = 1 << 4] = "Static"; + PullElementFlags[PullElementFlags["Optional"] = 1 << 7] = "Optional"; + PullElementFlags[PullElementFlags["Signature"] = 1 << 11] = "Signature"; + PullElementFlags[PullElementFlags["Enum"] = 1 << 12] = "Enum"; + PullElementFlags[PullElementFlags["ArrowFunction"] = 1 << 13] = "ArrowFunction"; + + PullElementFlags[PullElementFlags["ClassConstructorVariable"] = 1 << 14] = "ClassConstructorVariable"; + PullElementFlags[PullElementFlags["InitializedModule"] = 1 << 15] = "InitializedModule"; + PullElementFlags[PullElementFlags["InitializedDynamicModule"] = 1 << 16] = "InitializedDynamicModule"; + + PullElementFlags[PullElementFlags["MustCaptureThis"] = 1 << 18] = "MustCaptureThis"; + + PullElementFlags[PullElementFlags["DeclaredInAWithBlock"] = 1 << 21] = "DeclaredInAWithBlock"; + + PullElementFlags[PullElementFlags["HasReturnStatement"] = 1 << 22] = "HasReturnStatement"; + + PullElementFlags[PullElementFlags["PropertyParameter"] = 1 << 23] = "PropertyParameter"; + + PullElementFlags[PullElementFlags["IsAnnotatedWithAny"] = 1 << 24] = "IsAnnotatedWithAny"; + + PullElementFlags[PullElementFlags["HasDefaultArgs"] = 1 << 25] = "HasDefaultArgs"; + + PullElementFlags[PullElementFlags["ConstructorParameter"] = 1 << 26] = "ConstructorParameter"; + + PullElementFlags[PullElementFlags["ImplicitVariable"] = PullElementFlags.ClassConstructorVariable | PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "ImplicitVariable"; + PullElementFlags[PullElementFlags["SomeInitializedModule"] = PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "SomeInitializedModule"; + })(TypeScript.PullElementFlags || (TypeScript.PullElementFlags = {})); + var PullElementFlags = TypeScript.PullElementFlags; + + function hasModifier(modifiers, flag) { + for (var i = 0, n = modifiers.length; i < n; i++) { + if (TypeScript.hasFlag(modifiers[i], flag)) { + return true; + } + } + + return false; + } + TypeScript.hasModifier = hasModifier; + + (function (PullElementKind) { + PullElementKind[PullElementKind["None"] = 0] = "None"; + PullElementKind[PullElementKind["Global"] = 0] = "Global"; + + PullElementKind[PullElementKind["Script"] = 1 << 0] = "Script"; + PullElementKind[PullElementKind["Primitive"] = 1 << 1] = "Primitive"; + + PullElementKind[PullElementKind["Container"] = 1 << 2] = "Container"; + PullElementKind[PullElementKind["Class"] = 1 << 3] = "Class"; + PullElementKind[PullElementKind["Interface"] = 1 << 4] = "Interface"; + PullElementKind[PullElementKind["DynamicModule"] = 1 << 5] = "DynamicModule"; + PullElementKind[PullElementKind["Enum"] = 1 << 6] = "Enum"; + PullElementKind[PullElementKind["TypeAlias"] = 1 << 7] = "TypeAlias"; + PullElementKind[PullElementKind["ObjectLiteral"] = 1 << 8] = "ObjectLiteral"; + + PullElementKind[PullElementKind["Variable"] = 1 << 9] = "Variable"; + PullElementKind[PullElementKind["CatchVariable"] = 1 << 10] = "CatchVariable"; + PullElementKind[PullElementKind["Parameter"] = 1 << 11] = "Parameter"; + PullElementKind[PullElementKind["Property"] = 1 << 12] = "Property"; + PullElementKind[PullElementKind["TypeParameter"] = 1 << 13] = "TypeParameter"; + + PullElementKind[PullElementKind["Function"] = 1 << 14] = "Function"; + PullElementKind[PullElementKind["ConstructorMethod"] = 1 << 15] = "ConstructorMethod"; + PullElementKind[PullElementKind["Method"] = 1 << 16] = "Method"; + PullElementKind[PullElementKind["FunctionExpression"] = 1 << 17] = "FunctionExpression"; + + PullElementKind[PullElementKind["GetAccessor"] = 1 << 18] = "GetAccessor"; + PullElementKind[PullElementKind["SetAccessor"] = 1 << 19] = "SetAccessor"; + + PullElementKind[PullElementKind["CallSignature"] = 1 << 20] = "CallSignature"; + PullElementKind[PullElementKind["ConstructSignature"] = 1 << 21] = "ConstructSignature"; + PullElementKind[PullElementKind["IndexSignature"] = 1 << 22] = "IndexSignature"; + + PullElementKind[PullElementKind["ObjectType"] = 1 << 23] = "ObjectType"; + PullElementKind[PullElementKind["FunctionType"] = 1 << 24] = "FunctionType"; + PullElementKind[PullElementKind["ConstructorType"] = 1 << 25] = "ConstructorType"; + + PullElementKind[PullElementKind["EnumMember"] = 1 << 26] = "EnumMember"; + + PullElementKind[PullElementKind["WithBlock"] = 1 << 27] = "WithBlock"; + PullElementKind[PullElementKind["CatchBlock"] = 1 << 28] = "CatchBlock"; + + PullElementKind[PullElementKind["All"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Container | PullElementKind.Class | PullElementKind.Interface | PullElementKind.DynamicModule | PullElementKind.Enum | PullElementKind.TypeAlias | PullElementKind.ObjectLiteral | PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.TypeParameter | PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor | PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.EnumMember | PullElementKind.WithBlock | PullElementKind.CatchBlock] = "All"; + + PullElementKind[PullElementKind["SomeFunction"] = PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor] = "SomeFunction"; + + PullElementKind[PullElementKind["SomeValue"] = PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.EnumMember | PullElementKind.SomeFunction] = "SomeValue"; + + PullElementKind[PullElementKind["SomeType"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.TypeParameter] = "SomeType"; + + PullElementKind[PullElementKind["AcceptableAlias"] = PullElementKind.Variable | PullElementKind.SomeFunction | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.Container | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "AcceptableAlias"; + + PullElementKind[PullElementKind["SomeContainer"] = PullElementKind.Container | PullElementKind.DynamicModule | PullElementKind.TypeAlias] = "SomeContainer"; + + PullElementKind[PullElementKind["SomeSignature"] = PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature] = "SomeSignature"; + + PullElementKind[PullElementKind["SomeTypeReference"] = PullElementKind.Interface | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "SomeTypeReference"; + + PullElementKind[PullElementKind["SomeInstantiatableType"] = PullElementKind.Class | PullElementKind.Interface | PullElementKind.TypeParameter] = "SomeInstantiatableType"; + })(TypeScript.PullElementKind || (TypeScript.PullElementKind = {})); + var PullElementKind = TypeScript.PullElementKind; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.pullDeclID = 0; + var sentinelEmptyPullDeclArray = []; + + var PullDecl = (function () { + function PullDecl(declName, displayName, kind, declFlags, span) { + this.declID = TypeScript.pullDeclID++; + this.flags = 0 /* None */; + this.declGroups = null; + this.childDecls = null; + this.typeParameters = null; + this.synthesizedValDecl = null; + this.childDeclTypeCache = null; + this.childDeclValueCache = null; + this.childDeclNamespaceCache = null; + this.childDeclTypeParameterCache = null; + this.name = declName; + this.kind = kind; + this.flags = declFlags; + this.span = span; + + if (displayName !== this.name) { + this.declDisplayName = displayName; + } + } + PullDecl.prototype.fileName = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getParentPath = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getParentDecl = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.semanticInfoChain = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.isExternalModule = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getEnclosingDecl = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype._getEnclosingDeclFromParentDecl = function () { + var decl = this; + while (decl) { + switch (decl.kind) { + default: + return decl; + case 512 /* Variable */: + case 8192 /* TypeParameter */: + case 2048 /* Parameter */: + case 128 /* TypeAlias */: + case 67108864 /* EnumMember */: + } + + decl = decl.getParentDecl(); + } + + TypeScript.Debug.fail(); + }; + + PullDecl.prototype.getDisplayName = function () { + return this.declDisplayName === undefined ? this.name : this.declDisplayName; + }; + + PullDecl.prototype.setSymbol = function (symbol) { + this.semanticInfoChain().setSymbolForDecl(this, symbol); + }; + + PullDecl.prototype.ensureSymbolIsBound = function (bindSignatureSymbol) { + if (typeof bindSignatureSymbol === "undefined") { bindSignatureSymbol = false; } + if (!((bindSignatureSymbol && this.hasSignatureSymbol()) || this.hasSymbol()) && this.kind != 1 /* Script */) { + var binder = this.semanticInfoChain().getBinder(); + binder.bindDeclToPullSymbol(this); + } + }; + + PullDecl.prototype.getSymbol = function () { + if (this.kind == 1 /* Script */) { + return null; + } + + this.ensureSymbolIsBound(); + + return this.semanticInfoChain().getSymbolForDecl(this); + }; + + PullDecl.prototype.hasSymbol = function () { + var symbol = this.semanticInfoChain().getSymbolForDecl(this); + return !!symbol; + }; + + PullDecl.prototype.setSignatureSymbol = function (signatureSymbol) { + this.semanticInfoChain().setSignatureSymbolForDecl(this, signatureSymbol); + }; + + PullDecl.prototype.getSignatureSymbol = function () { + this.ensureSymbolIsBound(true); + + return this.semanticInfoChain().getSignatureSymbolForDecl(this); + }; + + PullDecl.prototype.hasSignatureSymbol = function () { + var signatureSymbol = this.semanticInfoChain().getSignatureSymbolForDecl(this); + return !!signatureSymbol; + }; + + PullDecl.prototype.setFlags = function (flags) { + this.flags = flags; + }; + + PullDecl.prototype.setFlag = function (flags) { + this.flags |= flags; + }; + + PullDecl.prototype.getSpan = function () { + return this.span; + }; + + PullDecl.prototype.setValueDecl = function (valDecl) { + this.synthesizedValDecl = valDecl; + }; + + PullDecl.prototype.getValueDecl = function () { + return this.synthesizedValDecl; + }; + + PullDecl.prototype.isEqual = function (other) { + return (this.name === other.name) && (this.kind === other.kind) && (this.flags === other.flags) && (this.fileName() === other.fileName()) && (this.span.start() === other.span.start()) && (this.span.end() === other.span.end()); + }; + + PullDecl.prototype.getChildDeclCache = function (declKind) { + if (declKind === 8192 /* TypeParameter */) { + if (!this.childDeclTypeParameterCache) { + this.childDeclTypeParameterCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclTypeParameterCache; + } else if (TypeScript.hasFlag(declKind, 164 /* SomeContainer */)) { + if (!this.childDeclNamespaceCache) { + this.childDeclNamespaceCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclNamespaceCache; + } else if (TypeScript.hasFlag(declKind, 58728539 /* SomeType */)) { + if (!this.childDeclTypeCache) { + this.childDeclTypeCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclTypeCache; + } else { + if (!this.childDeclValueCache) { + this.childDeclValueCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclValueCache; + } + }; + + PullDecl.prototype.addChildDecl = function (childDecl) { + if (childDecl.kind === 8192 /* TypeParameter */) { + if (!this.typeParameters) { + this.typeParameters = []; + } + this.typeParameters[this.typeParameters.length] = childDecl; + } else { + if (!this.childDecls) { + this.childDecls = []; + } + this.childDecls[this.childDecls.length] = childDecl; + } + + var declName = childDecl.name; + + if (!(childDecl.kind & 7340032 /* SomeSignature */)) { + var cache = this.getChildDeclCache(childDecl.kind); + var childrenOfName = cache[declName]; + if (!childrenOfName) { + childrenOfName = []; + } + + childrenOfName.push(childDecl); + cache[declName] = childrenOfName; + } + }; + + PullDecl.prototype.searchChildDecls = function (declName, searchKind) { + var cacheVal = null; + + if (searchKind & 58728539 /* SomeType */) { + cacheVal = this.childDeclTypeCache ? this.childDeclTypeCache[declName] : null; + } else if (searchKind & 164 /* SomeContainer */) { + cacheVal = this.childDeclNamespaceCache ? this.childDeclNamespaceCache[declName] : null; + } else { + cacheVal = this.childDeclValueCache ? this.childDeclValueCache[declName] : null; + } + + if (cacheVal) { + return cacheVal; + } else { + if (searchKind & 58728539 /* SomeType */) { + cacheVal = this.childDeclTypeParameterCache ? this.childDeclTypeParameterCache[declName] : null; + + if (cacheVal) { + return cacheVal; + } + } + + return sentinelEmptyPullDeclArray; + } + }; + + PullDecl.prototype.getChildDecls = function () { + return this.childDecls ? this.childDecls : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.getTypeParameters = function () { + return this.typeParameters ? this.typeParameters : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.addVariableDeclToGroup = function (decl) { + if (!this.declGroups) { + this.declGroups = TypeScript.createIntrinsicsObject(); + } + + var declGroup = this.declGroups[decl.name]; + if (declGroup) { + declGroup.addDecl(decl); + } else { + declGroup = new PullDeclGroup(decl.name); + declGroup.addDecl(decl); + this.declGroups[decl.name] = declGroup; + } + }; + + PullDecl.prototype.getVariableDeclGroups = function () { + var declGroups = null; + + if (this.declGroups) { + for (var declName in this.declGroups) { + if (this.declGroups[declName]) { + if (declGroups === null) { + declGroups = []; + } + + declGroups.push(this.declGroups[declName].getDecls()); + } + } + } + + return declGroups ? declGroups : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.hasBeenBound = function () { + return this.hasSymbol() || this.hasSignatureSymbol(); + }; + + PullDecl.prototype.isSynthesized = function () { + return false; + }; + + PullDecl.prototype.ast = function () { + var semanticInfoChain = this.semanticInfoChain(); + return semanticInfoChain ? semanticInfoChain.getASTForDecl(this) : null; + }; + return PullDecl; + })(); + TypeScript.PullDecl = PullDecl; + + var RootPullDecl = (function (_super) { + __extends(RootPullDecl, _super); + function RootPullDecl(name, fileName, kind, declFlags, span, semanticInfoChain, isExternalModule) { + _super.call(this, name, name, kind, declFlags, span); + this._semanticInfoChain = semanticInfoChain; + this._isExternalModule = isExternalModule; + this._fileName = fileName; + } + RootPullDecl.prototype.fileName = function () { + return this._fileName; + }; + + RootPullDecl.prototype.getParentPath = function () { + return [this]; + }; + + RootPullDecl.prototype.getParentDecl = function () { + return null; + }; + + RootPullDecl.prototype.semanticInfoChain = function () { + return this._semanticInfoChain; + }; + + RootPullDecl.prototype.isExternalModule = function () { + return this._isExternalModule; + }; + + RootPullDecl.prototype.getEnclosingDecl = function () { + return this; + }; + return RootPullDecl; + })(PullDecl); + TypeScript.RootPullDecl = RootPullDecl; + + var NormalPullDecl = (function (_super) { + __extends(NormalPullDecl, _super); + function NormalPullDecl(declName, displayName, kind, declFlags, parentDecl, span, addToParent) { + if (typeof addToParent === "undefined") { addToParent = true; } + _super.call(this, declName, displayName, kind, declFlags, span); + this.parentDecl = null; + this.parentPath = null; + + this.parentDecl = parentDecl; + if (addToParent) { + parentDecl.addChildDecl(this); + } + } + NormalPullDecl.prototype.fileName = function () { + return this.parentDecl ? this.parentDecl.fileName() : ""; + }; + + NormalPullDecl.prototype.getParentDecl = function () { + return this.parentDecl; + }; + + NormalPullDecl.prototype.getParentPath = function () { + if (!this.parentPath) { + var path = [this]; + var parentDecl = this.parentDecl; + + while (parentDecl) { + if (parentDecl && path[path.length - 1] != parentDecl && !(parentDecl.kind & 256 /* ObjectLiteral */)) { + path.unshift(parentDecl); + } + + parentDecl = parentDecl.getParentDecl(); + } + + this.parentPath = path; + } + + return this.parentPath; + }; + + NormalPullDecl.prototype.semanticInfoChain = function () { + var parent = this.getParentDecl(); + return parent ? parent.semanticInfoChain() : null; + }; + + NormalPullDecl.prototype.isExternalModule = function () { + return false; + }; + + NormalPullDecl.prototype.getEnclosingDecl = function () { + return this.parentDecl && this.parentDecl._getEnclosingDeclFromParentDecl(); + }; + return NormalPullDecl; + })(PullDecl); + TypeScript.NormalPullDecl = NormalPullDecl; + + var PullEnumElementDecl = (function (_super) { + __extends(PullEnumElementDecl, _super); + function PullEnumElementDecl(declName, displayName, parentDecl, span) { + _super.call(this, declName, displayName, 67108864 /* EnumMember */, 4 /* Public */, parentDecl, span); + this.constantValue = null; + } + return PullEnumElementDecl; + })(NormalPullDecl); + TypeScript.PullEnumElementDecl = PullEnumElementDecl; + + var PullFunctionExpressionDecl = (function (_super) { + __extends(PullFunctionExpressionDecl, _super); + function PullFunctionExpressionDecl(expressionName, declFlags, parentDecl, span, displayName) { + if (typeof displayName === "undefined") { displayName = ""; } + _super.call(this, "", displayName, 131072 /* FunctionExpression */, declFlags, parentDecl, span); + this.functionExpressionName = expressionName; + } + PullFunctionExpressionDecl.prototype.getFunctionExpressionName = function () { + return this.functionExpressionName; + }; + return PullFunctionExpressionDecl; + })(NormalPullDecl); + TypeScript.PullFunctionExpressionDecl = PullFunctionExpressionDecl; + + var PullSynthesizedDecl = (function (_super) { + __extends(PullSynthesizedDecl, _super); + function PullSynthesizedDecl(declName, displayName, kind, declFlags, parentDecl, span, semanticInfoChain) { + _super.call(this, declName, displayName, kind, declFlags, parentDecl, span, false); + this._semanticInfoChain = semanticInfoChain; + } + PullSynthesizedDecl.prototype.semanticInfoChain = function () { + return this._semanticInfoChain; + }; + + PullSynthesizedDecl.prototype.isSynthesized = function () { + return true; + }; + return PullSynthesizedDecl; + })(NormalPullDecl); + TypeScript.PullSynthesizedDecl = PullSynthesizedDecl; + + var PullDeclGroup = (function () { + function PullDeclGroup(name) { + this.name = name; + this._decls = []; + } + PullDeclGroup.prototype.addDecl = function (decl) { + if (decl.name === this.name) { + this._decls[this._decls.length] = decl; + } + }; + + PullDeclGroup.prototype.getDecls = function () { + return this._decls; + }; + return PullDeclGroup; + })(); + TypeScript.PullDeclGroup = PullDeclGroup; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.pullSymbolID = 0; + TypeScript.globalTyvarID = 0; + TypeScript.sentinelEmptyArray = []; + + var PullSymbol = (function () { + function PullSymbol(name, declKind) { + this.pullSymbolID = TypeScript.pullSymbolID++; + this._container = null; + this.type = null; + this._declarations = null; + this.isResolved = false; + this.isOptional = false; + this.inResolution = false; + this.isSynthesized = false; + this.isVarArg = false; + this.rootSymbol = null; + this._enclosingSignature = null; + this._docComments = null; + this.isPrinting = false; + this.name = name; + this.kind = declKind; + } + PullSymbol.prototype.isAny = function () { + return false; + }; + + PullSymbol.prototype.isType = function () { + return (this.kind & 58728539 /* SomeType */) != 0; + }; + + PullSymbol.prototype.isTypeReference = function () { + return false; + }; + + PullSymbol.prototype.isSignature = function () { + return (this.kind & 7340032 /* SomeSignature */) != 0; + }; + + PullSymbol.prototype.isArrayNamedTypeReference = function () { + return false; + }; + + PullSymbol.prototype.isPrimitive = function () { + return this.kind === 2 /* Primitive */; + }; + + PullSymbol.prototype.isAccessor = function () { + return false; + }; + + PullSymbol.prototype.isError = function () { + return false; + }; + + PullSymbol.prototype.isInterface = function () { + return this.kind === 16 /* Interface */; + }; + + PullSymbol.prototype.isMethod = function () { + return this.kind === 65536 /* Method */; + }; + + PullSymbol.prototype.isProperty = function () { + return this.kind === 4096 /* Property */; + }; + + PullSymbol.prototype.isAlias = function () { + return false; + }; + + PullSymbol.prototype.isContainer = function () { + return false; + }; + + PullSymbol.prototype.findAliasedType = function (scopeSymbol, skipScopeSymbolAliasesLookIn, lookIntoOnlyExportedAlias, aliasSymbols, visitedScopeDeclarations) { + if (typeof aliasSymbols === "undefined") { aliasSymbols = []; } + if (typeof visitedScopeDeclarations === "undefined") { visitedScopeDeclarations = []; } + var scopeDeclarations = scopeSymbol.getDeclarations(); + var scopeSymbolAliasesToLookIn = []; + + for (var i = 0; i < scopeDeclarations.length; i++) { + var scopeDecl = scopeDeclarations[i]; + if (!TypeScript.ArrayUtilities.contains(visitedScopeDeclarations, scopeDecl)) { + visitedScopeDeclarations.push(scopeDecl); + + var childDecls = scopeDecl.getChildDecls(); + for (var j = 0; j < childDecls.length; j++) { + var childDecl = childDecls[j]; + if (childDecl.kind === 128 /* TypeAlias */ && (!lookIntoOnlyExportedAlias || (childDecl.flags & 1 /* Exported */))) { + var symbol = childDecl.getSymbol(); + + if (PullContainerSymbol.usedAsSymbol(symbol, this) || (this.rootSymbol && PullContainerSymbol.usedAsSymbol(symbol, this.rootSymbol))) { + aliasSymbols.push(symbol); + return aliasSymbols; + } + + if (!skipScopeSymbolAliasesLookIn && this.isExternalModuleReferenceAlias(symbol) && (!symbol.assignedContainer().hasExportAssignment() || (symbol.assignedContainer().getExportAssignedContainerSymbol() && symbol.assignedContainer().getExportAssignedContainerSymbol().kind == 32 /* DynamicModule */))) { + scopeSymbolAliasesToLookIn.push(symbol); + } + } + } + } + } + + for (var i = 0; i < scopeSymbolAliasesToLookIn.length; i++) { + var scopeSymbolAlias = scopeSymbolAliasesToLookIn[i]; + + aliasSymbols.push(scopeSymbolAlias); + var result = this.findAliasedType(scopeSymbolAlias.assignedContainer().hasExportAssignment() ? scopeSymbolAlias.assignedContainer().getExportAssignedContainerSymbol() : scopeSymbolAlias.assignedContainer(), false, true, aliasSymbols, visitedScopeDeclarations); + if (result) { + return result; + } + + aliasSymbols.pop(); + } + + return null; + }; + + PullSymbol.prototype.getExternalAliasedSymbols = function (scopeSymbol) { + if (!scopeSymbol) { + return null; + } + + var scopePath = scopeSymbol.pathToRoot(); + if (scopePath.length && scopePath[scopePath.length - 1].kind === 32 /* DynamicModule */) { + var symbols = this.findAliasedType(scopePath[scopePath.length - 1]); + return symbols; + } + + return null; + }; + + PullSymbol.prototype.isExternalModuleReferenceAlias = function (aliasSymbol) { + if (aliasSymbol) { + if (aliasSymbol.assignedValue()) { + return false; + } + + if (aliasSymbol.assignedType() && aliasSymbol.assignedType() != aliasSymbol.assignedContainer()) { + return false; + } + + if (aliasSymbol.assignedContainer() && aliasSymbol.assignedContainer().kind != 32 /* DynamicModule */) { + return false; + } + + return true; + } + + return false; + }; + + PullSymbol.prototype.getExportedInternalAliasSymbol = function (scopeSymbol) { + if (scopeSymbol) { + if (this.kind != 128 /* TypeAlias */) { + var scopePath = scopeSymbol.pathToRoot(); + for (var i = 0; i < scopePath.length; i++) { + var internalAliases = this.findAliasedType(scopeSymbol, true, true); + if (internalAliases) { + TypeScript.Debug.assert(internalAliases.length == 1); + return internalAliases[0]; + } + } + } + } + + return null; + }; + + PullSymbol.prototype.getAliasSymbolName = function (scopeSymbol, aliasNameGetter, aliasPartsNameGetter, skipInternalAlias) { + if (!skipInternalAlias) { + var internalAlias = this.getExportedInternalAliasSymbol(scopeSymbol); + if (internalAlias) { + return aliasNameGetter(internalAlias); + } + } + + var externalAliases = this.getExternalAliasedSymbols(scopeSymbol); + + if (externalAliases && this.isExternalModuleReferenceAlias(externalAliases[externalAliases.length - 1])) { + var aliasFullName = ""; + for (var i = 1, symbolsLen = externalAliases.length; i < symbolsLen; i++) { + aliasFullName = aliasFullName + "." + aliasPartsNameGetter(externalAliases[i]); + } + return aliasNameGetter(externalAliases[0]) + aliasFullName; + } + + return null; + }; + + PullSymbol.prototype._getResolver = function () { + TypeScript.Debug.assert(this._declarations && this._declarations.length > 0); + return this._declarations[0].semanticInfoChain().getResolver(); + }; + + PullSymbol.prototype._resolveDeclaredSymbol = function () { + return this._getResolver().resolveDeclaredSymbol(this); + }; + + PullSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + var aliasName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getName(scopeSymbol, useConstraintInName); + }, function (symbol) { + return symbol.getName(); + }); + if (aliasName != null) { + return aliasName; + } + + return this.name; + }; + + PullSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + var aliasDisplayName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getDisplayName(scopeSymbol, useConstraintInName); + }, function (symbol) { + return symbol.getDisplayName(); + }, skipInternalAliasName); + if (aliasDisplayName != null) { + return aliasDisplayName; + } + + var decls = this.getDeclarations(); + var name = decls.length && decls[0].getDisplayName(); + + return (name && name.length) ? name : this.name; + }; + + PullSymbol.prototype.getIsSpecialized = function () { + return false; + }; + + PullSymbol.prototype.getRootSymbol = function () { + if (!this.rootSymbol) { + return this; + } + return this.rootSymbol; + }; + PullSymbol.prototype.setRootSymbol = function (symbol) { + this.rootSymbol = symbol; + }; + + PullSymbol.prototype.setIsSynthesized = function (value) { + if (typeof value === "undefined") { value = true; } + this.isSynthesized = value; + }; + + PullSymbol.prototype.getIsSynthesized = function () { + return this.isSynthesized; + }; + + PullSymbol.prototype.setEnclosingSignature = function (signature) { + this._enclosingSignature = signature; + }; + + PullSymbol.prototype.getEnclosingSignature = function () { + return this._enclosingSignature; + }; + + PullSymbol.prototype.addDeclaration = function (decl) { + TypeScript.Debug.assert(!!decl); + + if (this.rootSymbol) { + return; + } + + if (!this._declarations) { + this._declarations = [decl]; + } else { + this._declarations[this._declarations.length] = decl; + } + }; + + PullSymbol.prototype.getDeclarations = function () { + if (this.rootSymbol) { + return this.rootSymbol.getDeclarations(); + } + + if (!this._declarations) { + this._declarations = []; + } + + return this._declarations; + }; + + PullSymbol.prototype.hasDeclaration = function (decl) { + if (!this._declarations) { + return false; + } + + return TypeScript.ArrayUtilities.any(this._declarations, function (eachDecl) { + return eachDecl === decl; + }); + }; + + PullSymbol.prototype.setContainer = function (containerSymbol) { + if (this.rootSymbol) { + return; + } + + this._container = containerSymbol; + }; + + PullSymbol.prototype.getContainer = function () { + if (this.rootSymbol) { + return this.rootSymbol.getContainer(); + } + + return this._container; + }; + + PullSymbol.prototype.setResolved = function () { + this.isResolved = true; + this.inResolution = false; + }; + + PullSymbol.prototype.startResolving = function () { + this.inResolution = true; + }; + + PullSymbol.prototype.setUnresolved = function () { + this.isResolved = false; + this.inResolution = false; + }; + + PullSymbol.prototype.anyDeclHasFlag = function (flag) { + var declarations = this.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + if (TypeScript.hasFlag(declarations[i].flags, flag)) { + return true; + } + } + return false; + }; + + PullSymbol.prototype.allDeclsHaveFlag = function (flag) { + var declarations = this.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + if (!TypeScript.hasFlag(declarations[i].flags, flag)) { + return false; + } + } + return true; + }; + + PullSymbol.prototype.pathToRoot = function () { + var path = []; + var node = this; + while (node) { + if (node.isType()) { + var associatedContainerSymbol = node.getAssociatedContainerType(); + if (associatedContainerSymbol) { + node = associatedContainerSymbol; + } + } + path[path.length] = node; + var nodeKind = node.kind; + if (nodeKind == 2048 /* Parameter */) { + break; + } else { + node = node.getContainer(); + } + } + return path; + }; + + PullSymbol.prototype.findCommonAncestorPath = function (b) { + var aPath = this.pathToRoot(); + if (aPath.length === 1) { + return aPath; + } + + var bPath; + if (b) { + bPath = b.pathToRoot(); + } else { + return aPath; + } + + var commonNodeIndex = -1; + for (var i = 0, aLen = aPath.length; i < aLen; i++) { + var aNode = aPath[i]; + for (var j = 0, bLen = bPath.length; j < bLen; j++) { + var bNode = bPath[j]; + if (aNode === bNode) { + var aDecl = null; + if (i > 0) { + var decls = aPath[i - 1].getDeclarations(); + if (decls.length) { + aDecl = decls[0].getParentDecl(); + } + } + var bDecl = null; + if (j > 0) { + var decls = bPath[j - 1].getDeclarations(); + if (decls.length) { + bDecl = decls[0].getParentDecl(); + } + } + if (!aDecl || !bDecl || aDecl == bDecl) { + commonNodeIndex = i; + break; + } + } + } + if (commonNodeIndex >= 0) { + break; + } + } + + if (commonNodeIndex >= 0) { + return aPath.slice(0, commonNodeIndex); + } else { + return aPath; + } + }; + + PullSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var str = this.getNameAndTypeName(scopeSymbol); + return str; + }; + + PullSymbol.prototype.getNamePartForFullName = function () { + return this.getDisplayName(null, true); + }; + + PullSymbol.prototype.fullName = function (scopeSymbol) { + var path = this.pathToRoot(); + var fullName = ""; + + var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.fullName(scopeSymbol); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }); + if (aliasFullName != null) { + return aliasFullName; + } + + for (var i = 1; i < path.length; i++) { + var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.fullName(scopeSymbol); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }); + if (aliasFullName != null) { + fullName = aliasFullName + "." + fullName; + break; + } + + var scopedName = path[i].getNamePartForFullName(); + if (path[i].kind == 32 /* DynamicModule */ && !TypeScript.isQuoted(scopedName)) { + break; + } + + if (scopedName === "") { + break; + } + + fullName = scopedName + "." + fullName; + } + + fullName = fullName + this.getNamePartForFullName(); + return fullName; + }; + + PullSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) { + var path = this.findCommonAncestorPath(scopeSymbol); + var fullName = ""; + + var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }, skipInternalAliasName); + if (aliasFullName != null) { + return aliasFullName; + } + + for (var i = 1; i < path.length; i++) { + var kind = path[i].kind; + if (kind === 4 /* Container */ || kind === 32 /* DynamicModule */) { + var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, false, skipInternalAliasName); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }, skipInternalAliasName); + if (aliasFullName != null) { + fullName = aliasFullName + "." + fullName; + break; + } + + if (kind === 4 /* Container */) { + fullName = path[i].getDisplayName() + "." + fullName; + } else { + var displayName = path[i].getDisplayName(); + if (TypeScript.isQuoted(displayName)) { + fullName = displayName + "." + fullName; + } + break; + } + } else { + break; + } + } + fullName = fullName + this.getDisplayName(scopeSymbol, useConstraintInName, skipInternalAliasName); + return fullName; + }; + + PullSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) { + var name = this.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + return TypeScript.MemberName.create(name); + }; + + PullSymbol.prototype.getTypeName = function (scopeSymbol, getPrettyTypeName) { + var memberName = this.getTypeNameEx(scopeSymbol, getPrettyTypeName); + return memberName.toString(); + }; + + PullSymbol.prototype.getTypeNameEx = function (scopeSymbol, getPrettyTypeName) { + var type = this.type; + if (type) { + var memberName = getPrettyTypeName ? this.getTypeNameForFunctionSignature("", scopeSymbol, getPrettyTypeName) : null; + if (!memberName) { + memberName = type.getScopedNameEx(scopeSymbol, false, true, getPrettyTypeName); + } + + return memberName; + } + return TypeScript.MemberName.create(""); + }; + + PullSymbol.prototype.getTypeNameForFunctionSignature = function (prefix, scopeSymbol, getPrettyTypeName) { + var type = this.type; + if (type && !type.isNamedTypeSymbol() && this.kind != 4096 /* Property */ && this.kind != 512 /* Variable */ && this.kind != 2048 /* Parameter */) { + var signatures = type.getCallSignatures(); + if (signatures.length == 1 || (getPrettyTypeName && signatures.length)) { + var typeName = new TypeScript.MemberNameArray(); + var signatureName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, prefix, false, false, scopeSymbol, getPrettyTypeName); + typeName.addAll(signatureName); + return typeName; + } + } + + return null; + }; + + PullSymbol.prototype.getNameAndTypeName = function (scopeSymbol) { + var nameAndTypeName = this.getNameAndTypeNameEx(scopeSymbol); + return nameAndTypeName.toString(); + }; + + PullSymbol.prototype.getNameAndTypeNameEx = function (scopeSymbol) { + var type = this.type; + var nameStr = this.getDisplayName(scopeSymbol); + if (type) { + nameStr = nameStr + (this.isOptional ? "?" : ""); + var memberName = this.getTypeNameForFunctionSignature(nameStr, scopeSymbol); + if (!memberName) { + var typeNameEx = type.getScopedNameEx(scopeSymbol); + memberName = TypeScript.MemberName.create(typeNameEx, nameStr + ": ", ""); + } + return memberName; + } + return TypeScript.MemberName.create(nameStr); + }; + + PullSymbol.getTypeParameterString = function (typars, scopeSymbol, useContraintInName) { + return PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, undefined, useContraintInName).toString(); + }; + + PullSymbol.getTypeParameterStringEx = function (typeParameters, scopeSymbol, getTypeParamMarkerInfo, useContraintInName) { + var builder = new TypeScript.MemberNameArray(); + builder.prefix = ""; + + if (typeParameters && typeParameters.length) { + builder.add(TypeScript.MemberName.create("<")); + + for (var i = 0; i < typeParameters.length; i++) { + if (i) { + builder.add(TypeScript.MemberName.create(", ")); + } + + if (getTypeParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + + builder.add(typeParameters[i].getScopedNameEx(scopeSymbol, false, useContraintInName)); + + if (getTypeParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + } + + builder.add(TypeScript.MemberName.create(">")); + } + + return builder; + }; + + PullSymbol.getIsExternallyVisible = function (symbol, fromIsExternallyVisibleSymbol, inIsExternallyVisibleSymbols) { + if (inIsExternallyVisibleSymbols) { + for (var i = 0; i < inIsExternallyVisibleSymbols.length; i++) { + if (inIsExternallyVisibleSymbols[i] === symbol) { + return true; + } + } + } else { + inIsExternallyVisibleSymbols = []; + } + + if (fromIsExternallyVisibleSymbol === symbol) { + return true; + } + + inIsExternallyVisibleSymbols.push(fromIsExternallyVisibleSymbol); + + var result = symbol.isExternallyVisible(inIsExternallyVisibleSymbols); + + TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(inIsExternallyVisibleSymbols) === fromIsExternallyVisibleSymbol); + inIsExternallyVisibleSymbols.pop(); + + return result; + }; + + PullSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) { + var kind = this.kind; + if (kind === 2 /* Primitive */) { + return true; + } + + if (this.rootSymbol) { + return PullSymbol.getIsExternallyVisible(this.rootSymbol, this, inIsExternallyVisibleSymbols); + } + + if (this.isType()) { + var associatedContainerSymbol = this.getAssociatedContainerType(); + if (associatedContainerSymbol) { + return PullSymbol.getIsExternallyVisible(associatedContainerSymbol, this, inIsExternallyVisibleSymbols); + } + } + + if (this.anyDeclHasFlag(2 /* Private */)) { + return false; + } + + var container = this.getContainer(); + if (container === null) { + var decls = this.getDeclarations(); + if (decls.length) { + var parentDecl = decls[0].getParentDecl(); + if (parentDecl) { + var parentSymbol = parentDecl.getSymbol(); + if (!parentSymbol || parentDecl.kind == 1 /* Script */) { + return true; + } + + return PullSymbol.getIsExternallyVisible(parentSymbol, this, inIsExternallyVisibleSymbols); + } + } + + return true; + } + + if (container.kind == 32 /* DynamicModule */ || (container.getAssociatedContainerType() && container.getAssociatedContainerType().kind == 32 /* DynamicModule */)) { + var containerSymbol = container.kind == 32 /* DynamicModule */ ? container : container.getAssociatedContainerType(); + if (PullContainerSymbol.usedAsSymbol(containerSymbol, this)) { + return true; + } + } + + if (!this.anyDeclHasFlag(1 /* Exported */) && kind != 4096 /* Property */ && kind != 65536 /* Method */) { + return false; + } + + return PullSymbol.getIsExternallyVisible(container, this, inIsExternallyVisibleSymbols); + }; + + PullSymbol.prototype.getDocCommentsOfDecl = function (decl) { + var ast = decl.ast(); + + if (ast) { + var enclosingModuleDeclaration = TypeScript.getEnclosingModuleDeclaration(ast); + if (TypeScript.isLastNameOfModule(enclosingModuleDeclaration, ast)) { + return TypeScript.docComments(enclosingModuleDeclaration); + } + + if (ast.kind() != 130 /* ModuleDeclaration */ || decl.kind != 512 /* Variable */) { + return TypeScript.docComments(ast); + } + } + + return []; + }; + + PullSymbol.prototype.getDocCommentArray = function (symbol) { + var docComments = []; + if (!symbol) { + return docComments; + } + + var isParameter = symbol.kind == 2048 /* Parameter */; + var decls = symbol.getDeclarations(); + for (var i = 0; i < decls.length; i++) { + if (isParameter && decls[i].kind == 4096 /* Property */) { + continue; + } + docComments = docComments.concat(this.getDocCommentsOfDecl(decls[i])); + } + return docComments; + }; + + PullSymbol.getDefaultConstructorSymbolForDocComments = function (classSymbol) { + if (classSymbol.getHasDefaultConstructor()) { + var extendedTypes = classSymbol.getExtendedTypes(); + if (extendedTypes.length) { + return PullSymbol.getDefaultConstructorSymbolForDocComments(extendedTypes[0]); + } + } + + return classSymbol.type.getConstructSignatures()[0]; + }; + + PullSymbol.prototype.getDocCommentText = function (comments) { + var docCommentText = new Array(); + for (var c = 0; c < comments.length; c++) { + var commentText = this.getDocCommentTextValue(comments[c]); + if (commentText !== "") { + docCommentText.push(commentText); + } + } + return docCommentText.join("\n"); + }; + + PullSymbol.prototype.getDocCommentTextValue = function (comment) { + return this.cleanJSDocComment(comment.fullText()); + }; + + PullSymbol.prototype.docComments = function (useConstructorAsClass) { + var decls = this.getDeclarations(); + if (useConstructorAsClass && decls.length && decls[0].kind == 32768 /* ConstructorMethod */) { + var classDecl = decls[0].getParentDecl(); + return this.getDocCommentText(this.getDocCommentsOfDecl(classDecl)); + } + + if (this._docComments === null) { + var docComments = ""; + if (!useConstructorAsClass && this.kind == 2097152 /* ConstructSignature */ && decls.length && decls[0].kind == 8 /* Class */) { + var classSymbol = this.returnType; + var extendedTypes = classSymbol.getExtendedTypes(); + if (extendedTypes.length) { + docComments = extendedTypes[0].getConstructorMethod().docComments(); + } else { + docComments = ""; + } + } else if (this.kind == 2048 /* Parameter */) { + var parameterComments = []; + + var funcContainer = this.getEnclosingSignature(); + var funcDocComments = this.getDocCommentArray(funcContainer); + var paramComment = this.getParameterDocCommentText(this.getDisplayName(), funcDocComments); + if (paramComment != "") { + parameterComments.push(paramComment); + } + + var paramSelfComment = this.getDocCommentText(this.getDocCommentArray(this)); + if (paramSelfComment != "") { + parameterComments.push(paramSelfComment); + } + docComments = parameterComments.join("\n"); + } else { + var getSymbolComments = true; + if (this.kind == 16777216 /* FunctionType */) { + var functionSymbol = this.getFunctionSymbol(); + + if (functionSymbol) { + docComments = functionSymbol._docComments || ""; + getSymbolComments = false; + } else { + var declarationList = this.getDeclarations(); + if (declarationList.length > 0) { + docComments = declarationList[0].getSymbol()._docComments || ""; + getSymbolComments = false; + } + } + } + if (getSymbolComments) { + docComments = this.getDocCommentText(this.getDocCommentArray(this)); + if (docComments == "") { + if (this.kind == 1048576 /* CallSignature */) { + var callTypeSymbol = this.functionType; + if (callTypeSymbol && callTypeSymbol.getCallSignatures().length == 1) { + docComments = callTypeSymbol.docComments(); + } + } + } + } + } + + this._docComments = docComments; + } + + return this._docComments; + }; + + PullSymbol.prototype.getParameterDocCommentText = function (param, fncDocComments) { + if (fncDocComments.length === 0 || fncDocComments[0].kind() !== 6 /* MultiLineCommentTrivia */) { + return ""; + } + + for (var i = 0; i < fncDocComments.length; i++) { + var commentContents = fncDocComments[i].fullText(); + for (var j = commentContents.indexOf("@param", 0); 0 <= j; j = commentContents.indexOf("@param", j)) { + j += 6; + if (!this.isSpaceChar(commentContents, j)) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j); + if (j === -1) { + break; + } + + if (commentContents.charCodeAt(j) === 123 /* openBrace */) { + j++; + + var charCode = 0; + for (var curlies = 1; j < commentContents.length; j++) { + charCode = commentContents.charCodeAt(j); + + if (charCode === 123 /* openBrace */) { + curlies++; + continue; + } + + if (charCode === 125 /* closeBrace */) { + curlies--; + if (curlies === 0) { + break; + } else { + continue; + } + } + + if (charCode === 64 /* at */) { + break; + } + } + + if (j === commentContents.length) { + break; + } + + if (charCode === 64 /* at */) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j + 1); + if (j === -1) { + break; + } + } + + if (param !== commentContents.substr(j, param.length) || !this.isSpaceChar(commentContents, j + param.length)) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j + param.length); + if (j === -1) { + return ""; + } + + var endOfParam = commentContents.indexOf("@", j); + var paramHelpString = commentContents.substring(j, endOfParam < 0 ? commentContents.length : endOfParam); + + var paramSpacesToRemove = undefined; + var paramLineIndex = commentContents.substring(0, j).lastIndexOf("\n") + 1; + if (paramLineIndex !== 0) { + if (paramLineIndex < j && commentContents.charAt(paramLineIndex + 1) === "\r") { + paramLineIndex++; + } + } + var startSpaceRemovalIndex = this.consumeLeadingSpace(commentContents, paramLineIndex); + if (startSpaceRemovalIndex !== j && commentContents.charAt(startSpaceRemovalIndex) === "*") { + paramSpacesToRemove = j - startSpaceRemovalIndex - 1; + } + + return this.cleanJSDocComment(paramHelpString, paramSpacesToRemove); + } + } + + return ""; + }; + + PullSymbol.prototype.cleanJSDocComment = function (content, spacesToRemove) { + var docCommentLines = new Array(); + content = content.replace("/**", ""); + if (content.length >= 2 && content.charAt(content.length - 1) === "/" && content.charAt(content.length - 2) === "*") { + content = content.substring(0, content.length - 2); + } + var lines = content.split("\n"); + var inParamTag = false; + for (var l = 0; l < lines.length; l++) { + var line = lines[l]; + var cleanLinePos = this.cleanDocCommentLine(line, true, spacesToRemove); + if (!cleanLinePos) { + continue; + } + + var docCommentText = ""; + var prevPos = cleanLinePos.start; + for (var i = line.indexOf("@", cleanLinePos.start); 0 <= i && i < cleanLinePos.end; i = line.indexOf("@", i + 1)) { + var wasInParamtag = inParamTag; + + if (line.indexOf("param", i + 1) === i + 1 && this.isSpaceChar(line, i + 6)) { + if (!wasInParamtag) { + docCommentText += line.substring(prevPos, i); + } + + prevPos = i; + inParamTag = true; + } else if (wasInParamtag) { + prevPos = i; + inParamTag = false; + } + } + + if (!inParamTag) { + docCommentText += line.substring(prevPos, cleanLinePos.end); + } + + var newCleanPos = this.cleanDocCommentLine(docCommentText, false); + if (newCleanPos) { + if (spacesToRemove === undefined) { + spacesToRemove = cleanLinePos.jsDocSpacesRemoved; + } + docCommentLines.push(docCommentText); + } + } + + return docCommentLines.join("\n"); + }; + + PullSymbol.prototype.consumeLeadingSpace = function (line, startIndex, maxSpacesToRemove) { + var endIndex = line.length; + if (maxSpacesToRemove !== undefined) { + endIndex = TypeScript.MathPrototype.min(startIndex + maxSpacesToRemove, endIndex); + } + + for (; startIndex < endIndex; startIndex++) { + var charCode = line.charCodeAt(startIndex); + if (charCode !== 32 /* space */ && charCode !== 9 /* tab */) { + return startIndex; + } + } + + if (endIndex !== line.length) { + return endIndex; + } + + return -1; + }; + + PullSymbol.prototype.isSpaceChar = function (line, index) { + var length = line.length; + if (index < length) { + var charCode = line.charCodeAt(index); + + return charCode === 32 /* space */ || charCode === 9 /* tab */; + } + + return index === length; + }; + + PullSymbol.prototype.cleanDocCommentLine = function (line, jsDocStyleComment, jsDocLineSpaceToRemove) { + var nonSpaceIndex = this.consumeLeadingSpace(line, 0); + if (nonSpaceIndex !== -1) { + var jsDocSpacesRemoved = nonSpaceIndex; + if (jsDocStyleComment && line.charAt(nonSpaceIndex) === '*') { + var startIndex = nonSpaceIndex + 1; + nonSpaceIndex = this.consumeLeadingSpace(line, startIndex, jsDocLineSpaceToRemove); + + if (nonSpaceIndex !== -1) { + jsDocSpacesRemoved = nonSpaceIndex - startIndex; + } else { + return null; + } + } + + return { + start: nonSpaceIndex, + end: line.charAt(line.length - 1) === "\r" ? line.length - 1 : line.length, + jsDocSpacesRemoved: jsDocSpacesRemoved + }; + } + + return null; + }; + return PullSymbol; + })(); + TypeScript.PullSymbol = PullSymbol; + + var PullSignatureSymbol = (function (_super) { + __extends(PullSignatureSymbol, _super); + function PullSignatureSymbol(kind) { + _super.call(this, "", kind); + this._memberTypeParameterNameCache = null; + this._stringConstantOverload = undefined; + this.parameters = TypeScript.sentinelEmptyArray; + this.typeParameters = null; + this.returnType = null; + this.functionType = null; + this.hasOptionalParam = false; + this.nonOptionalParamCount = 0; + this.hasVarArgs = false; + this.hasAGenericParameter = false; + this.hasBeenChecked = false; + this.inWrapCheck = false; + } + PullSignatureSymbol.prototype.isDefinition = function () { + return false; + }; + + PullSignatureSymbol.prototype.isGeneric = function () { + return this.hasAGenericParameter || (this.typeParameters && this.typeParameters.length != 0); + }; + + PullSignatureSymbol.prototype.addParameter = function (parameter, isOptional) { + if (typeof isOptional === "undefined") { isOptional = false; } + if (this.parameters == TypeScript.sentinelEmptyArray) { + this.parameters = []; + } + + this.parameters[this.parameters.length] = parameter; + this.hasOptionalParam = isOptional; + + if (!parameter.getEnclosingSignature()) { + parameter.setEnclosingSignature(this); + } + + if (!isOptional) { + this.nonOptionalParamCount++; + } + }; + + PullSignatureSymbol.prototype.addTypeParameter = function (typeParameter) { + if (!this.typeParameters) { + this.typeParameters = []; + } + + if (!this._memberTypeParameterNameCache) { + this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject(); + } + + this.typeParameters[this.typeParameters.length] = typeParameter; + + this._memberTypeParameterNameCache[typeParameter.getName()] = typeParameter; + }; + + PullSignatureSymbol.prototype.getTypeParameters = function () { + if (!this.typeParameters) { + this.typeParameters = []; + } + + return this.typeParameters; + }; + + PullSignatureSymbol.prototype.findTypeParameter = function (name) { + var memberSymbol; + + if (!this._memberTypeParameterNameCache) { + this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject(); + + if (this.typeParameters) { + for (var i = 0; i < this.typeParameters.length; i++) { + this._memberTypeParameterNameCache[this.typeParameters[i].getName()] = this.typeParameters[i]; + } + } + } + + memberSymbol = this._memberTypeParameterNameCache[name]; + + return memberSymbol; + }; + + PullSignatureSymbol.prototype.isStringConstantOverloadSignature = function () { + if (this._stringConstantOverload === undefined) { + var params = this.parameters; + this._stringConstantOverload = false; + for (var i = 0; i < params.length; i++) { + var paramType = params[i].type; + if (paramType && paramType.isPrimitive() && paramType.isStringConstant()) { + this._stringConstantOverload = true; + } + } + } + + return this._stringConstantOverload; + }; + + PullSignatureSymbol.getSignatureTypeMemberName = function (candidateSignature, signatures, scopeSymbol) { + var allMemberNames = new TypeScript.MemberNameArray(); + var signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, "", false, false, scopeSymbol, true, candidateSignature); + allMemberNames.addAll(signatureMemberName); + return allMemberNames; + }; + + PullSignatureSymbol.getSignaturesTypeNameEx = function (signatures, prefix, shortform, brackets, scopeSymbol, getPrettyTypeName, candidateSignature) { + var result = []; + if (!signatures) { + return result; + } + + var len = signatures.length; + if (!getPrettyTypeName && len > 1) { + shortform = false; + } + + var foundDefinition = false; + if (candidateSignature && candidateSignature.isDefinition() && len > 1) { + candidateSignature = null; + } + + for (var i = 0; i < len; i++) { + if (len > 1 && signatures[i].isDefinition()) { + foundDefinition = true; + continue; + } + + var signature = signatures[i]; + if (getPrettyTypeName && candidateSignature) { + signature = candidateSignature; + } + + result.push(signature.getSignatureTypeNameEx(prefix, shortform, brackets, scopeSymbol)); + if (getPrettyTypeName) { + break; + } + } + + if (getPrettyTypeName && result.length && len > 1) { + var lastMemberName = result[result.length - 1]; + for (var i = i + 1; i < len; i++) { + if (signatures[i].isDefinition()) { + foundDefinition = true; + break; + } + } + var overloadString = TypeScript.getLocalizedText(TypeScript.DiagnosticCode._0_overload_s, [foundDefinition ? len - 2 : len - 1]); + lastMemberName.add(TypeScript.MemberName.create(overloadString)); + } + + return result; + }; + + PullSignatureSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var s = this.getSignatureTypeNameEx(this.getScopedNameEx().toString(), false, false, scopeSymbol, undefined, useConstraintInName).toString(); + return s; + }; + + PullSignatureSymbol.prototype.getSignatureTypeNameEx = function (prefix, shortform, brackets, scopeSymbol, getParamMarkerInfo, getTypeParamMarkerInfo) { + var typeParamterBuilder = new TypeScript.MemberNameArray(); + + typeParamterBuilder.add(PullSymbol.getTypeParameterStringEx(this.getTypeParameters(), scopeSymbol, getTypeParamMarkerInfo, true)); + + if (brackets) { + typeParamterBuilder.add(TypeScript.MemberName.create("[")); + } else { + typeParamterBuilder.add(TypeScript.MemberName.create("(")); + } + + var builder = new TypeScript.MemberNameArray(); + builder.prefix = prefix; + + if (getTypeParamMarkerInfo) { + builder.prefix = prefix; + builder.addAll(typeParamterBuilder.entries); + } else { + builder.prefix = prefix + typeParamterBuilder.toString(); + } + + var params = this.parameters; + var paramLen = params.length; + for (var i = 0; i < paramLen; i++) { + var paramType = params[i].type; + var typeString = paramType ? ": " : ""; + var paramIsVarArg = params[i].isVarArg; + var varArgPrefix = paramIsVarArg ? "..." : ""; + var optionalString = (!paramIsVarArg && params[i].isOptional) ? "?" : ""; + if (getParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + builder.add(TypeScript.MemberName.create(varArgPrefix + params[i].getScopedNameEx(scopeSymbol).toString() + optionalString + typeString)); + if (paramType) { + builder.add(paramType.getScopedNameEx(scopeSymbol)); + } + if (getParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + if (i < paramLen - 1) { + builder.add(TypeScript.MemberName.create(", ")); + } + } + + if (shortform) { + if (brackets) { + builder.add(TypeScript.MemberName.create("] => ")); + } else { + builder.add(TypeScript.MemberName.create(") => ")); + } + } else { + if (brackets) { + builder.add(TypeScript.MemberName.create("]: ")); + } else { + builder.add(TypeScript.MemberName.create("): ")); + } + } + + if (this.returnType) { + builder.add(this.returnType.getScopedNameEx(scopeSymbol)); + } else { + builder.add(TypeScript.MemberName.create("any")); + } + + return builder; + }; + + PullSignatureSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) { + var signature = this; + if (signature.inWrapCheck) { + return false; + } + + signature.inWrapCheck = true; + + var wrapsSomeTypeParameter = false; + + if (signature.returnType && signature.returnType.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + } + + if (!wrapsSomeTypeParameter) { + var parameters = signature.parameters; + + for (var i = 0; i < parameters.length; i++) { + if (!parameters[i].type) { + parameters[i]._resolveDeclaredSymbol(); + } + + if (parameters[i].type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + signature.inWrapCheck = false; + + return wrapsSomeTypeParameter; + }; + + PullSignatureSymbol.prototype.wrapsSomeNestedTypeIntoInfiniteExpansion = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + if (this.inWrapCheck) { + return isCheckingTypeArgumentList; + } + + if (knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID) != undefined) { + return knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID); + } + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, isCheckingTypeArgumentList); + + this.inWrapCheck = true; + + var wrapsSomeWrappedTypeParameter = false; + + if (this.returnType && this.returnType._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + wrapsSomeWrappedTypeParameter = true; + } + + if (!wrapsSomeWrappedTypeParameter) { + var parameters = this.parameters; + + for (var i = 0; i < parameters.length; i++) { + if (parameters[i].type && parameters[i].type._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + wrapsSomeWrappedTypeParameter = true; + break; + } + } + } + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, wrapsSomeWrappedTypeParameter); + + this.inWrapCheck = false; + + return wrapsSomeWrappedTypeParameter; + }; + return PullSignatureSymbol; + })(PullSymbol); + TypeScript.PullSignatureSymbol = PullSignatureSymbol; + + var PullTypeSymbol = (function (_super) { + __extends(PullTypeSymbol, _super); + function PullTypeSymbol(name, kind) { + _super.call(this, name, kind); + this._members = TypeScript.sentinelEmptyArray; + this._enclosedMemberTypes = null; + this._enclosedMemberContainers = null; + this._typeParameters = null; + this._specializedVersionsOfThisType = null; + this._arrayVersionOfThisType = null; + this._implementedTypes = null; + this._extendedTypes = null; + this._typesThatExplicitlyImplementThisType = null; + this._typesThatExtendThisType = null; + this._callSignatures = null; + this._allCallSignatures = null; + this._constructSignatures = null; + this._indexSignatures = null; + this._allIndexSignatures = null; + this._memberNameCache = null; + this._enclosedTypeNameCache = null; + this._enclosedContainerCache = null; + this._typeParameterNameCache = null; + this._containedNonMemberNameCache = null; + this._containedNonMemberTypeNameCache = null; + this._containedNonMemberContainerCache = null; + this._simpleInstantiationCache = null; + this._complexInstantiationCache = null; + this._hasGenericSignature = false; + this._hasGenericMember = false; + this._hasBaseTypeConflict = false; + this._knownBaseTypeCount = 0; + this._associatedContainerTypeSymbol = null; + this._constructorMethod = null; + this._hasDefaultConstructor = false; + this._functionSymbol = null; + this._inMemberTypeNameEx = false; + this.inSymbolPrivacyCheck = false; + this.inWrapCheck = false; + this.typeReference = null; + this._isArrayNamedTypeReference = undefined; + this.type = this; + } + PullTypeSymbol.prototype.isArrayNamedTypeReference = function () { + if (this._isArrayNamedTypeReference === undefined) { + this._isArrayNamedTypeReference = this.computeIsArrayNamedTypeReference(); + } + + return this._isArrayNamedTypeReference; + }; + + PullTypeSymbol.prototype.computeIsArrayNamedTypeReference = function () { + var typeArgs = this.getTypeArguments(); + if (typeArgs && this.getTypeArguments().length === 1 && this.name === "Array") { + var container = this.getContainer(); + var declaration = this.getDeclarations()[0]; + + if (declaration && declaration.getParentDecl() && declaration.getParentDecl().getParentDecl() === null) { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.isType = function () { + return true; + }; + PullTypeSymbol.prototype.isClass = function () { + return this.kind == 8 /* Class */ || (this._constructorMethod != null); + }; + PullTypeSymbol.prototype.isFunction = function () { + return (this.kind & (33554432 /* ConstructorType */ | 16777216 /* FunctionType */)) != 0; + }; + PullTypeSymbol.prototype.isConstructor = function () { + return this.kind == 33554432 /* ConstructorType */; + }; + PullTypeSymbol.prototype.isTypeParameter = function () { + return false; + }; + PullTypeSymbol.prototype.isTypeVariable = function () { + return false; + }; + PullTypeSymbol.prototype.isError = function () { + return false; + }; + PullTypeSymbol.prototype.isEnum = function () { + return this.kind == 64 /* Enum */; + }; + + PullTypeSymbol.prototype.getTypeParameterArgumentMap = function () { + return null; + }; + + PullTypeSymbol.prototype.isObject = function () { + return TypeScript.hasFlag(this.kind, 8 /* Class */ | 33554432 /* ConstructorType */ | 64 /* Enum */ | 16777216 /* FunctionType */ | 16 /* Interface */ | 8388608 /* ObjectType */); + }; + + PullTypeSymbol.prototype.getKnownBaseTypeCount = function () { + return this._knownBaseTypeCount; + }; + PullTypeSymbol.prototype.resetKnownBaseTypeCount = function () { + this._knownBaseTypeCount = 0; + }; + PullTypeSymbol.prototype.incrementKnownBaseCount = function () { + this._knownBaseTypeCount++; + }; + + PullTypeSymbol.prototype.setHasBaseTypeConflict = function () { + this._hasBaseTypeConflict = true; + }; + PullTypeSymbol.prototype.hasBaseTypeConflict = function () { + return this._hasBaseTypeConflict; + }; + + PullTypeSymbol.prototype.hasMembers = function () { + if (this._members != TypeScript.sentinelEmptyArray) { + return true; + } + + var parents = this.getExtendedTypes(); + + for (var i = 0; i < parents.length; i++) { + if (parents[i].hasMembers()) { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.setHasGenericSignature = function () { + this._hasGenericSignature = true; + }; + PullTypeSymbol.prototype.getHasGenericSignature = function () { + return this._hasGenericSignature; + }; + + PullTypeSymbol.prototype.setHasGenericMember = function () { + this._hasGenericMember = true; + }; + PullTypeSymbol.prototype.getHasGenericMember = function () { + return this._hasGenericMember; + }; + + PullTypeSymbol.prototype.setAssociatedContainerType = function (type) { + this._associatedContainerTypeSymbol = type; + }; + + PullTypeSymbol.prototype.getAssociatedContainerType = function () { + return this._associatedContainerTypeSymbol; + }; + + PullTypeSymbol.prototype.getArrayType = function () { + return this._arrayVersionOfThisType; + }; + + PullTypeSymbol.prototype.getElementType = function () { + return null; + }; + + PullTypeSymbol.prototype.setArrayType = function (arrayType) { + this._arrayVersionOfThisType = arrayType; + }; + + PullTypeSymbol.prototype.getFunctionSymbol = function () { + return this._functionSymbol; + }; + + PullTypeSymbol.prototype.setFunctionSymbol = function (symbol) { + if (symbol) { + this._functionSymbol = symbol; + } + }; + + PullTypeSymbol.prototype.findContainedNonMember = function (name) { + if (!this._containedNonMemberNameCache) { + return null; + } + + return this._containedNonMemberNameCache[name]; + }; + + PullTypeSymbol.prototype.findContainedNonMemberType = function (typeName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + if (!this._containedNonMemberTypeNameCache) { + return null; + } + + var nonMemberSymbol = this._containedNonMemberTypeNameCache[typeName]; + + if (nonMemberSymbol && kind != 0 /* None */) { + nonMemberSymbol = ((nonMemberSymbol.kind & kind) != 0) ? nonMemberSymbol : null; + } + + return nonMemberSymbol; + }; + + PullTypeSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + if (!this._containedNonMemberContainerCache) { + return null; + } + + var nonMemberSymbol = this._containedNonMemberContainerCache[containerName]; + + if (nonMemberSymbol && kind != 0 /* None */) { + nonMemberSymbol = ((nonMemberSymbol.kind & kind) != 0) ? nonMemberSymbol : null; + } + + return nonMemberSymbol; + }; + + PullTypeSymbol.prototype.addMember = function (memberSymbol) { + if (!memberSymbol) { + return; + } + + memberSymbol.setContainer(this); + + if (!this._memberNameCache) { + this._memberNameCache = TypeScript.createIntrinsicsObject(); + } + + if (this._members === TypeScript.sentinelEmptyArray) { + this._members = []; + } + + this._members.push(memberSymbol); + this._memberNameCache[memberSymbol.name] = memberSymbol; + }; + + PullTypeSymbol.prototype.addEnclosedMemberType = function (enclosedType) { + if (!enclosedType) { + return; + } + + enclosedType.setContainer(this); + + if (!this._enclosedTypeNameCache) { + this._enclosedTypeNameCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._enclosedMemberTypes) { + this._enclosedMemberTypes = []; + } + + this._enclosedMemberTypes[this._enclosedMemberTypes.length] = enclosedType; + this._enclosedTypeNameCache[enclosedType.name] = enclosedType; + }; + + PullTypeSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) { + if (!enclosedContainer) { + return; + } + + enclosedContainer.setContainer(this); + + if (!this._enclosedContainerCache) { + this._enclosedContainerCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._enclosedMemberContainers) { + this._enclosedMemberContainers = []; + } + + this._enclosedMemberContainers[this._enclosedMemberContainers.length] = enclosedContainer; + this._enclosedContainerCache[enclosedContainer.name] = enclosedContainer; + }; + + PullTypeSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) { + if (!enclosedNonMember) { + return; + } + + enclosedNonMember.setContainer(this); + + if (!this._containedNonMemberNameCache) { + this._containedNonMemberNameCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberNameCache[enclosedNonMember.name] = enclosedNonMember; + }; + + PullTypeSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) { + if (!enclosedNonMemberType) { + return; + } + + enclosedNonMemberType.setContainer(this); + + if (!this._containedNonMemberTypeNameCache) { + this._containedNonMemberTypeNameCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberTypeNameCache[enclosedNonMemberType.name] = enclosedNonMemberType; + }; + + PullTypeSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) { + if (!enclosedNonMemberContainer) { + return; + } + + enclosedNonMemberContainer.setContainer(this); + + if (!this._containedNonMemberContainerCache) { + this._containedNonMemberContainerCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberContainerCache[enclosedNonMemberContainer.name] = enclosedNonMemberContainer; + }; + + PullTypeSymbol.prototype.addTypeParameter = function (typeParameter) { + if (!typeParameter) { + return; + } + + if (!typeParameter.getContainer()) { + typeParameter.setContainer(this); + } + + if (!this._typeParameterNameCache) { + this._typeParameterNameCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._typeParameters) { + this._typeParameters = []; + } + + this._typeParameters[this._typeParameters.length] = typeParameter; + this._typeParameterNameCache[typeParameter.getName()] = typeParameter; + }; + + PullTypeSymbol.prototype.addConstructorTypeParameter = function (typeParameter) { + this.addTypeParameter(typeParameter); + + var constructSignatures = this.getConstructSignatures(); + + for (var i = 0; i < constructSignatures.length; i++) { + constructSignatures[i].addTypeParameter(typeParameter); + } + }; + + PullTypeSymbol.prototype.getMembers = function () { + return this._members; + }; + + PullTypeSymbol.prototype.setHasDefaultConstructor = function (hasOne) { + if (typeof hasOne === "undefined") { hasOne = true; } + this._hasDefaultConstructor = hasOne; + }; + + PullTypeSymbol.prototype.getHasDefaultConstructor = function () { + return this._hasDefaultConstructor; + }; + + PullTypeSymbol.prototype.getConstructorMethod = function () { + return this._constructorMethod; + }; + + PullTypeSymbol.prototype.setConstructorMethod = function (constructorMethod) { + this._constructorMethod = constructorMethod; + }; + + PullTypeSymbol.prototype.getTypeParameters = function () { + if (!this._typeParameters) { + return TypeScript.sentinelEmptyArray; + } + + return this._typeParameters; + }; + + PullTypeSymbol.prototype.isGeneric = function () { + return (this._typeParameters && this._typeParameters.length > 0) || this._hasGenericSignature || this._hasGenericMember || this.isArrayNamedTypeReference(); + }; + + PullTypeSymbol.prototype.canUseSimpleInstantiationCache = function (substitutingTypes) { + return substitutingTypes.length === 1 && substitutingTypes[0].kind !== 8388608 /* ObjectType */; + }; + + PullTypeSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) { + if (!substitutingTypes || !substitutingTypes.length) { + return; + } + + if (this.canUseSimpleInstantiationCache(substitutingTypes)) { + if (!this._simpleInstantiationCache) { + this._simpleInstantiationCache = []; + } + + this._simpleInstantiationCache[substitutingTypes[0].pullSymbolID] = specializedVersionOfThisType; + } else { + if (!this._complexInstantiationCache) { + this._complexInstantiationCache = TypeScript.createIntrinsicsObject(); + } + + this._complexInstantiationCache[getIDForTypeSubstitutions(substitutingTypes)] = specializedVersionOfThisType; + } + + if (!this._specializedVersionsOfThisType) { + this._specializedVersionsOfThisType = []; + } + + this._specializedVersionsOfThisType.push(specializedVersionOfThisType); + }; + + PullTypeSymbol.prototype.getSpecialization = function (substitutingTypes) { + if (!substitutingTypes || !substitutingTypes.length) { + return null; + } + + if (this.canUseSimpleInstantiationCache(substitutingTypes)) { + if (!this._simpleInstantiationCache) { + return null; + } + + var result = this._simpleInstantiationCache[substitutingTypes[0].pullSymbolID]; + return result ? result : null; + } else { + if (!this._complexInstantiationCache) { + return null; + } + + var result = this._complexInstantiationCache[getIDForTypeSubstitutions(substitutingTypes)]; + return result ? result : null; + } + }; + + PullTypeSymbol.prototype.getKnownSpecializations = function () { + if (!this._specializedVersionsOfThisType) { + return TypeScript.sentinelEmptyArray; + } + + return this._specializedVersionsOfThisType; + }; + + PullTypeSymbol.prototype.getTypeArguments = function () { + return null; + }; + + PullTypeSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + return this.getTypeParameters(); + }; + + PullTypeSymbol.prototype.addCallSignature = function (callSignature) { + if (!this._callSignatures) { + this._callSignatures = []; + } + + this._callSignatures[this._callSignatures.length] = callSignature; + + if (callSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + callSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addConstructSignature = function (constructSignature) { + if (!this._constructSignatures) { + this._constructSignatures = []; + } + + this._constructSignatures[this._constructSignatures.length] = constructSignature; + + if (constructSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + constructSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addIndexSignature = function (indexSignature) { + if (!this._indexSignatures) { + this._indexSignatures = []; + } + + this._indexSignatures[this._indexSignatures.length] = indexSignature; + + if (indexSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + indexSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addUnhiddenSignaturesFromBaseType = function (derivedTypeSignatures, baseTypeSignatures, signaturesBeingAggregated) { + if (!derivedTypeSignatures) { + signaturesBeingAggregated.push.apply(signaturesBeingAggregated, baseTypeSignatures); + return; + } + + var resolver = this._getResolver(); + for (var i = 0; i < baseTypeSignatures.length; i++) { + var baseSignature = baseTypeSignatures[i]; + + var signatureIsHidden = TypeScript.ArrayUtilities.any(derivedTypeSignatures, function (sig) { + return resolver.signaturesAreIdentical(baseSignature, sig, false); + }); + + if (!signatureIsHidden) { + signaturesBeingAggregated.push(baseSignature); + } + } + }; + + PullTypeSymbol.prototype.hasOwnCallSignatures = function () { + return this._callSignatures !== null; + }; + + PullTypeSymbol.prototype.getCallSignatures = function () { + if (this._allCallSignatures) { + return this._allCallSignatures; + } + + var signatures = []; + + if (this._callSignatures) { + signatures = signatures.concat(this._callSignatures); + } + + if (this._extendedTypes && this.kind === 16 /* Interface */) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._callSignatures, this._extendedTypes[i].getCallSignatures(), signatures); + } + } + + this._allCallSignatures = signatures; + + return signatures; + }; + + PullTypeSymbol.prototype.hasOwnConstructSignatures = function () { + return this._constructSignatures !== null; + }; + + PullTypeSymbol.prototype.getConstructSignatures = function () { + var signatures = []; + + if (this._constructSignatures) { + signatures = signatures.concat(this._constructSignatures); + } + + if (this._extendedTypes && this.kind === 16 /* Interface */) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._constructSignatures, this._extendedTypes[i].getConstructSignatures(), signatures); + } + } + + return signatures; + }; + + PullTypeSymbol.prototype.hasOwnIndexSignatures = function () { + return this._indexSignatures !== null; + }; + + PullTypeSymbol.prototype.getOwnIndexSignatures = function () { + return this._indexSignatures || TypeScript.sentinelEmptyArray; + }; + + PullTypeSymbol.prototype.getIndexSignatures = function () { + if (this._allIndexSignatures) { + return this._allIndexSignatures; + } + + var signatures = []; + + if (this._indexSignatures) { + signatures = signatures.concat(this._indexSignatures); + } + + if (this._extendedTypes) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._indexSignatures, this._extendedTypes[i].getIndexSignatures(), signatures); + } + } + + this._allIndexSignatures = signatures; + + return signatures; + }; + + PullTypeSymbol.prototype.addImplementedType = function (implementedType) { + if (!implementedType) { + return; + } + + if (!this._implementedTypes) { + this._implementedTypes = []; + } + + this._implementedTypes[this._implementedTypes.length] = implementedType; + + implementedType.addTypeThatExplicitlyImplementsThisType(this); + }; + + PullTypeSymbol.prototype.getImplementedTypes = function () { + if (!this._implementedTypes) { + return TypeScript.sentinelEmptyArray; + } + + return this._implementedTypes; + }; + + PullTypeSymbol.prototype.addExtendedType = function (extendedType) { + if (!extendedType) { + return; + } + + if (!this._extendedTypes) { + this._extendedTypes = []; + } + + this._extendedTypes[this._extendedTypes.length] = extendedType; + + extendedType.addTypeThatExtendsThisType(this); + }; + + PullTypeSymbol.prototype.getExtendedTypes = function () { + if (!this._extendedTypes) { + return TypeScript.sentinelEmptyArray; + } + + return this._extendedTypes; + }; + + PullTypeSymbol.prototype.addTypeThatExtendsThisType = function (type) { + if (!type) { + return; + } + + if (!this._typesThatExtendThisType) { + this._typesThatExtendThisType = []; + } + + this._typesThatExtendThisType[this._typesThatExtendThisType.length] = type; + }; + + PullTypeSymbol.prototype.getTypesThatExtendThisType = function () { + if (!this._typesThatExtendThisType) { + this._typesThatExtendThisType = []; + } + + return this._typesThatExtendThisType; + }; + + PullTypeSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) { + if (!type) { + return; + } + + if (!this._typesThatExplicitlyImplementThisType) { + this._typesThatExplicitlyImplementThisType = []; + } + + this._typesThatExplicitlyImplementThisType[this._typesThatExplicitlyImplementThisType.length] = type; + }; + + PullTypeSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () { + if (!this._typesThatExplicitlyImplementThisType) { + this._typesThatExplicitlyImplementThisType = []; + } + + return this._typesThatExplicitlyImplementThisType; + }; + + PullTypeSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + if (this === potentialBase || this.getRootSymbol() === potentialBase || this === potentialBase.getRootSymbol()) { + return true; + } + + if (TypeScript.ArrayUtilities.contains(visited, this)) { + return true; + } + + visited.push(this); + + var extendedTypes = this.getExtendedTypes(); + + for (var i = 0; i < extendedTypes.length; i++) { + if (extendedTypes[i].hasBase(potentialBase, visited)) { + return true; + } + } + + var implementedTypes = this.getImplementedTypes(); + + for (var i = 0; i < implementedTypes.length; i++) { + if (implementedTypes[i].hasBase(potentialBase, visited)) { + return true; + } + } + + visited.pop(); + + return false; + }; + + PullTypeSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) { + if (baseType.isError()) { + return false; + } + + var thisIsClass = this.isClass(); + if (isExtendedType) { + if (thisIsClass) { + return baseType.kind === 8 /* Class */; + } + } else { + if (!thisIsClass) { + return false; + } + } + + return !!(baseType.kind & (16 /* Interface */ | 8 /* Class */)); + }; + + PullTypeSymbol.prototype.findMember = function (name, lookInParent) { + var memberSymbol = null; + + if (this._memberNameCache) { + memberSymbol = this._memberNameCache[name]; + } + + if (memberSymbol || !lookInParent) { + return memberSymbol; + } + + if (this._extendedTypes) { + for (var i = 0; i < this._extendedTypes.length; i++) { + memberSymbol = this._extendedTypes[i].findMember(name, lookInParent); + + if (memberSymbol) { + return memberSymbol; + } + } + } + + return null; + }; + + PullTypeSymbol.prototype.findNestedType = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + var memberSymbol; + + if (!this._enclosedTypeNameCache) { + return null; + } + + memberSymbol = this._enclosedTypeNameCache[name]; + + if (memberSymbol && kind != 0 /* None */) { + memberSymbol = ((memberSymbol.kind & kind) != 0) ? memberSymbol : null; + } + + return memberSymbol; + }; + + PullTypeSymbol.prototype.findNestedContainer = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + var memberSymbol; + + if (!this._enclosedContainerCache) { + return null; + } + + memberSymbol = this._enclosedContainerCache[name]; + + if (memberSymbol && kind != 0 /* None */) { + memberSymbol = ((memberSymbol.kind & kind) != 0) ? memberSymbol : null; + } + + return memberSymbol; + }; + + PullTypeSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + var allMembers = []; + + if (this._members != TypeScript.sentinelEmptyArray) { + for (var i = 0, n = this._members.length; i < n; i++) { + var member = this._members[i]; + if ((member.kind & searchDeclKind) && (memberVisiblity !== 2 /* externallyVisible */ || !member.anyDeclHasFlag(2 /* Private */))) { + allMembers[allMembers.length] = member; + } + } + } + + if (this._extendedTypes) { + var extenedMembersVisibility = memberVisiblity !== 0 /* all */ ? 2 /* externallyVisible */ : 0 /* all */; + + for (var i = 0, n = this._extendedTypes.length; i < n; i++) { + var extendedMembers = this._extendedTypes[i].getAllMembers(searchDeclKind, extenedMembersVisibility); + + for (var j = 0, m = extendedMembers.length; j < m; j++) { + var extendedMember = extendedMembers[j]; + if (!(this._memberNameCache && this._memberNameCache[extendedMember.name])) { + allMembers[allMembers.length] = extendedMember; + } + } + } + } + + if (this.isContainer()) { + if (this._enclosedMemberTypes) { + for (var i = 0; i < this._enclosedMemberTypes.length; i++) { + allMembers[allMembers.length] = this._enclosedMemberTypes[i]; + } + } + if (this._enclosedMemberContainers) { + for (var i = 0; i < this._enclosedMemberContainers.length; i++) { + allMembers[allMembers.length] = this._enclosedMemberContainers[i]; + } + } + } + + return allMembers; + }; + + PullTypeSymbol.prototype.findTypeParameter = function (name) { + if (!this._typeParameterNameCache) { + return null; + } + + return this._typeParameterNameCache[name]; + }; + + PullTypeSymbol.prototype.setResolved = function () { + _super.prototype.setResolved.call(this); + }; + + PullTypeSymbol.prototype.getNamePartForFullName = function () { + var name = _super.prototype.getNamePartForFullName.call(this); + + var typars = this.getTypeArgumentsOrTypeParameters(); + var typarString = PullSymbol.getTypeParameterString(typars, this, true); + return name + typarString; + }; + + PullTypeSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) { + return this.getScopedNameEx(scopeSymbol, skipTypeParametersInName, useConstraintInName, false, false, skipInternalAliasName).toString(); + }; + + PullTypeSymbol.prototype.isNamedTypeSymbol = function () { + var kind = this.kind; + if (kind === 2 /* Primitive */ || kind === 8 /* Class */ || kind === 4 /* Container */ || kind === 32 /* DynamicModule */ || kind === 128 /* TypeAlias */ || kind === 64 /* Enum */ || kind === 8192 /* TypeParameter */ || ((kind === 16 /* Interface */ || kind === 8388608 /* ObjectType */) && this.name != "")) { + return true; + } + + return false; + }; + + PullTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var s = this.getScopedNameEx(scopeSymbol, false, useConstraintInName).toString(); + return s; + }; + + PullTypeSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) { + if (this.isArrayNamedTypeReference()) { + var elementType = this.getElementType(); + var elementMemberName = elementType ? (elementType.isArrayNamedTypeReference() || elementType.isNamedTypeSymbol() ? elementType.getScopedNameEx(scopeSymbol, false, false, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) : elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : TypeScript.MemberName.create("any"); + return TypeScript.MemberName.create(elementMemberName, "", "[]"); + } + + if (!this.isNamedTypeSymbol()) { + return this.getMemberTypeNameEx(true, scopeSymbol, getPrettyTypeName); + } + + if (skipTypeParametersInName) { + return TypeScript.MemberName.create(_super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName)); + } else { + var builder = new TypeScript.MemberNameArray(); + builder.prefix = _super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + + var typars = this.getTypeArgumentsOrTypeParameters(); + builder.add(PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, getTypeParamMarkerInfo, useConstraintInName)); + + return builder; + } + }; + + PullTypeSymbol.prototype.hasOnlyOverloadCallSignatures = function () { + var members = this.getMembers(); + var callSignatures = this.getCallSignatures(); + var constructSignatures = this.getConstructSignatures(); + return members.length === 0 && constructSignatures.length === 0 && callSignatures.length > 1; + }; + + PullTypeSymbol.prototype.getTypeOfSymbol = function () { + var associatedContainerType = this.getAssociatedContainerType(); + if (associatedContainerType && associatedContainerType.isNamedTypeSymbol()) { + return associatedContainerType; + } + + var functionSymbol = this.getFunctionSymbol(); + if (functionSymbol && functionSymbol.kind == 16384 /* Function */ && !TypeScript.PullHelpers.isSymbolLocal(functionSymbol)) { + return functionSymbol; + } + + return null; + }; + + PullTypeSymbol.prototype.getMemberTypeNameEx = function (topLevel, scopeSymbol, getPrettyTypeName) { + var members = this.getMembers(); + var callSignatures = this.getCallSignatures(); + var constructSignatures = this.getConstructSignatures(); + var indexSignatures = this.getIndexSignatures(); + + if (members.length > 0 || callSignatures.length > 0 || constructSignatures.length > 0 || indexSignatures.length > 0) { + var typeOfSymbol = this.getTypeOfSymbol(); + if (typeOfSymbol) { + var nameForTypeOf = typeOfSymbol.getScopedNameEx(scopeSymbol, true); + return TypeScript.MemberName.create(nameForTypeOf, "typeof ", ""); + } + + if (this._inMemberTypeNameEx) { + return TypeScript.MemberName.create("any"); + } + + this._inMemberTypeNameEx = true; + + var allMemberNames = new TypeScript.MemberNameArray(); + var curlies = !topLevel || indexSignatures.length != 0; + var delim = "; "; + for (var i = 0; i < members.length; i++) { + if (members[i].kind == 65536 /* Method */ && members[i].type.hasOnlyOverloadCallSignatures()) { + var methodCallSignatures = members[i].type.getCallSignatures(); + var nameStr = members[i].getDisplayName(scopeSymbol) + (members[i].isOptional ? "?" : ""); + ; + var methodMemberNames = PullSignatureSymbol.getSignaturesTypeNameEx(methodCallSignatures, nameStr, false, false, scopeSymbol); + allMemberNames.addAll(methodMemberNames); + } else { + var memberTypeName = members[i].getNameAndTypeNameEx(scopeSymbol); + if (memberTypeName.isArray() && memberTypeName.delim === delim) { + allMemberNames.addAll(memberTypeName.entries); + } else { + allMemberNames.add(memberTypeName); + } + } + curlies = true; + } + + var getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.hasOnlyOverloadCallSignatures(); + + var signatureCount = callSignatures.length + constructSignatures.length + indexSignatures.length; + var useShortFormSignature = !curlies && (signatureCount === 1); + var signatureMemberName; + + if (callSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(callSignatures, "", useShortFormSignature, false, scopeSymbol, getPrettyFunctionOverload); + allMemberNames.addAll(signatureMemberName); + } + + if (constructSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(constructSignatures, "new", useShortFormSignature, false, scopeSymbol); + allMemberNames.addAll(signatureMemberName); + } + + if (indexSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(indexSignatures, "", useShortFormSignature, true, scopeSymbol); + allMemberNames.addAll(signatureMemberName); + } + + if ((curlies) || (!getPrettyFunctionOverload && (signatureCount > 1) && topLevel)) { + allMemberNames.prefix = "{ "; + allMemberNames.suffix = "}"; + allMemberNames.delim = delim; + } else if (allMemberNames.entries.length > 1) { + allMemberNames.delim = delim; + } + + this._inMemberTypeNameEx = false; + + return allMemberNames; + } + + return TypeScript.MemberName.create("{}"); + }; + + PullTypeSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) { + return 2 /* Closed */; + }; + + PullTypeSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) { + var type = this; + + var wrapsSomeTypeParameter = false; + + if (type.isTypeParameter()) { + if (typeParameterArgumentMap[type.pullSymbolID]) { + return true; + } + + var constraint = type.getConstraint(); + + if (constraint && constraint.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return true; + } + + return false; + } + + if (type.inWrapCheck) { + return wrapsSomeTypeParameter; + } + + type.inWrapCheck = true; + + if (!wrapsSomeTypeParameter) { + var typeArguments = type.getTypeArguments(); + + if (type.isGeneric() && !typeArguments) { + typeArguments = type.getTypeParameters(); + } + + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (typeArguments[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + } + + if (!(type.kind & 8216 /* SomeInstantiatableType */) || !type.name) { + if (!wrapsSomeTypeParameter) { + var members = type.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + for (var i = 0; i < members.length; i++) { + if (members[i].type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + var sigs = type.getCallSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + sigs = type.getConstructSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + sigs = type.getIndexSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + } + + type.inWrapCheck = false; + + return wrapsSomeTypeParameter; + }; + + PullTypeSymbol.prototype.wrapsSomeNestedTypeIntoInfiniteExpansion = function (typeBeingWrapped) { + if (!this.isArrayNamedTypeReference() && this.isNamedTypeSymbol()) { + var knownWrapMap = TypeScript.BitMatrix.getBitMatrix(true); + var result = this._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, false, knownWrapMap); + knownWrapMap.release(); + + return result; + } + + return false; + }; + + PullTypeSymbol.prototype.isTypeEquivalentToRootSymbol = function () { + if (this.isTypeReference()) { + if (this.getIsSpecialized()) { + var typeArguments = this.getTypeArguments(); + var rootTypeArguments = this.getRootSymbol().getTypeArguments(); + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (!typeArguments[i].isTypeParameter() && !(rootTypeArguments && rootTypeArguments[i] == typeArguments[i].getRootSymbol())) { + return false; + } + } + return true; + } + + return false; + } else { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.isTypeBeingWrapped = function (typeBeingWrapped) { + if (this.inWrapCheck || this == typeBeingWrapped) { + return true; + } + + if (typeBeingWrapped.isTypeEquivalentToRootSymbol()) { + return this.isTypeBeingWrapped(typeBeingWrapped.getRootSymbol()); + } + + return false; + }; + + PullTypeSymbol.prototype.anyRootTypeBeingWrapped = function (typeBeingWrapped) { + var prevRootType = this; + var rootType = this.getRootSymbol(); + while (rootType != prevRootType) { + if (rootType.isTypeBeingWrapped(typeBeingWrapped)) { + return true; + } + + prevRootType = rootType; + rootType = rootType.getRootSymbol(); + } + + return false; + }; + + PullTypeSymbol.prototype._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + if (this.isArrayNamedTypeReference()) { + return this.getElementType()._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap); + } + + if (this.isTypeBeingWrapped(typeBeingWrapped)) { + return isCheckingTypeArgumentList; + } + + if (knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID) != undefined) { + return knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID); + } + + if (this.isPrimitive() || this.isTypeParameter()) { + return false; + } + + this.inWrapCheck = true; + + var wrapsSomeWrappedTypeParameter = false; + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, false); + + wrapsSomeWrappedTypeParameter = this._wrapsSomeNestedTypeIntoInfiniteExpansionWorker(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap); + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, wrapsSomeWrappedTypeParameter); + + this.inWrapCheck = false; + + return wrapsSomeWrappedTypeParameter; + }; + + PullTypeSymbol.prototype._wrapsSomeNestedTypeIntoInfiniteExpansionWorker = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + var typeArguments = this.getTypeArguments(); + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (typeArguments[i]._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, true, knownWrapMap)) { + return true; + } + } + } + + if (this.anyRootTypeBeingWrapped(typeBeingWrapped)) { + if (isCheckingTypeArgumentList && this.isTypeReference() && !this.getIsSpecialized()) { + return true; + } + + return false; + } else if (!this.isNamedTypeSymbol() || this.isGeneric()) { + var isTypeEquivalentToRootSymbol = this.isTypeEquivalentToRootSymbol(); + var rootType = TypeScript.PullHelpers.getRootType(this); + if (isTypeEquivalentToRootSymbol) { + rootType.inWrapCheck = true; + } + + var members = this.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + for (var i = 0; i < members.length; i++) { + if (members[i].type && members[i].type._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + var sigs = this.getCallSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + sigs = this.getConstructSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + sigs = this.getIndexSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + if (isTypeEquivalentToRootSymbol) { + rootType.inWrapCheck = false; + } + + return false; + } + }; + return PullTypeSymbol; + })(PullSymbol); + TypeScript.PullTypeSymbol = PullTypeSymbol; + + var PullPrimitiveTypeSymbol = (function (_super) { + __extends(PullPrimitiveTypeSymbol, _super); + function PullPrimitiveTypeSymbol(name) { + _super.call(this, name, 2 /* Primitive */); + + this.isResolved = true; + } + PullPrimitiveTypeSymbol.prototype.isAny = function () { + return this.name === "any"; + }; + + PullPrimitiveTypeSymbol.prototype.isStringConstant = function () { + return false; + }; + + PullPrimitiveTypeSymbol.prototype.setUnresolved = function () { + }; + return PullPrimitiveTypeSymbol; + })(PullTypeSymbol); + TypeScript.PullPrimitiveTypeSymbol = PullPrimitiveTypeSymbol; + + var PullStringConstantTypeSymbol = (function (_super) { + __extends(PullStringConstantTypeSymbol, _super); + function PullStringConstantTypeSymbol(name) { + _super.call(this, name); + } + PullStringConstantTypeSymbol.prototype.isStringConstant = function () { + return true; + }; + return PullStringConstantTypeSymbol; + })(PullPrimitiveTypeSymbol); + TypeScript.PullStringConstantTypeSymbol = PullStringConstantTypeSymbol; + + var PullErrorTypeSymbol = (function (_super) { + __extends(PullErrorTypeSymbol, _super); + function PullErrorTypeSymbol(anyType, name) { + _super.call(this, name); + this.anyType = anyType; + + this.isResolved = true; + } + PullErrorTypeSymbol.prototype.isError = function () { + return true; + }; + + PullErrorTypeSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + + PullErrorTypeSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + + PullErrorTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + return PullErrorTypeSymbol; + })(PullPrimitiveTypeSymbol); + TypeScript.PullErrorTypeSymbol = PullErrorTypeSymbol; + + var PullContainerSymbol = (function (_super) { + __extends(PullContainerSymbol, _super); + function PullContainerSymbol(name, kind) { + _super.call(this, name, kind); + this.instanceSymbol = null; + this.assignedValue = null; + this.assignedType = null; + this.assignedContainer = null; + } + PullContainerSymbol.prototype.isContainer = function () { + return true; + }; + + PullContainerSymbol.prototype.setInstanceSymbol = function (symbol) { + this.instanceSymbol = symbol; + }; + + PullContainerSymbol.prototype.getInstanceSymbol = function () { + return this.instanceSymbol; + }; + + PullContainerSymbol.prototype.setExportAssignedValueSymbol = function (symbol) { + this.assignedValue = symbol; + }; + + PullContainerSymbol.prototype.getExportAssignedValueSymbol = function () { + return this.assignedValue; + }; + + PullContainerSymbol.prototype.setExportAssignedTypeSymbol = function (type) { + this.assignedType = type; + }; + + PullContainerSymbol.prototype.getExportAssignedTypeSymbol = function () { + return this.assignedType; + }; + + PullContainerSymbol.prototype.setExportAssignedContainerSymbol = function (container) { + this.assignedContainer = container; + }; + + PullContainerSymbol.prototype.getExportAssignedContainerSymbol = function () { + return this.assignedContainer; + }; + + PullContainerSymbol.prototype.hasExportAssignment = function () { + return !!this.assignedValue || !!this.assignedType || !!this.assignedContainer; + }; + + PullContainerSymbol.usedAsSymbol = function (containerSymbol, symbol) { + if (!containerSymbol || !containerSymbol.isContainer()) { + return false; + } + + if (!containerSymbol.isAlias() && containerSymbol.type == symbol) { + return true; + } + + var moduleSymbol = containerSymbol; + var valueExportSymbol = moduleSymbol.getExportAssignedValueSymbol(); + var typeExportSymbol = moduleSymbol.getExportAssignedTypeSymbol(); + var containerExportSymbol = moduleSymbol.getExportAssignedContainerSymbol(); + if (valueExportSymbol || typeExportSymbol || containerExportSymbol) { + return valueExportSymbol == symbol || typeExportSymbol == symbol || containerExportSymbol == symbol || PullContainerSymbol.usedAsSymbol(containerExportSymbol, symbol); + } + + return false; + }; + + PullContainerSymbol.prototype.getInstanceType = function () { + return this.instanceSymbol ? this.instanceSymbol.type : null; + }; + return PullContainerSymbol; + })(PullTypeSymbol); + TypeScript.PullContainerSymbol = PullContainerSymbol; + + var PullTypeAliasSymbol = (function (_super) { + __extends(PullTypeAliasSymbol, _super); + function PullTypeAliasSymbol(name) { + _super.call(this, name, 128 /* TypeAlias */); + this._assignedValue = null; + this._assignedType = null; + this._assignedContainer = null; + this._isUsedAsValue = false; + this._typeUsedExternally = false; + this.retrievingExportAssignment = false; + } + PullTypeAliasSymbol.prototype.typeUsedExternally = function () { + this._resolveDeclaredSymbol(); + return this._typeUsedExternally; + }; + + PullTypeAliasSymbol.prototype.isUsedAsValue = function () { + this._resolveDeclaredSymbol(); + return this._isUsedAsValue; + }; + + PullTypeAliasSymbol.prototype.setTypeUsedExternally = function (value) { + this._typeUsedExternally = value; + }; + + PullTypeAliasSymbol.prototype.setIsUsedAsValue = function (value) { + this._isUsedAsValue = value; + + this._resolveDeclaredSymbol(); + var resolver = this._getResolver(); + var importDeclStatement = resolver.semanticInfoChain.getASTForDecl(this.getDeclarations()[0]); + var aliasSymbol = resolver.semanticInfoChain.getAliasSymbolForAST(importDeclStatement.moduleReference); + if (aliasSymbol) { + aliasSymbol.setIsUsedAsValue(value); + } + }; + + PullTypeAliasSymbol.prototype.assignedValue = function () { + this._resolveDeclaredSymbol(); + return this._assignedValue; + }; + + PullTypeAliasSymbol.prototype.assignedType = function () { + this._resolveDeclaredSymbol(); + return this._assignedType; + }; + + PullTypeAliasSymbol.prototype.assignedContainer = function () { + this._resolveDeclaredSymbol(); + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.isAlias = function () { + return true; + }; + PullTypeAliasSymbol.prototype.isContainer = function () { + return true; + }; + + PullTypeAliasSymbol.prototype.setAssignedValueSymbol = function (symbol) { + this._assignedValue = symbol; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedValueSymbol = function () { + if (this._assignedValue) { + return this._assignedValue; + } + + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedValueSymbol(); + this.retrievingExportAssignment = false; + return sym; + } + + return null; + }; + + PullTypeAliasSymbol.prototype.setAssignedTypeSymbol = function (type) { + this._assignedType = type; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedTypeSymbol = function () { + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedType) { + if (this._assignedType.isAlias()) { + this.retrievingExportAssignment = true; + var sym = this._assignedType.getExportAssignedTypeSymbol(); + this.retrievingExportAssignment = false; + } else if (this._assignedType != this._assignedContainer) { + return this._assignedType; + } + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedTypeSymbol(); + this.retrievingExportAssignment = false; + if (sym) { + return sym; + } + } + + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.setAssignedContainerSymbol = function (container) { + this._assignedContainer = container; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedContainerSymbol = function () { + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedContainerSymbol(); + this.retrievingExportAssignment = false; + if (sym) { + return sym; + } + } + + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.getMembers = function () { + if (this._assignedType) { + return this._assignedType.getMembers(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getCallSignatures = function () { + if (this._assignedType) { + return this._assignedType.getCallSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getConstructSignatures = function () { + if (this._assignedType) { + return this._assignedType.getConstructSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getIndexSignatures = function () { + if (this._assignedType) { + return this._assignedType.getIndexSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.findMember = function (name) { + if (this._assignedType) { + return this._assignedType.findMember(name, true); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.findNestedType = function (name) { + if (this._assignedType) { + return this._assignedType.findNestedType(name); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.findNestedContainer = function (name) { + if (this._assignedType) { + return this._assignedType.findNestedContainer(name); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisibility) { + if (this._assignedType) { + return this._assignedType.getAllMembers(searchDeclKind, memberVisibility); + } + + return TypeScript.sentinelEmptyArray; + }; + return PullTypeAliasSymbol; + })(PullTypeSymbol); + TypeScript.PullTypeAliasSymbol = PullTypeAliasSymbol; + + var PullDefinitionSignatureSymbol = (function (_super) { + __extends(PullDefinitionSignatureSymbol, _super); + function PullDefinitionSignatureSymbol() { + _super.apply(this, arguments); + } + PullDefinitionSignatureSymbol.prototype.isDefinition = function () { + return true; + }; + return PullDefinitionSignatureSymbol; + })(PullSignatureSymbol); + TypeScript.PullDefinitionSignatureSymbol = PullDefinitionSignatureSymbol; + + var PullTypeParameterSymbol = (function (_super) { + __extends(PullTypeParameterSymbol, _super); + function PullTypeParameterSymbol(name, _isFunctionTypeParameter) { + _super.call(this, name, 8192 /* TypeParameter */); + this._isFunctionTypeParameter = _isFunctionTypeParameter; + this._constraint = null; + } + PullTypeParameterSymbol.prototype.isTypeParameter = function () { + return true; + }; + PullTypeParameterSymbol.prototype.isFunctionTypeParameter = function () { + return this._isFunctionTypeParameter; + }; + + PullTypeParameterSymbol.prototype.setConstraint = function (constraintType) { + this._constraint = constraintType; + }; + + PullTypeParameterSymbol.prototype.getConstraint = function () { + return this._constraint; + }; + + PullTypeParameterSymbol.prototype.getCallSignatures = function () { + if (this._constraint) { + return this._constraint.getCallSignatures(); + } + + return _super.prototype.getCallSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.getConstructSignatures = function () { + if (this._constraint) { + return this._constraint.getConstructSignatures(); + } + + return _super.prototype.getConstructSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.getIndexSignatures = function () { + if (this._constraint) { + return this._constraint.getIndexSignatures(); + } + + return _super.prototype.getIndexSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.isGeneric = function () { + return true; + }; + + PullTypeParameterSymbol.prototype.fullName = function (scopeSymbol) { + var name = this.getDisplayName(scopeSymbol); + var container = this.getContainer(); + if (container) { + var containerName = container.fullName(scopeSymbol); + name = name + " in " + containerName; + } + + return name; + }; + + PullTypeParameterSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + var name = _super.prototype.getName.call(this, scopeSymbol); + + if (this.isPrinting) { + return name; + } + + this.isPrinting = true; + + if (useConstraintInName && this._constraint) { + name += " extends " + this._constraint.toString(scopeSymbol); + } + + this.isPrinting = false; + + return name; + }; + + PullTypeParameterSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + var name = _super.prototype.getDisplayName.call(this, scopeSymbol, useConstraintInName, skipInternalAliasName); + + if (this.isPrinting) { + return name; + } + + this.isPrinting = true; + + if (useConstraintInName && this._constraint) { + name += " extends " + this._constraint.toString(scopeSymbol); + } + + this.isPrinting = false; + + return name; + }; + + PullTypeParameterSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) { + return true; + }; + return PullTypeParameterSymbol; + })(PullTypeSymbol); + TypeScript.PullTypeParameterSymbol = PullTypeParameterSymbol; + + var PullAccessorSymbol = (function (_super) { + __extends(PullAccessorSymbol, _super); + function PullAccessorSymbol(name) { + _super.call(this, name, 4096 /* Property */); + this._getterSymbol = null; + this._setterSymbol = null; + } + PullAccessorSymbol.prototype.isAccessor = function () { + return true; + }; + + PullAccessorSymbol.prototype.setSetter = function (setter) { + if (!setter) { + return; + } + + this._setterSymbol = setter; + }; + + PullAccessorSymbol.prototype.getSetter = function () { + return this._setterSymbol; + }; + + PullAccessorSymbol.prototype.setGetter = function (getter) { + if (!getter) { + return; + } + + this._getterSymbol = getter; + }; + + PullAccessorSymbol.prototype.getGetter = function () { + return this._getterSymbol; + }; + return PullAccessorSymbol; + })(PullSymbol); + TypeScript.PullAccessorSymbol = PullAccessorSymbol; + + function getIDForTypeSubstitutions(types) { + var substitution = ""; + var members = null; + + for (var i = 0; i < types.length; i++) { + if (types[i].kind !== 8388608 /* ObjectType */) { + substitution += types[i].pullSymbolID + "#"; + } else { + var structure = getIDForTypeSubstitutionsFromObjectType(types[i]); + + if (structure) { + substitution += structure; + } else { + substitution += types[i].pullSymbolID + "#"; + } + } + } + + return substitution; + } + TypeScript.getIDForTypeSubstitutions = getIDForTypeSubstitutions; + + function getIDForTypeSubstitutionsFromObjectType(type) { + var structure = ""; + + if (type.isResolved) { + var members = type.getMembers(); + if (members && members.length) { + for (var j = 0; j < members.length; j++) { + structure += members[j].name + "@" + getIDForTypeSubstitutions([members[j].type]); + } + } + + var callSignatures = type.getCallSignatures(); + if (callSignatures && callSignatures.length) { + for (var j = 0; j < callSignatures.length; j++) { + structure += getIDForTypeSubstitutionFromSignature(callSignatures[j]); + } + } + + var constructSignatures = type.getConstructSignatures(); + if (constructSignatures && constructSignatures.length) { + for (var j = 0; j < constructSignatures.length; j++) { + structure += "new" + getIDForTypeSubstitutionFromSignature(constructSignatures[j]); + } + } + + var indexSignatures = type.getIndexSignatures(); + if (indexSignatures && indexSignatures.length) { + for (var j = 0; j < indexSignatures.length; j++) { + structure += "[]" + getIDForTypeSubstitutionFromSignature(indexSignatures[j]); + } + } + } + + if (structure !== "") { + return "{" + structure + "}"; + } + + return null; + } + + function getIDForTypeSubstitutionFromSignature(signature) { + var structure = "("; + var parameters = signature.parameters; + if (parameters && parameters.length) { + for (var k = 0; k < parameters.length; k++) { + structure += parameters[k].name + "@" + getIDForTypeSubstitutions([parameters[k].type]); + } + } + + structure += ")" + getIDForTypeSubstitutions([signature.returnType]); + return structure; + } + + (function (GetAllMembersVisiblity) { + GetAllMembersVisiblity[GetAllMembersVisiblity["all"] = 0] = "all"; + + GetAllMembersVisiblity[GetAllMembersVisiblity["internallyVisible"] = 1] = "internallyVisible"; + + GetAllMembersVisiblity[GetAllMembersVisiblity["externallyVisible"] = 2] = "externallyVisible"; + })(TypeScript.GetAllMembersVisiblity || (TypeScript.GetAllMembersVisiblity = {})); + var GetAllMembersVisiblity = TypeScript.GetAllMembersVisiblity; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CandidateInferenceInfo = (function () { + function CandidateInferenceInfo() { + this.typeParameter = null; + this.isFixed = false; + this.inferenceCandidates = []; + } + CandidateInferenceInfo.prototype.addCandidate = function (candidate) { + if (!this.isFixed) { + this.inferenceCandidates[this.inferenceCandidates.length] = candidate; + } + }; + return CandidateInferenceInfo; + })(); + TypeScript.CandidateInferenceInfo = CandidateInferenceInfo; + + var ArgumentInferenceContext = (function () { + function ArgumentInferenceContext(resolver, argumentsOrParameters) { + this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false); + this.candidateCache = []; + this.fixedParameterTypes = null; + this.resolver = null; + this.argumentASTs = null; + this.resolver = resolver; + + if (argumentsOrParameters.nonSeparatorAt != undefined) { + this.argumentASTs = argumentsOrParameters; + } else { + this.fixedParameterTypes = argumentsOrParameters; + } + } + ArgumentInferenceContext.prototype.alreadyRelatingTypes = function (objectType, parameterType) { + if (this.inferenceCache.valueAt(objectType.pullSymbolID, parameterType.pullSymbolID)) { + return true; + } else { + this.inferenceCache.setValueAt(objectType.pullSymbolID, parameterType.pullSymbolID, true); + return false; + } + }; + + ArgumentInferenceContext.prototype.resetRelationshipCache = function () { + this.inferenceCache.release(); + this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false); + }; + + ArgumentInferenceContext.prototype.addInferenceRoot = function (param) { + var info = this.candidateCache[param.pullSymbolID]; + + if (!info) { + info = new CandidateInferenceInfo(); + info.typeParameter = param; + this.candidateCache[param.pullSymbolID] = info; + } + }; + + ArgumentInferenceContext.prototype.getInferenceInfo = function (param) { + return this.candidateCache[param.pullSymbolID]; + }; + + ArgumentInferenceContext.prototype.addCandidateForInference = function (param, candidate, fix) { + var info = this.getInferenceInfo(param); + + if (info) { + if (candidate) { + info.addCandidate(candidate); + } + + if (!info.isFixed) { + info.isFixed = fix; + } + } + }; + + ArgumentInferenceContext.prototype.getInferenceArgumentCount = function () { + if (this.fixedParameterTypes) { + return this.fixedParameterTypes.length; + } else { + return this.argumentASTs.nonSeparatorCount(); + } + }; + + ArgumentInferenceContext.prototype.getArgumentTypeSymbolAtIndex = function (i, context) { + TypeScript.Debug.assert(i >= 0, "invalid inference argument position"); + + if (this.fixedParameterTypes && i < this.getInferenceArgumentCount()) { + return this.fixedParameterTypes[i]; + } else if (i < this.getInferenceArgumentCount()) { + return this.resolver.resolveAST(this.argumentASTs.nonSeparatorAt(i), true, context).type; + } + + return null; + }; + + ArgumentInferenceContext.prototype.getInferenceCandidates = function () { + var inferenceCandidates = []; + + for (var infoKey in this.candidateCache) { + if (this.candidateCache.hasOwnProperty(infoKey)) { + var info = this.candidateCache[infoKey]; + + for (var i = 0; i < info.inferenceCandidates.length; i++) { + var val = []; + val[info.typeParameter.pullSymbolID] = info.inferenceCandidates[i]; + inferenceCandidates.push(val); + } + } + } + + return inferenceCandidates; + }; + + ArgumentInferenceContext.prototype.inferArgumentTypes = function (resolver, context) { + var collection; + + var bestCommonType; + + var results = []; + + var unfit = false; + + for (var infoKey in this.candidateCache) { + if (this.candidateCache.hasOwnProperty(infoKey)) { + var info = this.candidateCache[infoKey]; + + if (!info.inferenceCandidates.length) { + results[results.length] = { param: info.typeParameter, type: null }; + continue; + } + + collection = { + getLength: function () { + return info.inferenceCandidates.length; + }, + getTypeAtIndex: function (index) { + return info.inferenceCandidates[index].type; + } + }; + + bestCommonType = resolver.widenType(resolver.findBestCommonType(collection, context, new TypeScript.TypeComparisonInfo())); + + if (!bestCommonType) { + unfit = true; + } else { + for (var i = 0; i < results.length; i++) { + if (results[i].type == info.typeParameter) { + results[i].type = bestCommonType; + } + } + } + + results[results.length] = { param: info.typeParameter, type: bestCommonType }; + } + } + + return { results: results, unfit: unfit }; + }; + return ArgumentInferenceContext; + })(); + TypeScript.ArgumentInferenceContext = ArgumentInferenceContext; + + var PullContextualTypeContext = (function () { + function PullContextualTypeContext(contextualType, provisional, substitutions) { + this.contextualType = contextualType; + this.provisional = provisional; + this.substitutions = substitutions; + this.provisionallyTypedSymbols = []; + this.hasProvisionalErrors = false; + this.astSymbolMap = []; + } + PullContextualTypeContext.prototype.recordProvisionallyTypedSymbol = function (symbol) { + this.provisionallyTypedSymbols[this.provisionallyTypedSymbols.length] = symbol; + }; + + PullContextualTypeContext.prototype.invalidateProvisionallyTypedSymbols = function () { + for (var i = 0; i < this.provisionallyTypedSymbols.length; i++) { + this.provisionallyTypedSymbols[i].setUnresolved(); + } + }; + + PullContextualTypeContext.prototype.setSymbolForAST = function (ast, symbol) { + this.astSymbolMap[ast.syntaxID()] = symbol; + }; + + PullContextualTypeContext.prototype.getSymbolForAST = function (ast) { + return this.astSymbolMap[ast.syntaxID()]; + }; + return PullContextualTypeContext; + })(); + TypeScript.PullContextualTypeContext = PullContextualTypeContext; + + var PullTypeResolutionContext = (function () { + function PullTypeResolutionContext(resolver, inTypeCheck, fileName) { + if (typeof inTypeCheck === "undefined") { inTypeCheck = false; } + if (typeof fileName === "undefined") { fileName = null; } + this.resolver = resolver; + this.inTypeCheck = inTypeCheck; + this.fileName = fileName; + this.contextStack = []; + this.typeCheckedNodes = null; + this.inBaseTypeResolution = false; + if (inTypeCheck) { + TypeScript.Debug.assert(fileName, "A file name must be provided if you are typechecking"); + this.typeCheckedNodes = TypeScript.BitVector.getBitVector(false); + } + } + PullTypeResolutionContext.prototype.setTypeChecked = function (ast) { + if (!this.inProvisionalResolution()) { + this.typeCheckedNodes.setValueAt(ast.syntaxID(), true); + } + }; + + PullTypeResolutionContext.prototype.canTypeCheckAST = function (ast) { + return this.typeCheck() && !this.typeCheckedNodes.valueAt(ast.syntaxID()) && this.fileName === ast.fileName(); + }; + + PullTypeResolutionContext.prototype.pushContextualType = function (type, provisional, substitutions) { + this.contextStack.push(new PullContextualTypeContext(type, provisional, substitutions)); + }; + + PullTypeResolutionContext.prototype.popContextualType = function () { + var tc = this.contextStack.pop(); + + tc.invalidateProvisionallyTypedSymbols(); + + if (tc.hasProvisionalErrors && this.inProvisionalResolution()) { + this.contextStack[this.contextStack.length - 1].hasProvisionalErrors = true; + } + + return tc; + }; + + PullTypeResolutionContext.prototype.hasProvisionalErrors = function () { + return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].hasProvisionalErrors : false; + }; + + PullTypeResolutionContext.prototype.findSubstitution = function (type) { + var substitution = null; + + if (this.contextStack.length) { + for (var i = this.contextStack.length - 1; i >= 0; i--) { + if (this.contextStack[i].substitutions) { + substitution = this.contextStack[i].substitutions[type.pullSymbolID]; + + if (substitution) { + break; + } + } + } + } + + return substitution; + }; + + PullTypeResolutionContext.prototype.getContextualType = function () { + var context = !this.contextStack.length ? null : this.contextStack[this.contextStack.length - 1]; + + if (context) { + var type = context.contextualType; + + if (!type) { + return null; + } + + if (type.isTypeParameter() && type.getConstraint()) { + type = type.getConstraint(); + } + + var substitution = this.findSubstitution(type); + + return substitution ? substitution : type; + } + + return null; + }; + + PullTypeResolutionContext.prototype.inProvisionalResolution = function () { + return (!this.contextStack.length ? false : this.contextStack[this.contextStack.length - 1].provisional); + }; + + PullTypeResolutionContext.prototype.isInBaseTypeResolution = function () { + return this.inBaseTypeResolution; + }; + + PullTypeResolutionContext.prototype.startBaseTypeResolution = function () { + var wasInBaseTypeResoltion = this.inBaseTypeResolution; + this.inBaseTypeResolution = true; + return wasInBaseTypeResoltion; + }; + + PullTypeResolutionContext.prototype.doneBaseTypeResolution = function (wasInBaseTypeResolution) { + this.inBaseTypeResolution = wasInBaseTypeResolution; + }; + + PullTypeResolutionContext.prototype.setTypeInContext = function (symbol, type) { + var substitution = this.findSubstitution(type); + + symbol.type = substitution ? substitution : type; + + if (this.contextStack.length && this.inProvisionalResolution()) { + this.contextStack[this.contextStack.length - 1].recordProvisionallyTypedSymbol(symbol); + } + }; + + PullTypeResolutionContext.prototype.postDiagnostic = function (diagnostic) { + if (diagnostic) { + if (this.inProvisionalResolution()) { + (this.contextStack[this.contextStack.length - 1]).hasProvisionalErrors = true; + } else if (this.inTypeCheck && this.resolver) { + this.resolver.semanticInfoChain.addDiagnostic(diagnostic); + } + } + }; + + PullTypeResolutionContext.prototype.typeCheck = function () { + return this.inTypeCheck && !this.inProvisionalResolution(); + }; + + PullTypeResolutionContext.prototype.setSymbolForAST = function (ast, symbol) { + this.contextStack[this.contextStack.length - 1].setSymbolForAST(ast, symbol); + }; + + PullTypeResolutionContext.prototype.getSymbolForAST = function (ast) { + for (var i = this.contextStack.length - 1; i >= 0; i--) { + var typeContext = this.contextStack[i]; + if (!typeContext.provisional) { + break; + } + + var symbol = typeContext.getSymbolForAST(ast); + if (symbol) { + return symbol; + } + } + + return null; + }; + return PullTypeResolutionContext; + })(); + TypeScript.PullTypeResolutionContext = PullTypeResolutionContext; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var OverloadApplicabilityStatus; + (function (OverloadApplicabilityStatus) { + OverloadApplicabilityStatus[OverloadApplicabilityStatus["NotAssignable"] = 0] = "NotAssignable"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableButWithProvisionalErrors"] = 1] = "AssignableButWithProvisionalErrors"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableWithNoProvisionalErrors"] = 2] = "AssignableWithNoProvisionalErrors"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["Subtype"] = 3] = "Subtype"; + })(OverloadApplicabilityStatus || (OverloadApplicabilityStatus = {})); + + var PullAdditionalCallResolutionData = (function () { + function PullAdditionalCallResolutionData() { + this.targetSymbol = null; + this.resolvedSignatures = null; + this.candidateSignature = null; + this.actualParametersContextTypeSymbols = null; + this.diagnosticsFromOverloadResolution = []; + } + return PullAdditionalCallResolutionData; + })(); + TypeScript.PullAdditionalCallResolutionData = PullAdditionalCallResolutionData; + + var PullAdditionalObjectLiteralResolutionData = (function () { + function PullAdditionalObjectLiteralResolutionData() { + this.membersContextTypeSymbols = null; + } + return PullAdditionalObjectLiteralResolutionData; + })(); + TypeScript.PullAdditionalObjectLiteralResolutionData = PullAdditionalObjectLiteralResolutionData; + + var MemberWithBaseOrigin = (function () { + function MemberWithBaseOrigin(memberSymbol, baseOrigin) { + this.memberSymbol = memberSymbol; + this.baseOrigin = baseOrigin; + } + return MemberWithBaseOrigin; + })(); + + var SignatureWithBaseOrigin = (function () { + function SignatureWithBaseOrigin(signature, baseOrigin) { + this.signature = signature; + this.baseOrigin = baseOrigin; + } + return SignatureWithBaseOrigin; + })(); + + var InheritedIndexSignatureInfo = (function () { + function InheritedIndexSignatureInfo() { + } + return InheritedIndexSignatureInfo; + })(); + + var CompilerReservedNames; + (function (CompilerReservedNames) { + CompilerReservedNames[CompilerReservedNames["_this"] = 1] = "_this"; + CompilerReservedNames[CompilerReservedNames["_super"] = 2] = "_super"; + CompilerReservedNames[CompilerReservedNames["arguments"] = 3] = "arguments"; + CompilerReservedNames[CompilerReservedNames["_i"] = 4] = "_i"; + CompilerReservedNames[CompilerReservedNames["require"] = 5] = "require"; + CompilerReservedNames[CompilerReservedNames["exports"] = 6] = "exports"; + })(CompilerReservedNames || (CompilerReservedNames = {})); + + function getCompilerReservedName(name) { + var nameText = name.valueText(); + var index = CompilerReservedNames[nameText]; + return CompilerReservedNames[index] ? index : undefined; + } + + var PullTypeResolver = (function () { + function PullTypeResolver(compilationSettings, semanticInfoChain) { + this.compilationSettings = compilationSettings; + this.semanticInfoChain = semanticInfoChain; + this._cachedArrayInterfaceType = null; + this._cachedNumberInterfaceType = null; + this._cachedStringInterfaceType = null; + this._cachedBooleanInterfaceType = null; + this._cachedObjectInterfaceType = null; + this._cachedFunctionInterfaceType = null; + this._cachedIArgumentsInterfaceType = null; + this._cachedRegExpInterfaceType = null; + this._cachedAnyTypeArgs = null; + this.typeCheckCallBacks = []; + this.postTypeCheckWorkitems = []; + this._cachedFunctionArgumentsSymbol = null; + this.assignableCache = TypeScript.BitMatrix.getBitMatrix(true); + this.subtypeCache = TypeScript.BitMatrix.getBitMatrix(true); + this.identicalCache = TypeScript.BitMatrix.getBitMatrix(true); + } + PullTypeResolver.prototype.cachedArrayInterfaceType = function () { + if (!this._cachedArrayInterfaceType) { + this._cachedArrayInterfaceType = this.getSymbolFromDeclPath("Array", [], 16 /* Interface */); + } + + if (!this._cachedArrayInterfaceType) { + this._cachedArrayInterfaceType = this.semanticInfoChain.anyTypeSymbol; + } + + if (!this._cachedArrayInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedArrayInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedArrayInterfaceType; + }; + + PullTypeResolver.prototype.getArrayNamedType = function () { + return this.cachedArrayInterfaceType(); + }; + + PullTypeResolver.prototype.cachedNumberInterfaceType = function () { + if (!this._cachedNumberInterfaceType) { + this._cachedNumberInterfaceType = this.getSymbolFromDeclPath("Number", [], 16 /* Interface */); + } + + if (this._cachedNumberInterfaceType && !this._cachedNumberInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedNumberInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedNumberInterfaceType; + }; + + PullTypeResolver.prototype.cachedStringInterfaceType = function () { + if (!this._cachedStringInterfaceType) { + this._cachedStringInterfaceType = this.getSymbolFromDeclPath("String", [], 16 /* Interface */); + } + + if (this._cachedStringInterfaceType && !this._cachedStringInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedStringInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedStringInterfaceType; + }; + + PullTypeResolver.prototype.cachedBooleanInterfaceType = function () { + if (!this._cachedBooleanInterfaceType) { + this._cachedBooleanInterfaceType = this.getSymbolFromDeclPath("Boolean", [], 16 /* Interface */); + } + + if (this._cachedBooleanInterfaceType && !this._cachedBooleanInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedBooleanInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedBooleanInterfaceType; + }; + + PullTypeResolver.prototype.cachedObjectInterfaceType = function () { + if (!this._cachedObjectInterfaceType) { + this._cachedObjectInterfaceType = this.getSymbolFromDeclPath("Object", [], 16 /* Interface */); + } + + if (!this._cachedObjectInterfaceType) { + this._cachedObjectInterfaceType = this.semanticInfoChain.anyTypeSymbol; + } + + if (!this._cachedObjectInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedObjectInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedObjectInterfaceType; + }; + + PullTypeResolver.prototype.cachedFunctionInterfaceType = function () { + if (!this._cachedFunctionInterfaceType) { + this._cachedFunctionInterfaceType = this.getSymbolFromDeclPath("Function", [], 16 /* Interface */); + } + + if (this._cachedFunctionInterfaceType && !this._cachedFunctionInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedFunctionInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedFunctionInterfaceType; + }; + + PullTypeResolver.prototype.cachedIArgumentsInterfaceType = function () { + if (!this._cachedIArgumentsInterfaceType) { + this._cachedIArgumentsInterfaceType = this.getSymbolFromDeclPath("IArguments", [], 16 /* Interface */); + } + + if (this._cachedIArgumentsInterfaceType && !this._cachedIArgumentsInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedIArgumentsInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedIArgumentsInterfaceType; + }; + + PullTypeResolver.prototype.cachedRegExpInterfaceType = function () { + if (!this._cachedRegExpInterfaceType) { + this._cachedRegExpInterfaceType = this.getSymbolFromDeclPath("RegExp", [], 16 /* Interface */); + } + + if (this._cachedRegExpInterfaceType && !this._cachedRegExpInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedRegExpInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedRegExpInterfaceType; + }; + + PullTypeResolver.prototype.cachedFunctionArgumentsSymbol = function () { + if (!this._cachedFunctionArgumentsSymbol) { + this._cachedFunctionArgumentsSymbol = new TypeScript.PullSymbol("arguments", 512 /* Variable */); + this._cachedFunctionArgumentsSymbol.type = this.cachedIArgumentsInterfaceType() ? this.cachedIArgumentsInterfaceType() : this.semanticInfoChain.anyTypeSymbol; + this._cachedFunctionArgumentsSymbol.setResolved(); + + var functionArgumentsDecl = new TypeScript.PullSynthesizedDecl("arguments", "arguments", 2048 /* Parameter */, 0 /* None */, null, new TypeScript.TextSpan(0, 0), this.semanticInfoChain); + functionArgumentsDecl.setSymbol(this._cachedFunctionArgumentsSymbol); + this._cachedFunctionArgumentsSymbol.addDeclaration(functionArgumentsDecl); + } + + return this._cachedFunctionArgumentsSymbol; + }; + + PullTypeResolver.prototype.setTypeChecked = function (ast, context) { + context.setTypeChecked(ast); + }; + + PullTypeResolver.prototype.canTypeCheckAST = function (ast, context) { + return context.canTypeCheckAST(ast); + }; + + PullTypeResolver.prototype.setSymbolForAST = function (ast, symbol, context) { + if (context && context.inProvisionalResolution()) { + context.setSymbolForAST(ast, symbol); + } else { + this.semanticInfoChain.setSymbolForAST(ast, symbol); + } + }; + + PullTypeResolver.prototype.getSymbolForAST = function (ast, context) { + var symbol = this.semanticInfoChain.getSymbolForAST(ast); + + if (!symbol) { + if (context && context.inProvisionalResolution()) { + symbol = context.getSymbolForAST(ast); + } + } + + return symbol; + }; + + PullTypeResolver.prototype.getASTForDecl = function (decl) { + return this.semanticInfoChain.getASTForDecl(decl); + }; + + PullTypeResolver.prototype.getNewErrorTypeSymbol = function (name) { + if (typeof name === "undefined") { name = null; } + return new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, name); + }; + + PullTypeResolver.prototype.getEnclosingDecl = function (decl) { + var declPath = decl.getParentPath(); + + if (declPath.length > 1 && declPath[declPath.length - 1] === decl) { + return declPath[declPath.length - 2]; + } else { + return declPath[declPath.length - 1]; + } + }; + + PullTypeResolver.prototype.getExportedMemberSymbol = function (symbol, parent) { + if (!(symbol.kind & (65536 /* Method */ | 4096 /* Property */))) { + var isContainer = (parent.kind & (4 /* Container */ | 32 /* DynamicModule */)) != 0; + var containerType = !isContainer ? parent.getAssociatedContainerType() : parent; + + if (isContainer && containerType) { + if (symbol.anyDeclHasFlag(1 /* Exported */)) { + return symbol; + } + + return null; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.getMemberSymbol = function (symbolName, declSearchKind, parent) { + var member = null; + + if (declSearchKind & 68147712 /* SomeValue */) { + member = parent.findMember(symbolName, true); + } else if (declSearchKind & 58728539 /* SomeType */) { + member = parent.findNestedType(symbolName); + } else if (declSearchKind & 164 /* SomeContainer */) { + member = parent.findNestedContainer(symbolName); + } + + if (member) { + return this.getExportedMemberSymbol(member, parent); + } + + var containerType = parent.getAssociatedContainerType(); + + if (containerType) { + if (containerType.isClass()) { + return null; + } + + parent = containerType; + + if (declSearchKind & 68147712 /* SomeValue */) { + member = parent.findMember(symbolName, true); + } else if (declSearchKind & 58728539 /* SomeType */) { + member = parent.findNestedType(symbolName); + } else if (declSearchKind & 164 /* SomeContainer */) { + member = parent.findNestedContainer(symbolName); + } + + if (member) { + return this.getExportedMemberSymbol(member, parent); + } + } + + if (parent.kind & 164 /* SomeContainer */) { + var typeDeclarations = parent.getDeclarations(); + var childDecls = null; + + for (var j = 0; j < typeDeclarations.length; j++) { + childDecls = typeDeclarations[j].searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + member = childDecls[0].getSymbol(); + + if (!member) { + member = childDecls[0].getSignatureSymbol(); + } + return this.getExportedMemberSymbol(member, parent); + } + + if ((declSearchKind & 58728539 /* SomeType */) != 0 || (declSearchKind & 68147712 /* SomeValue */) != 0) { + childDecls = typeDeclarations[j].searchChildDecls(symbolName, 128 /* TypeAlias */); + if (childDecls.length && childDecls[0].kind == 128 /* TypeAlias */) { + var aliasSymbol = this.getExportedMemberSymbol(childDecls[0].getSymbol(), parent); + if (aliasSymbol) { + if ((declSearchKind & 58728539 /* SomeType */) != 0) { + var typeSymbol = aliasSymbol.getExportAssignedTypeSymbol(); + if (typeSymbol) { + return typeSymbol; + } + } else { + var valueSymbol = aliasSymbol.getExportAssignedValueSymbol(); + if (valueSymbol) { + return valueSymbol; + } + } + } + } + } + } + } + }; + + PullTypeResolver.prototype.getSymbolFromDeclPath = function (symbolName, declPath, declSearchKind) { + var symbol = null; + + var decl = null; + var childDecls; + var declSymbol = null; + var declMembers; + var pathDeclKind; + var valDecl = null; + var kind; + var instanceSymbol = null; + var instanceType = null; + var childSymbol = null; + + for (var i = declPath.length - 1; i >= 0; i--) { + decl = declPath[i]; + pathDeclKind = decl.kind; + + if (decl.flags & 2097152 /* DeclaredInAWithBlock */) { + return this.semanticInfoChain.anyTypeSymbol; + } + + if (pathDeclKind & (4 /* Container */ | 32 /* DynamicModule */)) { + childDecls = decl.searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + return childDecls[0].getSymbol(); + } + + if (declSearchKind & 68147712 /* SomeValue */) { + instanceSymbol = decl.getSymbol().getInstanceSymbol(); + + childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */); + + if (childDecls.length) { + var sym = childDecls[0].getSymbol(); + + if (sym.isAlias()) { + return sym; + } + } + + if (instanceSymbol) { + instanceType = instanceSymbol.type; + + childSymbol = this.getMemberSymbol(symbolName, declSearchKind, instanceType); + + if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) { + return childSymbol; + } + } + + valDecl = decl.getValueDecl(); + + if (valDecl) { + decl = valDecl; + } + } + + declSymbol = decl.getSymbol().type; + + var childSymbol = this.getMemberSymbol(symbolName, declSearchKind, declSymbol); + + if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) { + return childSymbol; + } + } else if ((declSearchKind & (58728539 /* SomeType */ | 164 /* SomeContainer */)) || !(pathDeclKind & 8 /* Class */)) { + var candidateSymbol = null; + + if (pathDeclKind === 131072 /* FunctionExpression */ && symbolName === decl.getFunctionExpressionName()) { + candidateSymbol = decl.getSymbol(); + } + + childDecls = decl.searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + if (decl.kind & 1032192 /* SomeFunction */) { + decl.ensureSymbolIsBound(); + } + return childDecls[0].getSymbol(); + } + + if (candidateSymbol) { + return candidateSymbol; + } + + if (declSearchKind & 68147712 /* SomeValue */) { + childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */); + + if (childDecls.length) { + var sym = childDecls[0].getSymbol(); + + if (sym.isAlias()) { + return sym; + } + } + } + } + } + + symbol = this.semanticInfoChain.findSymbol([symbolName], declSearchKind); + + return symbol; + }; + + PullTypeResolver.prototype.getVisibleDeclsFromDeclPath = function (declPath, declSearchKind) { + var result = []; + var decl = null; + var childDecls; + var pathDeclKind; + + for (var i = declPath.length - 1; i >= 0; i--) { + decl = declPath[i]; + pathDeclKind = decl.kind; + + var declKind = decl.kind; + + if (declKind !== 8 /* Class */ && declKind !== 16 /* Interface */) { + this.addFilteredDecls(decl.getChildDecls(), declSearchKind, result); + } + + switch (declKind) { + case 4 /* Container */: + case 32 /* DynamicModule */: + var otherDecls = this.semanticInfoChain.findDeclsFromPath(declPath.slice(0, i + 1), 164 /* SomeContainer */); + for (var j = 0, m = otherDecls.length; j < m; j++) { + var otherDecl = otherDecls[j]; + if (otherDecl === decl) { + continue; + } + + var otherDeclChildren = otherDecl.getChildDecls(); + for (var k = 0, s = otherDeclChildren.length; k < s; k++) { + var otherDeclChild = otherDeclChildren[k]; + if ((otherDeclChild.flags & 1 /* Exported */) && (otherDeclChild.kind & declSearchKind)) { + result.push(otherDeclChild); + } + } + } + + break; + + case 8 /* Class */: + case 16 /* Interface */: + var parameters = decl.getTypeParameters(); + if (parameters && parameters.length) { + this.addFilteredDecls(parameters, declSearchKind, result); + } + + break; + + case 131072 /* FunctionExpression */: + var functionExpressionName = decl.getFunctionExpressionName(); + if (functionExpressionName) { + result.push(decl); + } + + case 16384 /* Function */: + case 32768 /* ConstructorMethod */: + case 65536 /* Method */: + var parameters = decl.getTypeParameters(); + if (parameters && parameters.length) { + this.addFilteredDecls(parameters, declSearchKind, result); + } + + break; + } + } + + var topLevelDecls = this.semanticInfoChain.topLevelDecls(); + for (var i = 0, n = topLevelDecls.length; i < n; i++) { + var topLevelDecl = topLevelDecls[i]; + if (declPath.length > 0 && topLevelDecl.fileName() === declPath[0].fileName()) { + continue; + } + + if (!topLevelDecl.isExternalModule()) { + this.addFilteredDecls(topLevelDecl.getChildDecls(), declSearchKind, result); + } + } + + return result; + }; + + PullTypeResolver.prototype.addFilteredDecls = function (decls, declSearchKind, result) { + if (decls.length) { + for (var i = 0, n = decls.length; i < n; i++) { + var decl = decls[i]; + if (decl.kind & declSearchKind) { + result.push(decl); + } + } + } + }; + + PullTypeResolver.prototype.getVisibleDecls = function (enclosingDecl) { + var declPath = enclosingDecl.getParentPath(); + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + + return this.getVisibleDeclsFromDeclPath(declPath, declSearchKind); + }; + + PullTypeResolver.prototype.getVisibleContextSymbols = function (enclosingDecl, context) { + var contextualTypeSymbol = context.getContextualType(); + if (!contextualTypeSymbol || this.isAnyOrEquivalent(contextualTypeSymbol)) { + return null; + } + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + var members = contextualTypeSymbol.getAllMembers(declSearchKind, 2 /* externallyVisible */); + + for (var i = 0; i < members.length; i++) { + members[i].setUnresolved(); + } + + return members; + }; + + PullTypeResolver.prototype.getVisibleMembersFromExpression = function (expression, enclosingDecl, context) { + var lhs = this.resolveAST(expression, false, context); + + if (isTypesOnlyLocation(expression) && (lhs.kind === 8 /* Class */ || lhs.kind === 16 /* Interface */)) { + return null; + } + + var lhsType = lhs.type; + if (!lhsType) { + return null; + } + + this.resolveDeclaredSymbol(lhsType, context); + + if (lhsType.isContainer() && lhsType.isAlias()) { + lhsType = lhsType.getExportAssignedTypeSymbol(); + } + + while (lhsType.isTypeParameter()) { + lhsType = lhsType.getConstraint(); + if (!lhsType) { + return null; + } + } + + if (this.isAnyOrEquivalent(lhsType)) { + return null; + } + + var memberVisibilty = 2 /* externallyVisible */; + var containerSymbol = lhsType; + if (containerSymbol.kind === 33554432 /* ConstructorType */) { + containerSymbol = containerSymbol.getConstructSignatures()[0].returnType; + } + + if (containerSymbol && containerSymbol.isClass()) { + var declPath = enclosingDecl.getParentPath(); + if (declPath && declPath.length) { + var declarations = containerSymbol.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + var declaration = declarations[i]; + if (TypeScript.ArrayUtilities.contains(declPath, declaration)) { + memberVisibilty = 1 /* internallyVisible */; + break; + } + } + } + } + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + + var members = []; + + if (lhsType.isContainer()) { + var exportedAssignedContainerSymbol = lhsType.getExportAssignedContainerSymbol(); + if (exportedAssignedContainerSymbol) { + lhsType = exportedAssignedContainerSymbol; + } + } + + if (lhsType.isTypeParameter()) { + var constraint = lhsType.getConstraint(); + + if (constraint) { + lhsType = constraint; + members = lhsType.getAllMembers(declSearchKind, 2 /* externallyVisible */); + } + } else { + if (lhs.kind == 67108864 /* EnumMember */) { + lhsType = this.semanticInfoChain.numberTypeSymbol; + } + + if (lhsType === this.semanticInfoChain.numberTypeSymbol && this.cachedNumberInterfaceType()) { + lhsType = this.cachedNumberInterfaceType(); + } else if (lhsType === this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + lhsType = this.cachedStringInterfaceType(); + } else if (lhsType === this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + lhsType = this.cachedBooleanInterfaceType(); + } + + if (!lhsType.isResolved) { + var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context); + + if (potentiallySpecializedType != lhsType) { + if (!lhs.isType()) { + context.setTypeInContext(lhs, potentiallySpecializedType); + } + + lhsType = potentiallySpecializedType; + } + } + + members = lhsType.getAllMembers(declSearchKind, memberVisibilty); + + if (lhsType.isContainer()) { + var associatedInstance = lhsType.getInstanceSymbol(); + if (associatedInstance) { + var instanceType = associatedInstance.type; + this.resolveDeclaredSymbol(instanceType, context); + var instanceMembers = instanceType.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(instanceMembers); + } + + var exportedContainer = lhsType.getExportAssignedContainerSymbol(); + if (exportedContainer) { + var exportedContainerMembers = exportedContainer.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(exportedContainerMembers); + } + } else if (!lhsType.isConstructor()) { + var associatedContainerSymbol = lhsType.getAssociatedContainerType(); + if (associatedContainerSymbol) { + var containerType = associatedContainerSymbol.type; + this.resolveDeclaredSymbol(containerType, context); + var containerMembers = containerType.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(containerMembers); + } + } + } + + if ((lhsType.getCallSignatures().length || lhsType.getConstructSignatures().length) && this.cachedFunctionInterfaceType()) { + members = members.concat(this.cachedFunctionInterfaceType().getAllMembers(declSearchKind, 2 /* externallyVisible */)); + } + + return members; + }; + + PullTypeResolver.prototype.isAnyOrEquivalent = function (type) { + return (type === this.semanticInfoChain.anyTypeSymbol) || type.isError(); + }; + + PullTypeResolver.prototype.resolveExternalModuleReference = function (idText, currentFileName) { + var originalIdText = idText; + var symbol = null; + + if (TypeScript.isRelative(originalIdText)) { + var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName)); + symbol = this.semanticInfoChain.findExternalModule(path + idText); + } else { + idText = originalIdText; + + symbol = this.semanticInfoChain.findAmbientExternalModuleInGlobalContext(TypeScript.quoteStr(originalIdText)); + + if (!symbol) { + var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName)); + + while (symbol === null && path != "") { + symbol = this.semanticInfoChain.findExternalModule(path + idText); + if (symbol === null) { + if (path === '/') { + path = ''; + } else { + path = TypeScript.normalizePath(path + ".."); + path = path && path != '/' ? path + '/' : path; + } + } + } + } + } + + return symbol; + }; + + PullTypeResolver.prototype.resolveDeclaredSymbol = function (symbol, context) { + if (!symbol || symbol.isResolved || symbol.isTypeReference()) { + return symbol; + } + + if (!context) { + context = new TypeScript.PullTypeResolutionContext(this); + } + + return this.resolveDeclaredSymbolWorker(symbol, context); + }; + + PullTypeResolver.prototype.resolveDeclaredSymbolWorker = function (symbol, context) { + if (!symbol || symbol.isResolved) { + return symbol; + } + + if (symbol.inResolution) { + if (!symbol.type && !symbol.isType()) { + symbol.type = this.semanticInfoChain.anyTypeSymbol; + } + + return symbol; + } + + var decls = symbol.getDeclarations(); + + for (var i = 0; i < decls.length; i++) { + var decl = decls[i]; + + var ast = this.semanticInfoChain.getASTForDecl(decl); + + if (!ast || (ast.kind() === 139 /* GetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (ast.kind() === 140 /* SetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) { + return symbol; + } + + if (ast.kind() === 11 /* IdentifierName */ && ast.parent && ast.parent.kind() === 236 /* CatchClause */) { + return symbol; + } + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(ast); + var resolvedSymbol; + if (TypeScript.isAnyNameOfModule(enclosingModule, ast)) { + resolvedSymbol = this.resolveSingleModuleDeclaration(enclosingModule, ast, context); + } else if (ast.kind() === 120 /* SourceUnit */ && decl.kind === 32 /* DynamicModule */) { + resolvedSymbol = this.resolveModuleSymbol(decl.getSymbol(), context, null, null, ast); + } else { + TypeScript.Debug.assert(ast.kind() != 11 /* IdentifierName */ && ast.kind() != 212 /* MemberAccessExpression */); + var resolvedSymbol = this.resolveAST(ast, false, context); + } + + if (decl.kind == 2048 /* Parameter */ && !symbol.isResolved && !symbol.type && resolvedSymbol && symbol.anyDeclHasFlag(8388608 /* PropertyParameter */ | 67108864 /* ConstructorParameter */)) { + symbol.type = resolvedSymbol.type; + symbol.setResolved(); + } + } + + return symbol; + }; + + PullTypeResolver.prototype.resolveOtherDeclarations = function (astName, context) { + var resolvedDecl = this.semanticInfoChain.getDeclForAST(astName); + var symbol = resolvedDecl.getSymbol(); + + var allDecls = symbol.getDeclarations(); + for (var i = 0; i < allDecls.length; i++) { + var currentDecl = allDecls[i]; + var astForCurrentDecl = this.getASTForDecl(currentDecl); + if (astForCurrentDecl != astName) { + var moduleDecl = TypeScript.getEnclosingModuleDeclaration(astForCurrentDecl); + if (TypeScript.isAnyNameOfModule(moduleDecl, astForCurrentDecl)) { + this.resolveSingleModuleDeclaration(moduleDecl, astForCurrentDecl, context); + } else { + this.resolveAST(astForCurrentDecl, false, context); + } + } + } + }; + + PullTypeResolver.prototype.resolveSourceUnit = function (sourceUnit, context) { + var enclosingDecl = this.getEnclosingDeclForAST(sourceUnit); + var moduleSymbol = enclosingDecl.getSymbol(); + this.ensureAllSymbolsAreBound(moduleSymbol); + + this.resolveFirstExportAssignmentStatement(sourceUnit.moduleElements, context); + this.resolveAST(sourceUnit.moduleElements, false, context); + + if (this.canTypeCheckAST(sourceUnit, context)) { + this.typeCheckSourceUnit(sourceUnit, context); + } + + return moduleSymbol; + }; + + PullTypeResolver.prototype.typeCheckSourceUnit = function (sourceUnit, context) { + this.setTypeChecked(sourceUnit, context); + + this.resolveAST(sourceUnit.moduleElements, false, context); + }; + + PullTypeResolver.prototype.resolveEnumDeclaration = function (ast, context) { + var containerDecl = this.semanticInfoChain.getDeclForAST(ast); + var containerSymbol = containerDecl.getSymbol(); + + if (containerSymbol.isResolved || containerSymbol.inResolution) { + return containerSymbol; + } + + containerSymbol.inResolution = true; + + var containerDecls = containerSymbol.getDeclarations(); + + for (var i = 0; i < containerDecls.length; i++) { + var childDecls = containerDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + + containerSymbol.setResolved(); + + this.resolveOtherDeclarations(ast, context); + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckEnumDeclaration(ast, context); + } + + return containerSymbol; + }; + + PullTypeResolver.prototype.typeCheckEnumDeclaration = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.enumElements, false, context); + var containerDecl = this.semanticInfoChain.getDeclForAST(ast); + this.validateVariableDeclarationGroups(containerDecl, context); + + if (!TypeScript.enumIsElided(ast)) { + this.checkNameForCompilerGeneratedDeclarationCollision(ast, true, ast.identifier, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckEnumDeclaration = function (ast, context) { + this.checkThisCaptureVariableCollides(ast, true, context); + }; + + PullTypeResolver.prototype.resolveModuleDeclaration = function (ast, context) { + var result; + + if (ast.stringLiteral) { + result = this.resolveSingleModuleDeclaration(ast, ast.stringLiteral, context); + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + result = this.resolveSingleModuleDeclaration(ast, moduleNames[i], context); + } + } + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckModuleDeclaration(ast, context); + } + + return result; + }; + + PullTypeResolver.prototype.ensureAllSymbolsAreBound = function (containerSymbol) { + if (containerSymbol) { + var containerDecls = containerSymbol.getDeclarations(); + + for (var i = 0; i < containerDecls.length; i++) { + var childDecls = containerDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + } + }; + + PullTypeResolver.prototype.resolveModuleSymbol = function (containerSymbol, context, moduleDeclAST, moduleDeclNameAST, sourceUnitAST) { + if (containerSymbol.isResolved || containerSymbol.inResolution) { + return containerSymbol; + } + + containerSymbol.inResolution = true; + this.ensureAllSymbolsAreBound(containerSymbol); + + var instanceSymbol = containerSymbol.getInstanceSymbol(); + + if (instanceSymbol) { + this.resolveDeclaredSymbol(instanceSymbol, context); + } + + var isLastName = TypeScript.isLastNameOfModule(moduleDeclAST, moduleDeclNameAST); + if (isLastName) { + this.resolveFirstExportAssignmentStatement(moduleDeclAST.moduleElements, context); + } else if (sourceUnitAST) { + this.resolveFirstExportAssignmentStatement(sourceUnitAST.moduleElements, context); + } + + containerSymbol.setResolved(); + + if (moduleDeclNameAST) { + this.resolveOtherDeclarations(moduleDeclNameAST, context); + } + + return containerSymbol; + }; + + PullTypeResolver.prototype.resolveFirstExportAssignmentStatement = function (moduleElements, context) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + if (moduleElement.kind() == 134 /* ExportAssignment */) { + this.resolveExportAssignmentStatement(moduleElement, context); + return; + } + } + }; + + PullTypeResolver.prototype.resolveSingleModuleDeclaration = function (ast, astName, context) { + var containerDecl = this.semanticInfoChain.getDeclForAST(astName); + var containerSymbol = containerDecl.getSymbol(); + + return this.resolveModuleSymbol(containerSymbol, context, ast, astName, null); + }; + + PullTypeResolver.prototype.typeCheckModuleDeclaration = function (ast, context) { + if (ast.stringLiteral) { + this.typeCheckSingleModuleDeclaration(ast, ast.stringLiteral, context); + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + this.typeCheckSingleModuleDeclaration(ast, moduleNames[i], context); + } + } + }; + + PullTypeResolver.prototype.typeCheckSingleModuleDeclaration = function (ast, astName, context) { + this.setTypeChecked(ast, context); + + if (TypeScript.isLastNameOfModule(ast, astName)) { + this.resolveAST(ast.moduleElements, false, context); + } + + var containerDecl = this.semanticInfoChain.getDeclForAST(astName); + this.validateVariableDeclarationGroups(containerDecl, context); + + if (ast.stringLiteral) { + if (TypeScript.isRelative(ast.stringLiteral.valueText())) { + this.semanticInfoChain.addDiagnosticFromAST(ast.stringLiteral, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_specify_relative_module_name); + } + } + + if (!TypeScript.moduleIsElided(ast) && !ast.stringLiteral) { + this.checkNameForCompilerGeneratedDeclarationCollision(astName, true, astName, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckModuleDeclaration = function (ast, context) { + this.checkThisCaptureVariableCollides(ast, true, context); + }; + + PullTypeResolver.prototype.isTypeRefWithoutTypeArgs = function (term) { + if (term.kind() == 11 /* IdentifierName */) { + return true; + } else if (term.kind() == 121 /* QualifiedName */) { + var binex = term; + + if (binex.right.kind() == 11 /* IdentifierName */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.createInstantiatedType = function (type, typeArguments) { + if (!type.isGeneric()) { + return type; + } + + var typeParameters = type.getTypeArgumentsOrTypeParameters(); + + var typeParameterArgumentMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterArgumentMap[typeParameters[i].pullSymbolID] = typeArguments[i] || new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, typeParameters[i].name); + } + + return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap); + }; + + PullTypeResolver.prototype.resolveReferenceTypeDeclaration = function (classOrInterface, name, heritageClauses, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(typeDecl); + var typeDeclSymbol = typeDecl.getSymbol(); + var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */; + var hasVisited = this.getSymbolForAST(classOrInterface, context) != null; + + if ((typeDeclSymbol.isResolved && hasVisited) || (typeDeclSymbol.inResolution && !context.isInBaseTypeResolution())) { + return typeDeclSymbol; + } + + var wasResolving = typeDeclSymbol.inResolution; + typeDeclSymbol.startResolving(); + + if (!typeDeclSymbol.isResolved) { + var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters(); + for (var i = 0; i < typeDeclTypeParameters.length; i++) { + this.resolveDeclaredSymbol(typeDeclTypeParameters[i], context); + } + } + + var typeRefDecls = typeDeclSymbol.getDeclarations(); + + for (var i = 0; i < typeRefDecls.length; i++) { + var childDecls = typeRefDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + + var wasInBaseTypeResolution = context.startBaseTypeResolution(); + + if (!typeDeclIsClass && !hasVisited) { + typeDeclSymbol.resetKnownBaseTypeCount(); + } + + var extendsClause = TypeScript.getExtendsHeritageClause(heritageClauses); + if (extendsClause) { + for (var i = typeDeclSymbol.getKnownBaseTypeCount(); i < extendsClause.typeNames.nonSeparatorCount(); i = typeDeclSymbol.getKnownBaseTypeCount()) { + typeDeclSymbol.incrementKnownBaseCount(); + var parentType = this.resolveTypeReference(extendsClause.typeNames.nonSeparatorAt(i), context); + + if (typeDeclSymbol.isValidBaseKind(parentType, true)) { + this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null); + + if (!typeDeclSymbol.hasBase(parentType) && !parentType.hasBase(typeDeclSymbol)) { + typeDeclSymbol.addExtendedType(parentType); + + var specializations = typeDeclSymbol.getKnownSpecializations(); + + for (var j = 0; j < specializations.length; j++) { + specializations[j].addExtendedType(parentType); + } + } + } else if (parentType && !this.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), context)) { + this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null); + } + } + } + + var implementsClause = TypeScript.getImplementsHeritageClause(heritageClauses); + if (implementsClause && typeDeclIsClass) { + var extendsCount = extendsClause ? extendsClause.typeNames.nonSeparatorCount() : 0; + for (var i = typeDeclSymbol.getKnownBaseTypeCount(); ((i - extendsCount) >= 0) && ((i - extendsCount) < implementsClause.typeNames.nonSeparatorCount()); i = typeDeclSymbol.getKnownBaseTypeCount()) { + typeDeclSymbol.incrementKnownBaseCount(); + var implementedTypeAST = implementsClause.typeNames.nonSeparatorAt(i - extendsCount); + var implementedType = this.resolveTypeReference(implementedTypeAST, context); + + if (typeDeclSymbol.isValidBaseKind(implementedType, false)) { + this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null); + + if (!typeDeclSymbol.hasBase(implementedType) && !implementedType.hasBase(typeDeclSymbol)) { + typeDeclSymbol.addImplementedType(implementedType); + } + } else if (implementedType && !this.getSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), context)) { + this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null); + } + } + } + + context.doneBaseTypeResolution(wasInBaseTypeResolution); + + if (wasInBaseTypeResolution) { + typeDeclSymbol.inResolution = false; + + this.typeCheckCallBacks.push(function (context) { + if (classOrInterface.kind() == 131 /* ClassDeclaration */) { + _this.resolveClassDeclaration(classOrInterface, context); + } else { + _this.resolveInterfaceDeclaration(classOrInterface, context); + } + }); + + return typeDeclSymbol; + } + + if (!typeDeclSymbol.isResolved) { + if (!typeDeclIsClass) { + var callSignatures = typeDeclSymbol.getCallSignatures(); + for (var i = 0; i < callSignatures.length; i++) { + this.resolveDeclaredSymbol(callSignatures[i], context); + } + + var constructSignatures = typeDeclSymbol.getConstructSignatures(); + for (var i = 0; i < constructSignatures.length; i++) { + this.resolveDeclaredSymbol(constructSignatures[i], context); + } + + var indexSignatures = typeDeclSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignatures.length; i++) { + this.resolveDeclaredSymbol(indexSignatures[i], context); + } + } + } + + this.setSymbolForAST(name, typeDeclSymbol, context); + this.setSymbolForAST(classOrInterface, typeDeclSymbol, context); + + typeDeclSymbol.setResolved(); + + return typeDeclSymbol; + }; + + PullTypeResolver.prototype.resolveClassDeclaration = function (classDeclAST, context) { + var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST); + var classDeclSymbol = classDecl.getSymbol(); + if (!classDeclSymbol.isResolved) { + this.resolveReferenceTypeDeclaration(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, context); + + var constructorMethod = classDeclSymbol.getConstructorMethod(); + var extendedTypes = classDeclSymbol.getExtendedTypes(); + var parentType = extendedTypes.length ? extendedTypes[0] : null; + + if (constructorMethod) { + var constructorTypeSymbol = constructorMethod.type; + + var constructSignatures = constructorTypeSymbol.getConstructSignatures(); + + if (!constructSignatures.length) { + var constructorSignature; + + var parentConstructor = parentType ? parentType.getConstructorMethod() : null; + + if (parentConstructor) { + this.resolveDeclaredSymbol(parentConstructor, context); + var parentConstructorType = parentConstructor.type; + var parentConstructSignatures = parentConstructorType.getConstructSignatures(); + + var parentConstructSignature; + var parentParameters; + + if (!parentConstructSignatures.length) { + parentConstructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + parentConstructSignature.returnType = parentType; + parentConstructorType.addConstructSignature(parentConstructSignature); + parentConstructSignature.addDeclaration(parentType.getDeclarations()[0]); + + var parentTypeParameters = parentConstructorType.getTypeParameters(); + + for (var i = 0; i < parentTypeParameters.length; i++) { + parentConstructSignature.addTypeParameter(parentTypeParameters[i]); + } + + parentConstructSignatures = [parentConstructSignature]; + } + + for (var i = 0; i < parentConstructSignatures.length; i++) { + parentConstructSignature = parentConstructSignatures[i]; + parentParameters = parentConstructSignature.parameters; + + constructorSignature = parentConstructSignature.isDefinition() ? new TypeScript.PullDefinitionSignatureSymbol(2097152 /* ConstructSignature */) : new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + constructorSignature.returnType = classDeclSymbol; + + for (var j = 0; j < parentParameters.length; j++) { + constructorSignature.addParameter(parentParameters[j], parentParameters[j].isOptional); + } + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var j = 0; j < typeParameters.length; j++) { + constructorSignature.addTypeParameter(typeParameters[j]); + } + + constructorTypeSymbol.addConstructSignature(constructorSignature); + constructorSignature.addDeclaration(classDecl); + } + } else { + constructorSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + constructorSignature.returnType = classDeclSymbol; + constructorTypeSymbol.addConstructSignature(constructorSignature); + constructorSignature.addDeclaration(classDecl); + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var i = 0; i < typeParameters.length; i++) { + constructorSignature.addTypeParameter(typeParameters[i]); + } + } + } + + if (!classDeclSymbol.isResolved) { + return classDeclSymbol; + } + + if (parentType) { + var parentConstructorSymbol = parentType.getConstructorMethod(); + + if (parentConstructorSymbol) { + var parentConstructorTypeSymbol = parentConstructorSymbol.type; + + if (!constructorTypeSymbol.hasBase(parentConstructorTypeSymbol)) { + constructorTypeSymbol.addExtendedType(parentConstructorTypeSymbol); + } + } + } + } + + this.resolveOtherDeclarations(classDeclAST, context); + } + + if (this.canTypeCheckAST(classDeclAST, context)) { + this.typeCheckClassDeclaration(classDeclAST, context); + } + + return classDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckTypeParametersOfTypeDeclaration = function (classOrInterface, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var typeDeclSymbol = typeDecl.getSymbol(); + var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters(); + for (var i = 0; i < typeDeclTypeParameters.length; i++) { + this.checkSymbolPrivacy(typeDeclSymbol, typeDeclTypeParameters[i], function (symbol) { + return _this.typeParameterOfTypeDeclarationPrivacyErrorReporter(classOrInterface, i, typeDeclTypeParameters[i], symbol, context); + }); + } + }; + + PullTypeResolver.prototype.typeCheckClassDeclaration = function (classDeclAST, context) { + this.setTypeChecked(classDeclAST, context); + + var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST); + var classDeclSymbol = classDecl.getSymbol(); + + this.checkNameForCompilerGeneratedDeclarationCollision(classDeclAST, true, classDeclAST.identifier, context); + this.resolveAST(classDeclAST.classElements, false, context); + + this.typeCheckTypeParametersOfTypeDeclaration(classDeclAST, context); + this.typeCheckBases(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, classDeclSymbol, this.getEnclosingDecl(classDecl), context); + + if (!classDeclSymbol.hasBaseTypeConflict()) { + this.typeCheckMembersAgainstIndexer(classDeclSymbol, classDecl, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckClassDeclaration = function (classDeclAST, context) { + this.checkThisCaptureVariableCollides(classDeclAST, true, context); + }; + + PullTypeResolver.prototype.resolveTypeSymbolSignatures = function (typeSymbol, context) { + var callSignatures = typeSymbol.getCallSignatures(); + for (var i = 0; i < callSignatures.length; i++) { + this.resolveDeclaredSymbol(callSignatures[i], context); + } + + var constructSignatures = typeSymbol.getConstructSignatures(); + for (var i = 0; i < constructSignatures.length; i++) { + this.resolveDeclaredSymbol(constructSignatures[i], context); + } + + var indexSignatures = typeSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignatures.length; i++) { + this.resolveDeclaredSymbol(indexSignatures[i], context); + } + }; + + PullTypeResolver.prototype.resolveInterfaceDeclaration = function (interfaceDeclAST, context) { + this.resolveReferenceTypeDeclaration(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, context); + + var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST); + var interfaceDeclSymbol = interfaceDecl.getSymbol(); + + this.resolveTypeSymbolSignatures(interfaceDeclSymbol, context); + + if (interfaceDeclSymbol.isResolved) { + this.resolveOtherDeclarations(interfaceDeclAST, context); + + if (this.canTypeCheckAST(interfaceDeclAST, context)) { + this.typeCheckInterfaceDeclaration(interfaceDeclAST, context); + } + } + + return interfaceDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckInterfaceDeclaration = function (interfaceDeclAST, context) { + this.setTypeChecked(interfaceDeclAST, context); + + var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST); + var interfaceDeclSymbol = interfaceDecl.getSymbol(); + + this.resolveAST(interfaceDeclAST.body.typeMembers, false, context); + + this.typeCheckTypeParametersOfTypeDeclaration(interfaceDeclAST, context); + this.typeCheckBases(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, interfaceDeclSymbol, this.getEnclosingDecl(interfaceDecl), context); + + if (!interfaceDeclSymbol.hasBaseTypeConflict()) { + this.typeCheckMembersAgainstIndexer(interfaceDeclSymbol, interfaceDecl, context); + } + }; + + PullTypeResolver.prototype.filterSymbol = function (symbol, kind, enclosingDecl, context) { + if (symbol) { + if (symbol.kind & kind) { + return symbol; + } + + if (symbol.isAlias()) { + this.resolveDeclaredSymbol(symbol, context); + + var alias = symbol; + if (kind & 164 /* SomeContainer */) { + return alias.getExportAssignedContainerSymbol(); + } else if (kind & 58728539 /* SomeType */) { + return alias.getExportAssignedTypeSymbol(); + } else if (kind & 68147712 /* SomeValue */) { + return alias.getExportAssignedValueSymbol(); + } + } + } + return null; + }; + + PullTypeResolver.prototype.getMemberSymbolOfKind = function (symbolName, kind, pullTypeSymbol, enclosingDecl, context) { + var memberSymbol = this.getMemberSymbol(symbolName, kind, pullTypeSymbol); + + return { + symbol: this.filterSymbol(memberSymbol, kind, enclosingDecl, context), + aliasSymbol: memberSymbol && memberSymbol.isAlias() ? memberSymbol : null + }; + }; + + PullTypeResolver.prototype.resolveIdentifierOfInternalModuleReference = function (importDecl, identifier, moduleSymbol, enclosingDecl, context) { + var rhsName = identifier.valueText(); + if (rhsName.length === 0) { + return null; + } + + var moduleTypeSymbol = moduleSymbol.type; + var memberSymbol = this.getMemberSymbolOfKind(rhsName, 164 /* SomeContainer */, moduleTypeSymbol, enclosingDecl, context); + var containerSymbol = memberSymbol.symbol; + var valueSymbol = null; + var typeSymbol = null; + var aliasSymbol = null; + + var acceptableAlias = true; + + if (containerSymbol) { + acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) != 0; + aliasSymbol = memberSymbol.aliasSymbol; + } + + if (!acceptableAlias && containerSymbol && containerSymbol.kind == 128 /* TypeAlias */) { + this.resolveDeclaredSymbol(containerSymbol, context); + var aliasedAssignedValue = containerSymbol.getExportAssignedValueSymbol(); + var aliasedAssignedType = containerSymbol.getExportAssignedTypeSymbol(); + var aliasedAssignedContainer = containerSymbol.getExportAssignedContainerSymbol(); + + if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) { + aliasSymbol = containerSymbol; + valueSymbol = aliasedAssignedValue; + typeSymbol = aliasedAssignedType; + containerSymbol = aliasedAssignedContainer; + acceptableAlias = true; + } + } + + if (!acceptableAlias) { + this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules); + return null; + } + + if (!valueSymbol) { + if (moduleTypeSymbol.getInstanceSymbol()) { + memberSymbol = this.getMemberSymbolOfKind(rhsName, 68147712 /* SomeValue */, moduleTypeSymbol.getInstanceSymbol().type, enclosingDecl, context); + valueSymbol = memberSymbol.symbol; + if (valueSymbol && memberSymbol.aliasSymbol) { + aliasSymbol = memberSymbol.aliasSymbol; + } + } + } + + if (!typeSymbol) { + memberSymbol = this.getMemberSymbolOfKind(rhsName, 58728539 /* SomeType */, moduleTypeSymbol, enclosingDecl, context); + typeSymbol = memberSymbol.symbol; + if (typeSymbol && memberSymbol.aliasSymbol) { + aliasSymbol = memberSymbol.aliasSymbol; + } + } + + if (!valueSymbol && !typeSymbol && !containerSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Could_not_find_symbol_0_in_module_1, [rhsName, moduleSymbol.toString()]); + return null; + } + + if (!typeSymbol && containerSymbol) { + typeSymbol = containerSymbol; + } + + return { + valueSymbol: valueSymbol, + typeSymbol: typeSymbol, + containerSymbol: containerSymbol, + aliasSymbol: aliasSymbol + }; + }; + + PullTypeResolver.prototype.resolveModuleReference = function (importDecl, moduleNameExpr, enclosingDecl, context, declPath) { + TypeScript.Debug.assert(moduleNameExpr.kind() == 121 /* QualifiedName */ || moduleNameExpr.kind() == 11 /* IdentifierName */ || moduleNameExpr.kind() === 14 /* StringLiteral */, "resolving module reference should always be either name or member reference"); + + var moduleSymbol = null; + var moduleName; + + if (moduleNameExpr.kind() == 121 /* QualifiedName */) { + var dottedNameAST = moduleNameExpr; + var moduleContainer = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath); + if (moduleContainer) { + moduleName = dottedNameAST.right.valueText(); + + moduleSymbol = this.getMemberSymbolOfKind(moduleName, 4 /* Container */, moduleContainer.type, enclosingDecl, context).symbol; + if (!moduleSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.Could_not_find_module_0_in_module_1, [moduleName, moduleContainer.toString()]); + } + } + } else { + var valueText = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.valueText() : moduleNameExpr.valueText(); + var text = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.text() : moduleNameExpr.text(); + + if (text.length > 0) { + var resolvedModuleNameSymbol = this.getSymbolFromDeclPath(valueText, declPath, 4 /* Container */); + moduleSymbol = this.filterSymbol(resolvedModuleNameSymbol, 4 /* Container */, enclosingDecl, context); + if (moduleSymbol) { + this.semanticInfoChain.setSymbolForAST(moduleNameExpr, moduleSymbol); + if (resolvedModuleNameSymbol.isAlias()) { + this.semanticInfoChain.setAliasSymbolForAST(moduleNameExpr, resolvedModuleNameSymbol); + } + } else { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameExpr, TypeScript.DiagnosticCode.Unable_to_resolve_module_reference_0, [valueText]); + } + } + } + + return moduleSymbol; + }; + + PullTypeResolver.prototype.resolveInternalModuleReference = function (importStatementAST, context) { + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + + var moduleReference = importStatementAST.moduleReference; + + var aliasExpr = moduleReference.kind() === 245 /* ExternalModuleReference */ ? moduleReference.stringLiteral : moduleReference.moduleName; + + var declPath = enclosingDecl.getParentPath(); + var aliasedType = null; + + if (aliasExpr.kind() === 11 /* IdentifierName */ || aliasExpr.kind() === 14 /* StringLiteral */) { + var moduleSymbol = this.resolveModuleReference(importDecl, aliasExpr, enclosingDecl, context, declPath); + if (moduleSymbol) { + aliasedType = moduleSymbol.type; + this.semanticInfoChain.setAliasSymbolForAST(moduleReference, this.semanticInfoChain.getAliasSymbolForAST(aliasExpr)); + if (aliasedType.anyDeclHasFlag(32768 /* InitializedModule */)) { + var moduleName = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.valueText() : aliasExpr.valueText(); + var valueSymbol = this.getSymbolFromDeclPath(moduleName, declPath, 68147712 /* SomeValue */); + var instanceSymbol = aliasedType.getInstanceSymbol(); + + if (valueSymbol && (instanceSymbol != valueSymbol || valueSymbol.type == aliasedType)) { + var text = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.text() : aliasExpr.text(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(aliasExpr, TypeScript.DiagnosticCode.Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1, [text, moduleSymbol.type.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + } else { + var importDeclSymbol = importDecl.getSymbol(); + importDeclSymbol.setAssignedValueSymbol(valueSymbol); + } + } + } else { + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } + } else if (aliasExpr.kind() == 121 /* QualifiedName */) { + var importDeclSymbol = importDecl.getSymbol(); + var dottedNameAST = aliasExpr; + var moduleSymbol = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath); + if (moduleSymbol) { + var identifierResolution = this.resolveIdentifierOfInternalModuleReference(importDecl, dottedNameAST.right, moduleSymbol, enclosingDecl, context); + if (identifierResolution) { + importDeclSymbol.setAssignedValueSymbol(identifierResolution.valueSymbol); + importDeclSymbol.setAssignedTypeSymbol(identifierResolution.typeSymbol); + importDeclSymbol.setAssignedContainerSymbol(identifierResolution.containerSymbol); + this.semanticInfoChain.setAliasSymbolForAST(moduleReference, identifierResolution.aliasSymbol); + if (identifierResolution.valueSymbol) { + importDeclSymbol.setIsUsedAsValue(true); + } + return null; + } + } + + importDeclSymbol.setAssignedTypeSymbol(this.semanticInfoChain.anyTypeSymbol); + } + + return aliasedType; + }; + + PullTypeResolver.prototype.resolveImportDeclaration = function (importStatementAST, context) { + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + var importDeclSymbol = importDecl.getSymbol(); + + var aliasedType = null; + + if (importDeclSymbol.isResolved) { + return importDeclSymbol; + } + + importDeclSymbol.startResolving(); + + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var modPath = importStatementAST.moduleReference.stringLiteral.valueText(); + var declPath = enclosingDecl.getParentPath(); + + aliasedType = this.resolveExternalModuleReference(modPath, importDecl.fileName()); + + if (!aliasedType) { + var path = importStatementAST.moduleReference.stringLiteral.text(); + this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Unable_to_resolve_external_module_0, [path]); + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } + } else { + aliasedType = this.resolveInternalModuleReference(importStatementAST, context); + } + + if (aliasedType) { + if (!aliasedType.isContainer()) { + this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Module_cannot_be_aliased_to_a_non_module_type); + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } else if (aliasedType.getExportAssignedValueSymbol()) { + importDeclSymbol.setIsUsedAsValue(true); + } + + if (aliasedType.isContainer()) { + importDeclSymbol.setAssignedContainerSymbol(aliasedType); + } + importDeclSymbol.setAssignedTypeSymbol(aliasedType); + + this.setSymbolForAST(importStatementAST.moduleReference, aliasedType, null); + } + + importDeclSymbol.setResolved(); + + this.resolveDeclaredSymbol(importDeclSymbol.assignedValue(), context); + this.resolveDeclaredSymbol(importDeclSymbol.assignedType(), context); + this.resolveDeclaredSymbol(importDeclSymbol.assignedContainer(), context); + + if (this.canTypeCheckAST(importStatementAST, context)) { + this.typeCheckImportDeclaration(importStatementAST, context); + } + + return importDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckImportDeclaration = function (importStatementAST, context) { + var _this = this; + this.setTypeChecked(importStatementAST, context); + + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + var importDeclSymbol = importDecl.getSymbol(); + + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + if (this.compilationSettings.noResolve()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set, null)); + } + + var modPath = importStatementAST.moduleReference.stringLiteral.valueText(); + if (enclosingDecl.kind === 32 /* DynamicModule */) { + var ast = TypeScript.getEnclosingModuleDeclaration(this.getASTForDecl(enclosingDecl)); + if (ast && ast.kind() === 130 /* ModuleDeclaration */) { + if (TypeScript.isRelative(modPath)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name)); + } + } + } + } + + var checkPrivacy; + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol(); + var container = containerSymbol ? containerSymbol.getContainer() : null; + if (container && container.kind == 32 /* DynamicModule */) { + checkPrivacy = true; + } + } else { + checkPrivacy = true; + } + + if (checkPrivacy) { + var typeSymbol = importDeclSymbol.getExportAssignedTypeSymbol(); + var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol(); + var valueSymbol = importDeclSymbol.getExportAssignedValueSymbol(); + + this.checkSymbolPrivacy(importDeclSymbol, containerSymbol, function (symbol) { + var messageCode = TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1; + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + + if (typeSymbol != containerSymbol) { + this.checkSymbolPrivacy(importDeclSymbol, typeSymbol, function (symbol) { + var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1; + + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + } + + if (valueSymbol) { + this.checkSymbolPrivacy(importDeclSymbol, valueSymbol.type, function (symbol) { + var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1; + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + } + } + + if (getCompilerReservedName(importStatementAST.identifier)) { + this.postTypeCheckWorkitems.push(importStatementAST); + } + }; + + PullTypeResolver.prototype.postTypeCheckImportDeclaration = function (importStatementAST, context) { + if (TypeScript.importDeclarationIsElided(importStatementAST, this.semanticInfoChain)) { + this.checkNameForCompilerGeneratedDeclarationCollision(importStatementAST, true, importStatementAST.identifier, context, true); + } + }; + + PullTypeResolver.prototype.resolveExportAssignmentStatement = function (exportAssignmentAST, context) { + var id = exportAssignmentAST.identifier.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var valueSymbol = null; + var typeSymbol = null; + var containerSymbol = null; + + var enclosingDecl = this.getEnclosingDeclForAST(exportAssignmentAST); + var parentSymbol = enclosingDecl.getSymbol(); + + if (!parentSymbol.isType() && parentSymbol.isContainer()) { + this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_used_at_the_top_level_of_external_modules); + return this.semanticInfoChain.anyTypeSymbol; + } + + var declPath = enclosingDecl !== null ? [enclosingDecl] : []; + + containerSymbol = this.getSymbolFromDeclPath(id, declPath, 164 /* SomeContainer */); + + var acceptableAlias = true; + + if (containerSymbol) { + acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) != 0; + } + + if (!acceptableAlias && containerSymbol && containerSymbol.kind == 128 /* TypeAlias */) { + this.resolveDeclaredSymbol(containerSymbol, context); + + var aliasSymbol = containerSymbol; + var aliasedAssignedValue = aliasSymbol.getExportAssignedValueSymbol(); + var aliasedAssignedType = aliasSymbol.getExportAssignedTypeSymbol(); + var aliasedAssignedContainer = aliasSymbol.getExportAssignedContainerSymbol(); + + if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) { + valueSymbol = aliasedAssignedValue; + typeSymbol = aliasedAssignedType; + containerSymbol = aliasedAssignedContainer; + aliasSymbol.setTypeUsedExternally(true); + acceptableAlias = true; + } + } + + if (!acceptableAlias) { + this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules); + return this.semanticInfoChain.voidTypeSymbol; + } + + if (!valueSymbol) { + valueSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */); + } + if (!typeSymbol) { + typeSymbol = this.getSymbolFromDeclPath(id, declPath, 58728539 /* SomeType */); + } + + if (!valueSymbol && !typeSymbol && !containerSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [id])); + return this.semanticInfoChain.voidTypeSymbol; + } + + if (valueSymbol) { + parentSymbol.setExportAssignedValueSymbol(valueSymbol); + } + if (typeSymbol) { + parentSymbol.setExportAssignedTypeSymbol(typeSymbol); + } + if (containerSymbol) { + parentSymbol.setExportAssignedContainerSymbol(containerSymbol); + } + + this.resolveDeclaredSymbol(valueSymbol, context); + this.resolveDeclaredSymbol(typeSymbol, context); + this.resolveDeclaredSymbol(containerSymbol, context); + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveAnyFunctionTypeSignature = function (funcDeclAST, typeParameters, parameterList, returnTypeAnnotation, context) { + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + TypeScript.Debug.assert(functionDecl); + + var funcDeclSymbol = functionDecl.getSymbol(); + + var signature = funcDeclSymbol.kind === 33554432 /* ConstructorType */ ? funcDeclSymbol.getConstructSignatures()[0] : funcDeclSymbol.getCallSignatures()[0]; + + if (returnTypeAnnotation) { + signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context); + } + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + if (parameterList) { + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveFunctionTypeSignatureParameter(parameterList.parameters.nonSeparatorAt(i), signature, functionDecl, context); + } + } + + funcDeclSymbol.setResolved(); + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.setTypeChecked(funcDeclAST, context); + this.typeCheckFunctionOverloads(funcDeclAST, context); + } + + return funcDeclSymbol; + }; + + PullTypeResolver.prototype.resolveFunctionTypeSignatureParameter = function (argDeclAST, signature, enclosingDecl, context) { + var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST); + var paramSymbol = paramDecl.getSymbol(); + + if (argDeclAST.typeAnnotation) { + var typeRef = this.resolveTypeReference(TypeScript.getType(argDeclAST), context); + + if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) { + var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeRef = this.getNewErrorTypeSymbol(); + } + + context.setTypeInContext(paramSymbol, typeRef); + } else { + if (paramSymbol.isVarArg && paramSymbol.type) { + if (this.cachedArrayInterfaceType()) { + context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [paramSymbol.type])); + } else { + context.setTypeInContext(paramSymbol, paramSymbol.type); + } + } else { + context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol); + + if (this.compilationSettings.noImplicitAny()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_function_type_implicitly_has_an_any_type, [argDeclAST.identifier.text()])); + } + } + } + + paramSymbol.setResolved(); + }; + + PullTypeResolver.prototype.resolveFunctionExpressionParameter = function (argDeclAST, id, typeExpr, equalsValueClause, contextParam, enclosingDecl, context) { + var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST); + var paramSymbol = paramDecl.getSymbol(); + var contextualType = contextParam && contextParam.type; + var isImplicitAny = false; + + if (typeExpr) { + var typeRef = this.resolveTypeReference(typeExpr, context); + + if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) { + var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeRef = this.getNewErrorTypeSymbol(); + } + + contextualType = typeRef || contextualType; + } + if (contextualType) { + context.setTypeInContext(paramSymbol, contextualType); + } else if (paramSymbol.isVarArg && this.cachedArrayInterfaceType()) { + context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol])); + isImplicitAny = true; + } + + var canTypeCheckAST = this.canTypeCheckAST(argDeclAST, context); + if (equalsValueClause && (canTypeCheckAST || !contextualType)) { + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + var initExprSymbol = this.resolveAST(equalsValueClause, contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + } + + if (!initExprSymbol || !initExprSymbol.type) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [id.text()])); + + if (!contextualType) { + context.setTypeInContext(paramSymbol, this.getNewErrorTypeSymbol(paramSymbol.name)); + } + } else { + var initTypeSymbol = this.getInstanceTypeForAssignment(argDeclAST, initExprSymbol.type, context); + if (!contextualType) { + context.setTypeInContext(paramSymbol, this.widenType(initTypeSymbol, equalsValueClause, context)); + isImplicitAny = initTypeSymbol !== paramSymbol.type; + } else { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, contextualType, argDeclAST, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(argDeclAST); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol)])); + } + } + } + } + } + + if (!contextualType && !paramSymbol.isVarArg && !initTypeSymbol) { + context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol); + isImplicitAny = true; + } + + if (isImplicitAny && this.compilationSettings.noImplicitAny()) { + var functionExpressionName = paramDecl.getParentDecl().getFunctionExpressionName(); + if (functionExpressionName) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [id.text(), functionExpressionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_lambda_function_implicitly_has_an_any_type, [id.text()])); + } + } + + if (canTypeCheckAST) { + this.checkNameForCompilerGeneratedDeclarationCollision(argDeclAST, true, id, context); + } + + paramSymbol.setResolved(); + }; + + PullTypeResolver.prototype.checkNameForCompilerGeneratedDeclarationCollision = function (astWithName, isDeclaration, name, context, immediateThisCheck) { + var compilerReservedName = getCompilerReservedName(name); + if (compilerReservedName) { + switch (compilerReservedName) { + case 1 /* _this */: + if (immediateThisCheck) { + this.checkThisCaptureVariableCollides(astWithName, isDeclaration, context); + } else { + this.postTypeCheckWorkitems.push(astWithName); + } + return; + + case 2 /* _super */: + this.checkSuperCaptureVariableCollides(astWithName, isDeclaration, context); + return; + + case 3 /* arguments */: + this.checkArgumentsCollides(astWithName, context); + return; + + case 4 /* _i */: + if (isDeclaration) { + this.checkIndexOfRestArgumentInitializationCollides(astWithName, context); + } + return; + + case 5 /* require */: + case 6 /* exports */: + if (isDeclaration) { + this.checkExternalModuleRequireExportsCollides(astWithName, name, context); + } + return; + + default: + TypeScript.Debug.fail("Unknown compiler reserved name: " + name.text()); + } + } + }; + + PullTypeResolver.prototype.hasRestParameterCodeGen = function (someFunctionDecl) { + var enclosingAST = this.getASTForDecl(someFunctionDecl); + var nodeType = enclosingAST.kind(); + + if (nodeType == 129 /* FunctionDeclaration */) { + var functionDeclaration = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.kind == 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && functionDeclaration.block && TypeScript.lastParameterIsRest(functionDeclaration.callSignature.parameterList); + } else if (nodeType === 135 /* MemberFunctionDeclaration */) { + var memberFunction = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.kind == 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && memberFunction.block && TypeScript.lastParameterIsRest(memberFunction.callSignature.parameterList); + } else if (nodeType == 137 /* ConstructorDeclaration */) { + var constructorDeclaration = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.getParentDecl().flags, 8 /* Ambient */) && constructorDeclaration.block && TypeScript.lastParameterIsRest(constructorDeclaration.parameterList); + } else if (nodeType == 218 /* ParenthesizedArrowFunctionExpression */) { + var arrowFunctionExpression = enclosingAST; + return TypeScript.lastParameterIsRest(arrowFunctionExpression.callSignature.parameterList); + } else if (nodeType === 222 /* FunctionExpression */) { + var functionExpression = enclosingAST; + return TypeScript.lastParameterIsRest(functionExpression.callSignature.parameterList); + } + + return false; + }; + + PullTypeResolver.prototype.checkArgumentsCollides = function (ast, context) { + if (ast.kind() == 242 /* Parameter */) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) { + if (this.hasRestParameterCodeGen(enclosingDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters)); + } + } + } + }; + + PullTypeResolver.prototype.checkIndexOfRestArgumentInitializationCollides = function (ast, context) { + if (ast.kind() == 242 /* Parameter */) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) { + if (this.hasRestParameterCodeGen(enclosingDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter)); + } + } + } + }; + + PullTypeResolver.prototype.checkExternalModuleRequireExportsCollides = function (ast, name, context) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(name); + if (TypeScript.isAnyNameOfModule(enclosingModule, name)) { + enclosingDecl = this.getEnclosingDeclForAST(enclosingModule); + } + + if (enclosingDecl && enclosingDecl.kind == 32 /* DynamicModule */) { + var decl = this.semanticInfoChain.getDeclForAST(ast); + + if (!TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) { + var nameText = name.valueText(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, [nameText, nameText])); + } + } + }; + + PullTypeResolver.prototype.resolveObjectTypeTypeReference = function (objectType, context) { + var interfaceDecl = this.semanticInfoChain.getDeclForAST(objectType); + TypeScript.Debug.assert(interfaceDecl); + + var interfaceSymbol = interfaceDecl.getSymbol(); + TypeScript.Debug.assert(interfaceSymbol); + + if (objectType.typeMembers) { + var memberDecl = null; + var memberSymbol = null; + var memberType = null; + var typeMembers = objectType.typeMembers; + + for (var i = 0; i < typeMembers.nonSeparatorCount(); i++) { + memberDecl = this.semanticInfoChain.getDeclForAST(typeMembers.nonSeparatorAt(i)); + memberSymbol = (memberDecl.kind & 7340032 /* SomeSignature */) ? memberDecl.getSignatureSymbol() : memberDecl.getSymbol(); + + this.resolveAST(typeMembers.nonSeparatorAt(i), false, context); + + memberType = memberSymbol.type; + + if ((memberType && memberType.isGeneric()) || (memberSymbol.isSignature() && memberSymbol.isGeneric())) { + interfaceSymbol.setHasGenericMember(); + } + } + } + + interfaceSymbol.setResolved(); + + if (this.canTypeCheckAST(objectType, context)) { + this.typeCheckObjectTypeTypeReference(objectType, context); + } + + return interfaceSymbol; + }; + + PullTypeResolver.prototype.typeCheckObjectTypeTypeReference = function (objectType, context) { + this.setTypeChecked(objectType, context); + var objectTypeDecl = this.semanticInfoChain.getDeclForAST(objectType); + var objectTypeSymbol = objectTypeDecl.getSymbol(); + + this.typeCheckMembersAgainstIndexer(objectTypeSymbol, objectTypeDecl, context); + }; + + PullTypeResolver.prototype.resolveTypeAnnotation = function (typeAnnotation, context) { + return this.resolveTypeReference(typeAnnotation.type, context); + }; + + PullTypeResolver.prototype.resolveTypeReference = function (typeRef, context) { + if (typeRef === null) { + return null; + } + + TypeScript.Debug.assert(typeRef.kind() !== 244 /* TypeAnnotation */); + + var aliasType = null; + var type = this.computeTypeReferenceSymbol(typeRef, context); + + if (type.kind == 4 /* Container */) { + var container = type; + var instanceSymbol = container.getInstanceSymbol(); + + if (instanceSymbol && (instanceSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */) || instanceSymbol.kind == 32768 /* ConstructorMethod */)) { + type = instanceSymbol.type.getAssociatedContainerType(); + } + } + + if (type && type.isAlias()) { + aliasType = type; + type = aliasType.getExportAssignedTypeSymbol(); + } + + if (type && !type.isGeneric()) { + if (aliasType) { + this.semanticInfoChain.setAliasSymbolForAST(typeRef, aliasType); + } + } + + if (type && !type.isError()) { + if ((type.kind & 58728539 /* SomeType */) === 0) { + if (type.kind & 164 /* SomeContainer */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_cannot_refer_to_container_0, [aliasType ? aliasType.toString() : type.toString()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_must_refer_to_type)); + } + } + } + + if (this.canTypeCheckAST(typeRef, context)) { + this.setTypeChecked(typeRef, context); + } + + return type; + }; + + PullTypeResolver.prototype.computeTypeReferenceSymbol = function (term, context) { + switch (term.kind()) { + case 60 /* AnyKeyword */: + return this.semanticInfoChain.anyTypeSymbol; + case 61 /* BooleanKeyword */: + return this.semanticInfoChain.booleanTypeSymbol; + case 67 /* NumberKeyword */: + return this.semanticInfoChain.numberTypeSymbol; + case 69 /* StringKeyword */: + return this.semanticInfoChain.stringTypeSymbol; + case 41 /* VoidKeyword */: + return this.semanticInfoChain.voidTypeSymbol; + } + + var typeDeclSymbol = null; + + if (term.kind() === 11 /* IdentifierName */) { + typeDeclSymbol = this.resolveTypeNameExpression(term, context); + } else if (term.kind() === 123 /* FunctionType */) { + var functionType = term; + typeDeclSymbol = this.resolveAnyFunctionTypeSignature(functionType, functionType.typeParameterList, functionType.parameterList, functionType.type, context); + } else if (term.kind() === 125 /* ConstructorType */) { + var constructorType = term; + typeDeclSymbol = this.resolveAnyFunctionTypeSignature(constructorType, constructorType.typeParameterList, constructorType.parameterList, constructorType.type, context); + } else if (term.kind() === 122 /* ObjectType */) { + typeDeclSymbol = this.resolveObjectTypeTypeReference(term, context); + } else if (term.kind() === 126 /* GenericType */) { + typeDeclSymbol = this.resolveGenericTypeReference(term, context); + } else if (term.kind() === 121 /* QualifiedName */) { + typeDeclSymbol = this.resolveQualifiedName(term, context); + } else if (term.kind() === 14 /* StringLiteral */) { + var stringConstantAST = term; + var enclosingDecl = this.getEnclosingDeclForAST(term); + typeDeclSymbol = new TypeScript.PullStringConstantTypeSymbol(stringConstantAST.text()); + var decl = new TypeScript.PullSynthesizedDecl(stringConstantAST.text(), stringConstantAST.text(), typeDeclSymbol.kind, null, enclosingDecl, new TypeScript.TextSpan(stringConstantAST.start(), stringConstantAST.width()), enclosingDecl.semanticInfoChain()); + typeDeclSymbol.addDeclaration(decl); + } else if (term.kind() === 127 /* TypeQuery */) { + var typeQuery = term; + + var typeQueryTerm = typeQuery.name; + + var valueSymbol = this.resolveAST(typeQueryTerm, false, context); + + if (valueSymbol && valueSymbol.isAlias()) { + if (valueSymbol.assignedValue()) { + valueSymbol = valueSymbol.assignedValue(); + } else { + var containerSymbol = valueSymbol.getExportAssignedContainerSymbol(); + valueSymbol = (containerSymbol && containerSymbol.isContainer() && !containerSymbol.isEnum()) ? containerSymbol.getInstanceSymbol() : null; + } + } + + if (valueSymbol) { + typeDeclSymbol = valueSymbol.type; + } else { + typeDeclSymbol = this.getNewErrorTypeSymbol(); + } + } else if (term.kind() === 124 /* ArrayType */) { + var arrayType = term; + var underlying = this.resolveTypeReference(arrayType.type, context); + var arraySymbol = underlying.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [underlying]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + } + + typeDeclSymbol = arraySymbol; + } else { + throw TypeScript.Errors.invalidOperation("unknown type"); + } + + if (!typeDeclSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Unable_to_resolve_type)); + return this.getNewErrorTypeSymbol(); + } + + if (typeDeclSymbol.isError()) { + return typeDeclSymbol; + } + + if (this.genericTypeIsUsedWithoutRequiredTypeArguments(typeDeclSymbol, term, context)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Generic_type_references_must_include_all_type_arguments)); + typeDeclSymbol = this.instantiateTypeToAny(typeDeclSymbol, context); + } + + return typeDeclSymbol; + }; + + PullTypeResolver.prototype.genericTypeIsUsedWithoutRequiredTypeArguments = function (typeSymbol, term, context) { + return typeSymbol.isNamedTypeSymbol() && typeSymbol.isGeneric() && !typeSymbol.isTypeParameter() && (typeSymbol.isResolved || typeSymbol.inResolution) && !typeSymbol.getIsSpecialized() && typeSymbol.getTypeParameters().length && typeSymbol.getTypeArguments() == null && this.isTypeRefWithoutTypeArgs(term); + }; + + PullTypeResolver.prototype.resolveMemberVariableDeclaration = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.getType(varDecl.variableDeclarator), varDecl.variableDeclarator.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolvePropertySignature = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.getType(varDecl), null, context); + }; + + PullTypeResolver.prototype.resolveVariableDeclarator = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.getType(varDecl), varDecl.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolveParameterList = function (list, context) { + return this.resolveSeparatedList(list.parameters, context); + }; + + PullTypeResolver.prototype.resolveParameter = function (parameter, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.getType(parameter), parameter.equalsValueClause, context); + }; + + PullTypeResolver.prototype.getEnumTypeSymbol = function (enumElement, context) { + var enumDeclaration = enumElement.parent.parent; + var decl = this.semanticInfoChain.getDeclForAST(enumDeclaration); + var symbol = decl.getSymbol(); + this.resolveDeclaredSymbol(symbol, context); + + return symbol; + }; + + PullTypeResolver.prototype.resolveEnumElement = function (enumElement, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckEnumElement = function (enumElement, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolveEqualsValueClause = function (clause, isContextuallyTyped, context) { + if (this.canTypeCheckAST(clause, context)) { + this.setTypeChecked(clause, context); + } + + return this.resolveAST(clause.value, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) { + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + + if (enclosingDecl && decl.kind == 2048 /* Parameter */) { + enclosingDecl.ensureSymbolIsBound(); + } + + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + if (declSymbol.isResolved) { + var declType = declSymbol.type; + var valDecl = decl.getValueDecl(); + + if (valDecl) { + var valSymbol = valDecl.getSymbol(); + + if (valSymbol && !valSymbol.isResolved) { + valSymbol.type = declType; + valSymbol.setResolved(); + } + } + } else { + if (declSymbol.inResolution) { + declSymbol.type = this.semanticInfoChain.anyTypeSymbol; + declSymbol.setResolved(); + return declSymbol; + } + + if (!declSymbol.type || !declSymbol.type.isError()) { + declSymbol.startResolving(); + + var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context); + + if (!hasTypeExpr) { + this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol); + } + + if (!(hasTypeExpr || init)) { + var defaultType = this.semanticInfoChain.anyTypeSymbol; + + if (declSymbol.isVarArg) { + defaultType = this.createInstantiatedType(this.cachedArrayInterfaceType(), [defaultType]); + } + + context.setTypeInContext(declSymbol, defaultType); + + if (declParameterSymbol) { + declParameterSymbol.type = defaultType; + } + } + declSymbol.setResolved(); + + if (declParameterSymbol) { + declParameterSymbol.setResolved(); + } + } + } + + if (this.canTypeCheckAST(varDeclOrParameter, context)) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDeclOrParameter, modifiers, name, typeExpr, init, context); + } + + return declSymbol; + }; + + PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclarationTypeExpr = function (varDeclOrParameter, name, typeExpr, context) { + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + if (varDeclOrParameter.kind() === 243 /* EnumElement */) { + var result = this.getEnumTypeSymbol(varDeclOrParameter, context); + declSymbol.type = result; + return result; + } + + if (!typeExpr) { + return null; + } + + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + var typeExprSymbol = this.resolveTypeReference(typeExpr, context); + + if (!typeExprSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()])); + declSymbol.type = this.getNewErrorTypeSymbol(); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol); + } + } else if (typeExprSymbol.isError()) { + context.setTypeInContext(declSymbol, typeExprSymbol); + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, typeExprSymbol); + } + } else { + if (typeExprSymbol == this.semanticInfoChain.anyTypeSymbol) { + decl.setFlag(16777216 /* IsAnnotatedWithAny */); + } + + if (typeExprSymbol.isContainer()) { + var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + + if (exportedTypeSymbol) { + typeExprSymbol = exportedTypeSymbol; + } else { + typeExprSymbol = typeExprSymbol.type; + + if (typeExprSymbol.isAlias()) { + typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + } + + if (typeExprSymbol && typeExprSymbol.isContainer() && !typeExprSymbol.isEnum()) { + var instanceSymbol = typeExprSymbol.getInstanceSymbol(); + + if (!instanceSymbol || !TypeScript.PullHelpers.symbolIsEnum(instanceSymbol)) { + typeExprSymbol = this.getNewErrorTypeSymbol(); + } else { + typeExprSymbol = instanceSymbol.type; + } + } + } + } else if (declSymbol.isVarArg && !(typeExprSymbol.isArrayNamedTypeReference() || typeExprSymbol == this.cachedArrayInterfaceType())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeExprSymbol = this.getNewErrorTypeSymbol(); + } + + context.setTypeInContext(declSymbol, typeExprSymbol); + + if (declParameterSymbol) { + declParameterSymbol.type = typeExprSymbol; + } + + if (typeExprSymbol.kind == 16777216 /* FunctionType */ && !typeExprSymbol.getFunctionSymbol()) { + typeExprSymbol.setFunctionSymbol(declSymbol); + } + } + + return typeExprSymbol; + }; + + PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr = function (varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol) { + if (!init) { + return null; + } + + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + if (typeExprSymbol) { + context.pushContextualType(typeExprSymbol, context.inProvisionalResolution(), null); + } + + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + var initExprSymbol = this.resolveAST(init, typeExprSymbol != null, context); + + if (typeExprSymbol) { + context.popContextualType(); + } + + if (!initExprSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()])); + + if (!hasTypeExpr) { + context.setTypeInContext(declSymbol, this.getNewErrorTypeSymbol()); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol); + } + } + } else { + var initTypeSymbol = initExprSymbol.type; + var widenedInitTypeSymbol = this.widenType(initTypeSymbol, init.value, context); + + if (!hasTypeExpr) { + context.setTypeInContext(declSymbol, widenedInitTypeSymbol); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, widenedInitTypeSymbol); + } + + if (this.compilationSettings.noImplicitAny()) { + if ((widenedInitTypeSymbol != initTypeSymbol) && (widenedInitTypeSymbol == this.semanticInfoChain.anyTypeSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } + } + } + } + + return widenedInitTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckPropertySignature = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.getType(varDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckMemberVariableDeclaration = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.getType(varDecl), varDecl.variableDeclarator.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckVariableDeclarator = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.getType(varDecl), varDecl.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckParameter = function (parameter, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.getType(parameter), parameter.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) { + var _this = this; + this.setTypeChecked(varDeclOrParameter, context); + + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + + var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context); + + var initTypeSymbol = this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol); + + if (hasTypeExpr || init) { + if (typeExprSymbol && typeExprSymbol.isAlias()) { + typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + } + + if (typeExprSymbol && typeExprSymbol.kind === 32 /* DynamicModule */) { + var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + + if (exportedTypeSymbol) { + typeExprSymbol = exportedTypeSymbol; + } else { + var instanceTypeSymbol = typeExprSymbol.getInstanceType(); + + if (!instanceTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [typeExprSymbol.toString()])); + typeExprSymbol = null; + } else { + typeExprSymbol = instanceTypeSymbol; + } + } + } + + initTypeSymbol = this.getInstanceTypeForAssignment(varDeclOrParameter, initTypeSymbol, context); + + if (initTypeSymbol && typeExprSymbol) { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, typeExprSymbol, varDeclOrParameter, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(varDeclOrParameter); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol)])); + } + } + } + } else if (varDeclOrParameter.kind() !== 243 /* EnumElement */ && this.compilationSettings.noImplicitAny() && !this.isForInVariableDeclarator(varDeclOrParameter)) { + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + if ((wrapperDecl.kind === 16384 /* Function */ || wrapperDecl.kind === 32768 /* ConstructorMethod */ || wrapperDecl.kind === 2097152 /* ConstructSignature */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } else if (wrapperDecl.kind === 65536 /* Method */) { + var parentDecl = wrapperDecl.getParentDecl(); + + if (!TypeScript.hasFlag(parentDecl.flags, 8 /* Ambient */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } else if (TypeScript.hasFlag(parentDecl.flags, 8 /* Ambient */) && !TypeScript.hasFlag(wrapperDecl.flags, 2 /* Private */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } + } else if (wrapperDecl.kind === 8388608 /* ObjectType */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Member_0_of_object_type_implicitly_has_an_any_type, [name.text()])); + } else if (wrapperDecl.kind !== 268435456 /* CatchBlock */) { + if (!TypeScript.hasFlag(wrapperDecl.flags, 8 /* Ambient */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } else if (TypeScript.hasFlag(wrapperDecl.flags, 8 /* Ambient */) && !TypeScript.hasModifier(modifiers, 2 /* Private */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } + } + } + + if (init && varDeclOrParameter.kind() === 242 /* Parameter */) { + var containerSignature = enclosingDecl.getSignatureSymbol(); + if (containerSignature && !containerSignature.isDefinition()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Default_arguments_are_not_allowed_in_an_overload_parameter)); + } + } + if (declSymbol.kind != 2048 /* Parameter */ && (declSymbol.kind != 4096 /* Property */ || declSymbol.getContainer().isNamedTypeSymbol())) { + this.checkSymbolPrivacy(declSymbol, declSymbol.type, function (symbol) { + return _this.variablePrivacyErrorReporter(varDeclOrParameter, declSymbol, symbol, context); + }); + } + + if ((declSymbol.kind != 4096 /* Property */ && declSymbol.kind != 67108864 /* EnumMember */) || declSymbol.anyDeclHasFlag(8388608 /* PropertyParameter */)) { + this.checkNameForCompilerGeneratedDeclarationCollision(varDeclOrParameter, true, name, context); + } + }; + + PullTypeResolver.prototype.isForInVariableDeclarator = function (ast) { + return ast.kind() === 225 /* VariableDeclarator */ && ast.parent && ast.parent.parent && ast.parent.parent.parent && ast.parent.kind() === 2 /* SeparatedList */ && ast.parent.parent.kind() === 224 /* VariableDeclaration */ && ast.parent.parent.parent.kind() === 155 /* ForInStatement */ && ast.parent.parent.parent.variableDeclaration === ast.parent.parent; + }; + + PullTypeResolver.prototype.checkSuperCaptureVariableCollides = function (superAST, isDeclaration, context) { + var enclosingDecl = this.getEnclosingDeclForAST(superAST); + var declPath = enclosingDecl.getParentPath(); + + var classSymbol = this.getContextualClassSymbolForEnclosingDecl(superAST, enclosingDecl); + + if (classSymbol && !classSymbol.anyDeclHasFlag(8 /* Ambient */)) { + if (superAST.kind() == 242 /* Parameter */) { + var enclosingAST = this.getASTForDecl(enclosingDecl); + if (enclosingAST.kind() !== 218 /* ParenthesizedArrowFunctionExpression */ && enclosingAST.kind() !== 219 /* SimpleArrowFunctionExpression */) { + var block = enclosingDecl.kind == 65536 /* Method */ ? enclosingAST.block : enclosingAST.block; + if (!block) { + return; + } + } + } + + this.resolveDeclaredSymbol(classSymbol, context); + + var parents = classSymbol.getExtendedTypes(); + if (parents.length) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(superAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference : TypeScript.DiagnosticCode.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference)); + } + } + }; + + PullTypeResolver.prototype.checkThisCaptureVariableCollides = function (_thisAST, isDeclaration, context) { + if (isDeclaration) { + var decl = this.semanticInfoChain.getDeclForAST(_thisAST); + if (TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) { + return; + } + } + + var enclosingDecl = this.getEnclosingDeclForAST(_thisAST); + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(_thisAST); + if (TypeScript.isAnyNameOfModule(enclosingModule, _thisAST)) { + enclosingDecl = this.getEnclosingDeclForAST(enclosingModule); + } + + var declPath = enclosingDecl.getParentPath(); + + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) { + continue; + } + + if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) { + if (TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(_thisAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference)); + } + break; + } + } + }; + + PullTypeResolver.prototype.postTypeCheckVariableDeclaratorOrParameter = function (varDeclOrParameter, context) { + this.checkThisCaptureVariableCollides(varDeclOrParameter, true, context); + }; + + PullTypeResolver.prototype.resolveTypeParameterDeclaration = function (typeParameterAST, context) { + var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST); + var typeParameterSymbol = typeParameterDecl.getSymbol(); + + if (typeParameterSymbol.isResolved || typeParameterSymbol.inResolution) { + if (typeParameterSymbol.isResolved && this.canTypeCheckAST(typeParameterAST, context)) { + this.typeCheckTypeParameterDeclaration(typeParameterAST, context); + } + return typeParameterSymbol; + } + + typeParameterSymbol.startResolving(); + + if (typeParameterAST.constraint) { + var constraintTypeSymbol = this.resolveTypeReference(typeParameterAST.constraint.type, context); + + if (constraintTypeSymbol) { + typeParameterSymbol.setConstraint(constraintTypeSymbol); + } + } + + typeParameterSymbol.setResolved(); + + if (this.canTypeCheckAST(typeParameterAST, context)) { + this.setTypeChecked(typeParameterAST, context); + } + + return typeParameterSymbol; + }; + + PullTypeResolver.prototype.typeCheckTypeParameterDeclaration = function (typeParameterAST, context) { + this.setTypeChecked(typeParameterAST, context); + + this.resolveAST(typeParameterAST.constraint, false, context); + }; + + PullTypeResolver.prototype.resolveConstraint = function (constraint, context) { + if (this.canTypeCheckAST(constraint, context)) { + this.setTypeChecked(constraint, context); + } + + return this.resolveTypeReference(constraint.type, context); + }; + + PullTypeResolver.prototype.resolveFunctionBodyReturnTypes = function (funcDeclAST, block, bodyExpression, signature, useContextualType, enclosingDecl, context) { + var _this = this; + var returnStatementsExpressions = []; + + var enclosingDeclStack = [enclosingDecl]; + + var preFindReturnExpressionTypes = function (ast, walker) { + var go = true; + + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + go = false; + break; + + case 150 /* ReturnStatement */: + var returnStatement = ast; + enclosingDecl.setFlag(4194304 /* HasReturnStatement */); + returnStatementsExpressions.push({ expression: returnStatement.expression, enclosingDecl: enclosingDeclStack[enclosingDeclStack.length - 1] }); + go = false; + break; + + case 236 /* CatchClause */: + case 163 /* WithStatement */: + enclosingDeclStack[enclosingDeclStack.length] = _this.semanticInfoChain.getDeclForAST(ast); + break; + + default: + break; + } + + walker.options.goChildren = go; + + return ast; + }; + + var postFindReturnExpressionEnclosingDecls = function (ast, walker) { + switch (ast.kind()) { + case 236 /* CatchClause */: + case 163 /* WithStatement */: + enclosingDeclStack.length--; + break; + default: + break; + } + + walker.options.goChildren = true; + + return ast; + }; + + if (block) { + TypeScript.getAstWalkerFactory().walk(block, preFindReturnExpressionTypes, postFindReturnExpressionEnclosingDecls); + } else { + returnStatementsExpressions.push({ expression: bodyExpression, enclosingDecl: enclosingDecl }); + enclosingDecl.setFlag(4194304 /* HasReturnStatement */); + } + + if (!returnStatementsExpressions.length) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + } else { + var returnExpressionSymbols = []; + var returnExpressions = []; + + for (var i = 0; i < returnStatementsExpressions.length; i++) { + var returnExpression = returnStatementsExpressions[i].expression; + if (returnExpression) { + var returnType = this.resolveAST(returnExpression, useContextualType, context).type; + + if (returnType.isError()) { + signature.returnType = returnType; + return; + } else { + if (returnExpression.parent.kind() === 150 /* ReturnStatement */) { + this.setSymbolForAST(returnExpression.parent, returnType, context); + } + } + + returnExpressionSymbols.push(returnType); + returnExpressions.push(returnExpression); + } + } + + if (!returnExpressionSymbols.length) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + } else { + var collection = { + getLength: function () { + return returnExpressionSymbols.length; + }, + getTypeAtIndex: function (index) { + return returnExpressionSymbols[index].type; + } + }; + + var bestCommonReturnType = this.findBestCommonType(collection, context, new TypeComparisonInfo()); + var returnType = bestCommonReturnType; + var returnExpression = returnExpressions[returnExpressionSymbols.indexOf(returnType)]; + + if (useContextualType && returnType == this.semanticInfoChain.anyTypeSymbol) { + var contextualType = context.getContextualType(); + + if (contextualType) { + returnType = contextualType; + } + } + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var functionSymbol = functionDecl.getSymbol(); + + if (returnType) { + var previousReturnType = returnType; + var newReturnType = this.widenType(returnType, returnExpression, context); + signature.returnType = newReturnType; + + if (!TypeScript.ArrayUtilities.contains(returnExpressionSymbols, bestCommonReturnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions)); + } + + if (this.compilationSettings.noImplicitAny()) { + if (previousReturnType !== newReturnType && newReturnType === this.semanticInfoChain.anyTypeSymbol) { + var functionName = enclosingDecl.name; + if (functionName == "") { + functionName = enclosingDecl.getFunctionExpressionName(); + } + + if (functionName != "") { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } + } + + if (!functionSymbol.type && functionSymbol.isAccessor()) { + functionSymbol.type = signature.returnType; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckConstructorDeclaration = function (funcDeclAST, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + if (funcDeclAST.parameterList) { + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveAST(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), false, context); + } + } + + this.resolveAST(funcDeclAST.block, false, context); + + if (funcDecl.getSignatureSymbol() && funcDecl.getSignatureSymbol().isDefinition() && this.enclosingClassIsDerived(funcDecl.getParentDecl())) { + if (!this.constructorHasSuperCall(funcDeclAST)) { + context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), 11, TypeScript.DiagnosticCode.Constructors_for_derived_classes_must_contain_a_super_call)); + } else if (this.superCallMustBeFirstStatementInConstructor(funcDecl)) { + var firstStatement = this.getFirstStatementOfBlockOrNull(funcDeclAST.block); + if (!firstStatement || !this.isSuperInvocationExpressionStatement(firstStatement)) { + context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), 11, TypeScript.DiagnosticCode.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties)); + } + } + } + + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context); + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.constructorHasSuperCall = function (constructorDecl) { + var _this = this; + if (constructorDecl.block) { + var foundSuperCall = false; + var pre = function (ast, walker) { + if (_this.isSuperInvocationExpression(ast)) { + foundSuperCall = true; + walker.options.stopWalking = true; + } + }; + + TypeScript.getAstWalkerFactory().walk(constructorDecl.block, pre); + return foundSuperCall; + } + + return false; + }; + + PullTypeResolver.prototype.typeCheckFunctionExpression = function (funcDecl, context) { + this.typeCheckAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.getType(funcDecl), funcDecl.block, null, context); + }; + + PullTypeResolver.prototype.typeCheckCallSignature = function (funcDecl, context) { + this.typeCheckFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckConstructSignature = function (funcDecl, context) { + this.typeCheckFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameters, returnTypeAnnotation, block, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + this.resolveAST(parameters, false, context); + + this.resolveAST(block, false, context); + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, isStatic, typeParameters, TypeScript.Parameters.fromParameterList(parameters), returnTypeAnnotation, block, context); + + var signature = funcDecl.getSignatureSymbol(); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + if (funcDeclAST.kind() !== 143 /* ConstructSignature */ && block && returnTypeAnnotation != null && !hasReturn) { + var isVoidOrAny = this.isAnyOrEquivalent(signature.returnType) || signature.returnType === this.semanticInfoChain.voidTypeSymbol; + + if (!isVoidOrAny && !(block.statements.childCount() > 0 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + var funcName = funcDecl.getDisplayName(); + funcName = funcName ? funcName : "expression"; + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_0_declared_a_non_void_return_type_but_has_no_return_expression, [funcName])); + } + } + + if (funcDecl.kind === 16384 /* Function */) { + this.checkNameForCompilerGeneratedDeclarationCollision(funcDeclAST, true, name, context); + } + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.typeCheckIndexSignature = function (funcDeclAST, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + this.resolveAST(funcDeclAST.parameter, false, context); + + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.Parameters.fromParameter(funcDeclAST.parameter), TypeScript.getType(funcDeclAST), null, context); + + var signature = funcDecl.getSignatureSymbol(); + + this.typeCheckCallBacks.push(function (context) { + var parentSymbol = funcDecl.getSignatureSymbol().getContainer(); + var allIndexSignatures = _this.getBothKindsOfIndexSignatures(parentSymbol, context); + var stringIndexSignature = allIndexSignatures.stringSignature; + var numberIndexSignature = allIndexSignatures.numericSignature; + var isNumericIndexer = numberIndexSignature === signature; + + if (numberIndexSignature && stringIndexSignature && (isNumericIndexer || stringIndexSignature.getDeclarations()[0].getParentDecl() !== numberIndexSignature.getDeclarations()[0].getParentDecl())) { + var comparisonInfo = new TypeComparisonInfo(); + + if (!_this.sourceIsSubtypeOfTarget(numberIndexSignature.returnType, stringIndexSignature.returnType, funcDeclAST, context, comparisonInfo)) { + var enclosingSymbol = _this.getEnclosingSymbolForAST(funcDeclAST); + if (comparisonInfo.message) { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1_NL_2, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol)])); + } + } + } + + var allMembers = parentSymbol.type.getAllMembers(536869887 /* All */, 0 /* all */); + for (var i = 0; i < allMembers.length; i++) { + var member = allMembers[i]; + var name = member.name; + if (name || (member.kind === 4096 /* Property */ && name === "")) { + if (!allMembers[i].isResolved) { + _this.resolveDeclaredSymbol(allMembers[i], context); + } + + if (parentSymbol !== allMembers[i].getContainer()) { + var isMemberNumeric = TypeScript.PullHelpers.isNameNumeric(name); + var indexerKindMatchesMemberNameKind = isNumericIndexer === isMemberNumeric; + var onlyStringIndexerIsPresent = !numberIndexSignature; + + if (indexerKindMatchesMemberNameKind || onlyStringIndexerIsPresent) { + var comparisonInfo = new TypeComparisonInfo(); + if (!_this.sourceIsSubtypeOfTarget(allMembers[i].type, signature.returnType, funcDeclAST, context, comparisonInfo, false)) { + _this.reportErrorThatMemberIsNotSubtypeOfIndexer(allMembers[i], signature, funcDeclAST, context, comparisonInfo); + } + } + } + } + } + }); + }; + + PullTypeResolver.prototype.postTypeCheckFunctionDeclaration = function (funcDeclAST, context) { + this.checkThisCaptureVariableCollides(funcDeclAST, true, context); + }; + + PullTypeResolver.prototype.resolveReturnTypeAnnotationOfFunctionDeclaration = function (funcDeclAST, returnTypeAnnotation, context) { + var returnTypeSymbol = null; + + if (returnTypeAnnotation) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + } else { + var isConstructor = funcDeclAST.kind() === 137 /* ConstructorDeclaration */ || funcDeclAST.kind() === 143 /* ConstructSignature */; + if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void)); + } + } + } + + return returnTypeSymbol; + }; + + PullTypeResolver.prototype.resolveMemberFunctionDeclaration = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + }; + + PullTypeResolver.prototype.resolveCallSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveConstructSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveMethodSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveAnyFunctionDeclaration = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + }; + + PullTypeResolver.prototype.resolveFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), TypeScript.getType(funcDecl), funcDecl.block, null, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveSimpleArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, null, TypeScript.Parameters.fromIdentifier(funcDecl.identifier), null, funcDecl.block, funcDecl.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveParenthesizedArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), TypeScript.getType(funcDecl), funcDecl.block, funcDecl.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.getEnclosingClassDeclaration = function (ast) { + while (ast) { + if (ast.kind() === 131 /* ClassDeclaration */) { + return ast; + } + + ast = ast.parent; + } + + return null; + }; + + PullTypeResolver.prototype.resolveConstructorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckConstructorDeclaration(funcDeclAST, context); + } + return funcSymbol; + } + + if (!signature.inResolution) { + var classAST = this.getEnclosingClassDeclaration(funcDeclAST); + + if (classAST) { + var classDecl = this.semanticInfoChain.getDeclForAST(classAST); + var classSymbol = classDecl.getSymbol(); + + if (!classSymbol.isResolved && !classSymbol.inResolution) { + this.resolveDeclaredSymbol(classSymbol, context); + } + } + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (funcDeclAST.parameterList) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context); + } + + context.inTypeCheck = prevInTypeCheck; + } + + if (signature.isGeneric()) { + if (funcSymbol) { + funcSymbol.type.setHasGenericSignature(); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckConstructorDeclaration(funcDeclAST, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveIndexMemberDeclaration = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + } + + return this.resolveIndexSignature(ast.indexSignature, context); + }; + + PullTypeResolver.prototype.resolveIndexSignature = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckIndexSignature(funcDeclAST, context); + } + return funcSymbol; + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + if (funcDeclAST.typeAnnotation) { + var returnTypeSymbol = this.resolveTypeReference(TypeScript.getType(funcDeclAST), context); + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(TypeScript.getType(funcDeclAST), TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + } + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (funcDeclAST.parameter) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + this.resolveParameter(funcDeclAST.parameter, context); + context.inTypeCheck = prevInTypeCheck; + } + + if (funcDeclAST.typeAnnotation) { + returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + var parentDeclFlags = 0 /* None */; + if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) { + var parentDecl = funcDecl.getParentDecl(); + parentDeclFlags = parentDecl.flags; + } + + if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) { + var funcDeclASTName = name; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, ["Indexer"])); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckIndexSignature(funcDeclAST, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + var isConstructor = funcDeclAST.kind() === 143 /* ConstructSignature */; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context); + } + return funcSymbol; + } + + if (isConstructor && !signature.inResolution) { + var classAST = this.getEnclosingClassDeclaration(funcDeclAST); + + if (classAST) { + var classDecl = this.semanticInfoChain.getDeclForAST(classAST); + var classSymbol = classDecl.getSymbol(); + + if (!classSymbol.isResolved && !classSymbol.inResolution) { + this.resolveDeclaredSymbol(classSymbol, context); + } + } + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + if (returnTypeAnnotation) { + var returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + + if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void)); + } + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + } + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + if (parameterList) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context); + } + + context.inTypeCheck = prevInTypeCheck; + } + + if (returnTypeAnnotation) { + returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else if (funcDecl.kind !== 2097152 /* ConstructSignature */) { + if (TypeScript.hasFlag(funcDecl.flags, 2048 /* Signature */)) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + var parentDeclFlags = 0 /* None */; + if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) { + var parentDecl = funcDecl.getParentDecl(); + parentDeclFlags = parentDecl.flags; + } + + if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) { + var funcDeclASTName = name; + if (funcDeclASTName) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [funcDeclASTName.text()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } else { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context); + } + } else if (funcDecl.kind === 2097152 /* ConstructSignature */) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (this.compilationSettings.noImplicitAny()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveGetterReturnTypeAnnotation = function (getterFunctionDeclarationAst, enclosingDecl, context) { + if (getterFunctionDeclarationAst && getterFunctionDeclarationAst.typeAnnotation) { + return this.resolveTypeReference(TypeScript.getType(getterFunctionDeclarationAst), context); + } + + return null; + }; + + PullTypeResolver.prototype.resolveSetterArgumentTypeAnnotation = function (setterFunctionDeclarationAst, enclosingDecl, context) { + if (setterFunctionDeclarationAst && setterFunctionDeclarationAst.parameterList && setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorCount() > 0) { + var parameter = setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorAt(0); + return this.resolveTypeReference(TypeScript.getType(parameter), context); + } + + return null; + }; + + PullTypeResolver.prototype.resolveAccessorDeclaration = function (funcDeclAst, context) { + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst); + var accessorSymbol = functionDeclaration.getSymbol(); + + if (accessorSymbol.inResolution) { + accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol; + accessorSymbol.setResolved(); + + return accessorSymbol; + } + + if (accessorSymbol.isResolved) { + if (!accessorSymbol.type) { + accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol; + } + } else { + var getterSymbol = accessorSymbol.getGetter(); + var getterFunctionDeclarationAst = getterSymbol ? getterSymbol.getDeclarations()[0].ast() : null; + var hasGetter = getterSymbol !== null; + + var setterSymbol = accessorSymbol.getSetter(); + var setterFunctionDeclarationAst = setterSymbol ? setterSymbol.getDeclarations()[0].ast() : null; + var hasSetter = setterSymbol !== null; + + var getterAnnotatedType = this.resolveGetterReturnTypeAnnotation(getterFunctionDeclarationAst, functionDeclaration, context); + var getterHasTypeAnnotation = getterAnnotatedType !== null; + + var setterAnnotatedType = this.resolveSetterArgumentTypeAnnotation(setterFunctionDeclarationAst, functionDeclaration, context); + var setterHasTypeAnnotation = setterAnnotatedType !== null; + + accessorSymbol.startResolving(); + + if (hasGetter) { + getterSymbol = this.resolveGetAccessorDeclaration(getterFunctionDeclarationAst, getterFunctionDeclarationAst.parameterList, TypeScript.getType(getterFunctionDeclarationAst), getterFunctionDeclarationAst.block, setterAnnotatedType, context); + } + + if (hasSetter) { + setterSymbol = this.resolveSetAccessorDeclaration(setterFunctionDeclarationAst, setterFunctionDeclarationAst.parameterList, context); + } + + if (hasGetter && hasSetter) { + var setterSig = setterSymbol.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + var setterHasParameters = setterParameters.length > 0; + var getterSig = getterSymbol.type.getCallSignatures()[0]; + + var setterSuppliedTypeSymbol = setterHasParameters ? setterParameters[0].type : null; + var getterSuppliedTypeSymbol = getterSig.returnType; + + if (setterHasTypeAnnotation && !getterHasTypeAnnotation) { + getterSuppliedTypeSymbol = setterSuppliedTypeSymbol; + getterSig.returnType = setterSuppliedTypeSymbol; + } else if ((getterHasTypeAnnotation && !setterHasTypeAnnotation) || (!getterHasTypeAnnotation && !setterHasTypeAnnotation)) { + setterSuppliedTypeSymbol = getterSuppliedTypeSymbol; + + if (setterHasParameters) { + setterParameters[0].type = getterSuppliedTypeSymbol; + } + } + + if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol)) { + accessorSymbol.type = this.getNewErrorTypeSymbol(); + } else { + accessorSymbol.type = getterSuppliedTypeSymbol; + } + } else if (hasSetter) { + var setterSig = setterSymbol.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + var setterHasParameters = setterParameters.length > 0; + + accessorSymbol.type = setterHasParameters ? setterParameters[0].type : this.semanticInfoChain.anyTypeSymbol; + } else { + var getterSig = getterSymbol.type.getCallSignatures()[0]; + accessorSymbol.type = getterSig.returnType; + } + + accessorSymbol.setResolved(); + } + + if (this.canTypeCheckAST(funcDeclAst, context)) { + this.typeCheckAccessorDeclaration(funcDeclAst, context); + } + + return accessorSymbol; + }; + + PullTypeResolver.prototype.typeCheckAccessorDeclaration = function (funcDeclAst, context) { + this.setTypeChecked(funcDeclAst, context); + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst); + var accessorSymbol = functionDeclaration.getSymbol(); + var getterSymbol = accessorSymbol.getGetter(); + var setterSymbol = accessorSymbol.getSetter(); + + var isGetter = funcDeclAst.kind() == 139 /* GetAccessor */; + if (isGetter) { + var getterFunctionDeclarationAst = funcDeclAst; + context.pushContextualType(getterSymbol.type, context.inProvisionalResolution(), null); + this.typeCheckGetAccessorDeclaration(getterFunctionDeclarationAst, context); + context.popContextualType(); + } else { + var setterFunctionDeclarationAst = funcDeclAst; + this.typeCheckSetAccessorDeclaration(setterFunctionDeclarationAst, context); + } + }; + + PullTypeResolver.prototype.resolveGetAccessorDeclaration = function (funcDeclAST, parameters, returnTypeAnnotation, block, setterAnnotatedType, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + var getterSymbol = accessorSymbol.getGetter(); + var getterTypeSymbol = getterSymbol.type; + + var signature = getterTypeSymbol.getCallSignatures()[0]; + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + return getterSymbol; + } + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + signature.setResolved(); + + return getterSymbol; + } + + signature.startResolving(); + + if (returnTypeAnnotation) { + var returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + if (!setterAnnotatedType) { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context); + } else { + signature.returnType = setterAnnotatedType; + } + } + + if (!hadError) { + signature.setResolved(); + } + } + + return getterSymbol; + }; + + PullTypeResolver.prototype.checkIfGetterAndSetterTypeMatch = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + var getter = accessorSymbol.getGetter(); + var setter = accessorSymbol.getSetter(); + + if (getter && setter) { + var getterAST = getter.getDeclarations()[0].ast(); + var setterAST = setter.getDeclarations()[0].ast(); + + if (getterAST.typeAnnotation && PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterAST)) { + var setterSig = setter.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + + var getter = accessorSymbol.getGetter(); + var getterSig = getter.type.getCallSignatures()[0]; + + var setterSuppliedTypeSymbol = setterParameters[0].type; + var getterSuppliedTypeSymbol = getterSig.returnType; + + if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.get_and_set_accessor_must_have_the_same_type)); + } + } + } + }; + + PullTypeResolver.prototype.typeCheckGetAccessorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + + this.resolveAST(funcDeclAST.block, false, context); + + this.validateVariableDeclarationGroups(funcDecl, context); + + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + var funcNameAST = funcDeclAST.propertyName; + + if (!hasReturn && !(funcDeclAST.block.statements.childCount() > 0 && funcDeclAST.block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getters_must_return_a_value)); + } + + var setter = accessorSymbol.getSetter(); + if (setter) { + var setterDecl = setter.getDeclarations()[0]; + var setterIsPrivate = TypeScript.hasFlag(setterDecl.flags, 2 /* Private */); + var getterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */); + + if (getterIsPrivate != setterIsPrivate) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility)); + } + + this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context); + } + + this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), TypeScript.getType(funcDeclAST), funcDeclAST.block, context); + }; + + PullTypeResolver.hasSetAccessorParameterTypeAnnotation = function (setAccessor) { + return setAccessor.parameterList && setAccessor.parameterList.parameters.nonSeparatorCount() > 0 && setAccessor.parameterList.parameters.nonSeparatorAt(0).typeAnnotation != null; + }; + + PullTypeResolver.prototype.resolveSetAccessorDeclaration = function (funcDeclAST, parameterList, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + var setterSymbol = accessorSymbol.getSetter(); + var setterTypeSymbol = setterSymbol.type; + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + return setterSymbol; + } + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + signature.setResolved(); + return setterSymbol; + } + + signature.startResolving(); + + if (parameterList) { + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context); + } + } + + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + + if (signature.hasAGenericParameter) { + setterTypeSymbol.setHasGenericSignature(); + } + + if (!hadError) { + signature.setResolved(); + } + } + + return setterSymbol; + }; + + PullTypeResolver.prototype.typeCheckSetAccessorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + if (funcDeclAST.parameterList) { + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context); + } + } + + this.resolveAST(funcDeclAST.block, false, context); + + this.validateVariableDeclarationGroups(funcDecl, context); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + var getter = accessorSymbol.getGetter(); + + var funcNameAST = funcDeclAST.propertyName; + + if (getter) { + var getterDecl = getter.getDeclarations()[0]; + var getterIsPrivate = TypeScript.hasFlag(getterDecl.flags, 2 /* Private */); + var setterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */); + + if (getterIsPrivate != setterIsPrivate) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility)); + } + + this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context); + } else { + if (this.compilationSettings.noImplicitAny()) { + var setterFunctionDeclarationAst = funcDeclAST; + if (!PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterFunctionDeclarationAst) && accessorSymbol.type == this.semanticInfoChain.anyTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type, [setterFunctionDeclarationAst.propertyName.text()])); + } + } + } + + this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context); + }; + + PullTypeResolver.prototype.resolveList = function (list, context) { + if (this.canTypeCheckAST(list, context)) { + this.setTypeChecked(list, context); + + for (var i = 0, n = list.childCount(); i < n; i++) { + this.resolveAST(list.childAt(i), false, context); + } + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveSeparatedList = function (list, context) { + if (this.canTypeCheckAST(list, context)) { + this.setTypeChecked(list, context); + + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + this.resolveAST(list.nonSeparatorAt(i), false, context); + } + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVoidExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.undefinedTypeSymbol; + }; + + PullTypeResolver.prototype.resolveLogicalOperation = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckLogicalOperation(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckLogicalOperation = function (binex, context) { + this.setTypeChecked(binex, context); + + var leftType = this.resolveAST(binex.left, false, context).type; + var rightType = this.resolveAST(binex.right, false, context).type; + + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsAssignableToTarget(leftType, rightType, binex, context, comparisonInfo) && !this.sourceIsAssignableToTarget(rightType, leftType, binex, context, comparisonInfo)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(binex); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binex, TypeScript.DiagnosticCode.Operator_0_cannot_be_applied_to_types_1_and_2, [ + TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(binex.kind())), + leftType.toString(enclosingSymbol), rightType.toString(enclosingSymbol)])); + } + }; + + PullTypeResolver.prototype.resolveLogicalNotExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.operand, false, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.resolveUnaryArithmeticOperation = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckUnaryArithmeticOperation(ast, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.resolvePostfixUnaryExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckPostfixUnaryExpression(ast, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.isAnyOrNumberOrEnum = function (type) { + return this.isAnyOrEquivalent(type) || type === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(type); + }; + + PullTypeResolver.prototype.typeCheckUnaryArithmeticOperation = function (unaryExpression, context) { + this.setTypeChecked(unaryExpression, context); + + var nodeType = unaryExpression.kind(); + var expression = this.resolveAST(unaryExpression.operand, false, context); + + if (nodeType == 164 /* PlusExpression */ || nodeType == 165 /* NegateExpression */ || nodeType == 166 /* BitwiseNotExpression */) { + return; + } + + TypeScript.Debug.assert(nodeType === 168 /* PreIncrementExpression */ || nodeType === 169 /* PreDecrementExpression */); + + var operandType = expression.type; + if (!this.isAnyOrNumberOrEnum(operandType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!this.isReference(unaryExpression.operand, expression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer)); + } + }; + + PullTypeResolver.prototype.typeCheckPostfixUnaryExpression = function (unaryExpression, context) { + this.setTypeChecked(unaryExpression, context); + + var nodeType = unaryExpression.kind(); + var expression = this.resolveAST(unaryExpression.operand, false, context); + + TypeScript.Debug.assert(nodeType === 210 /* PostIncrementExpression */ || nodeType === 211 /* PostDecrementExpression */); + + var operandType = expression.type; + if (!this.isAnyOrNumberOrEnum(operandType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!this.isReference(unaryExpression.operand, expression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer)); + } + }; + + PullTypeResolver.prototype.resolveBinaryArithmeticExpression = function (binaryExpression, context) { + if (this.canTypeCheckAST(binaryExpression, context)) { + this.typeCheckBinaryArithmeticExpression(binaryExpression, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckBinaryArithmeticExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsSymbol = this.resolveAST(binaryExpression.left, false, context); + + var lhsType = lhsSymbol.type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) { + lhsType = rhsType; + } + + if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) { + rhsType = lhsType; + } + + var lhsIsFit = this.isAnyOrNumberOrEnum(lhsType); + var rhsIsFit = this.isAnyOrNumberOrEnum(rhsType); + + if (!rhsIsFit) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!lhsIsFit) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type)); + } + + if (lhsIsFit && rhsIsFit) { + switch (binaryExpression.kind()) { + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + if (!this.isReference(binaryExpression.left, lhsSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } + + this.checkAssignability(binaryExpression.left, rhsType, lhsType, context); + } + } + }; + + PullTypeResolver.prototype.resolveTypeOfExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.stringTypeSymbol; + }; + + PullTypeResolver.prototype.resolveThrowStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveDeleteExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.resolveInstanceOfExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckInstanceOfExpression(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckInstanceOfExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsType = this.resolveAST(binaryExpression.left, false, context).type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + var enclosingSymbol = this.getEnclosingSymbolForAST(binaryExpression); + var isValidLHS = this.isAnyOrEquivalent(lhsType) || lhsType.isObject() || lhsType.isTypeParameter(); + var isValidRHS = this.isAnyOrEquivalent(rhsType) || this.typeIsSubtypeOfFunction(rhsType, binaryExpression, context); + + if (!isValidLHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_a_subtype_of_the_Function_interface_type)); + } + }; + + PullTypeResolver.prototype.resolveCommaExpression = function (commaExpression, context) { + if (this.canTypeCheckAST(commaExpression, context)) { + this.setTypeChecked(commaExpression, context); + + this.resolveAST(commaExpression.left, false, context); + } + + var rhsType = this.resolveAST(commaExpression.right, false, context).type; + + return this.resolveAST(commaExpression.right, false, context).type; + }; + + PullTypeResolver.prototype.resolveInExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckInExpression(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckInExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsType = this.resolveAST(binaryExpression.left, false, context).type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + var isValidLHS = this.isAnyOrEquivalent(lhsType.type) || lhsType.type === this.semanticInfoChain.stringTypeSymbol || lhsType.type === this.semanticInfoChain.numberTypeSymbol; + + var isValidRHS = this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter(); + + if (!isValidLHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + }; + + PullTypeResolver.prototype.resolveForStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.variableDeclaration, false, context); + this.resolveAST(ast.initializer, false, context); + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.incrementor, false, context); + this.resolveAST(ast.statement, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveForInStatement = function (forInStatement, context) { + if (this.canTypeCheckAST(forInStatement, context)) { + this.typeCheckForInStatement(forInStatement, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckForInStatement = function (forInStatement, context) { + this.setTypeChecked(forInStatement, context); + + var rhsType = this.resolveAST(forInStatement.expression, false, context).type; + var lval = forInStatement.variableDeclaration || forInStatement.left; + + var varSym = this.resolveAST(lval, false, context); + + if (forInStatement.variableDeclaration) { + var declaration = forInStatement.variableDeclaration; + var varDecl = declaration.declarators.nonSeparatorAt(0); + + if (varDecl.typeAnnotation) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lval, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation)); + } + + var varSym = this.getSymbolForAST(varDecl, context); + } + + var isStringOrNumber = varSym.type === this.semanticInfoChain.stringTypeSymbol || this.isAnyOrEquivalent(varSym.type); + + var isValidRHS = rhsType && (this.isAnyOrEquivalent(rhsType) || !rhsType.isPrimitive()); + + if (!isStringOrNumber) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lval, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.expression, TypeScript.DiagnosticCode.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + + this.resolveAST(forInStatement.statement, false, context); + }; + + PullTypeResolver.prototype.resolveWhileStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckWhileStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckWhileStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveDoStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckDoStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckDoStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveIfStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckIfStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckIfStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + this.resolveAST(ast.elseClause, false, context); + }; + + PullTypeResolver.prototype.resolveElseClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckElseClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckElseClause = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveBlock = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.statements, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVariableStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.declaration, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVariableDeclarationList = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.declarators, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveWithStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckWithStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckWithStatement = function (ast, context) { + this.setTypeChecked(ast, context); + var withStatement = ast; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(withStatement.condition, TypeScript.DiagnosticCode.All_symbols_within_a_with_block_will_be_resolved_to_any)); + }; + + PullTypeResolver.prototype.resolveTryStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckTryStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckTryStatement = function (ast, context) { + this.setTypeChecked(ast, context); + var tryStatement = ast; + + this.resolveAST(tryStatement.block, false, context); + this.resolveAST(tryStatement.catchClause, false, context); + this.resolveAST(tryStatement.finallyClause, false, context); + }; + + PullTypeResolver.prototype.resolveCatchClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckCatchClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckCatchClause = function (ast, context) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.block, false, context); + + var catchDecl = this.semanticInfoChain.getDeclForAST(ast); + this.validateVariableDeclarationGroups(catchDecl, context); + }; + + PullTypeResolver.prototype.resolveFinallyClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckFinallyClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckFinallyClause = function (ast, context) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.block, false, context); + }; + + PullTypeResolver.prototype.getEnclosingFunctionDeclaration = function (ast) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + + while (enclosingDecl) { + if (enclosingDecl.kind & 1032192 /* SomeFunction */) { + return enclosingDecl; + } + + enclosingDecl = enclosingDecl.getParentDecl(); + } + + return null; + }; + + PullTypeResolver.prototype.resolveReturnExpression = function (expression, enclosingFunction, context) { + if (enclosingFunction) { + enclosingFunction.setFlag(4194304 /* HasReturnStatement */); + } + + var isContextuallyTyped = false; + + if (enclosingFunction) { + var enclosingDeclAST = this.getASTForDecl(enclosingFunction); + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation) { + var returnTypeAnnotationSymbol = this.resolveTypeReference(typeAnnotation, context); + if (returnTypeAnnotationSymbol) { + isContextuallyTyped = true; + context.pushContextualType(returnTypeAnnotationSymbol, context.inProvisionalResolution(), null); + } + } else { + var currentContextualType = context.getContextualType(); + if (currentContextualType && currentContextualType.isFunction()) { + var currentContextTypeDecls = currentContextualType.getDeclarations(); + var currentContextualTypeSignatureSymbol = currentContextTypeDecls && currentContextTypeDecls.length > 0 ? currentContextTypeDecls[0].getSignatureSymbol() : currentContextualType.getCallSignatures()[0]; + + var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType; + if (currentContextualTypeReturnTypeSymbol) { + isContextuallyTyped = true; + context.pushContextualType(currentContextualTypeReturnTypeSymbol, context.inProvisionalResolution(), null); + } + } + } + } + + var result = this.resolveAST(expression, isContextuallyTyped, context).type; + if (isContextuallyTyped) { + context.popContextualType(); + } + + return result; + }; + + PullTypeResolver.prototype.typeCheckReturnExpression = function (expression, expressionType, enclosingFunction, context) { + if (enclosingFunction && enclosingFunction.kind === 32768 /* ConstructorMethod */) { + var classDecl = enclosingFunction.getParentDecl(); + if (classDecl) { + var classSymbol = classDecl.getSymbol(); + this.resolveDeclaredSymbol(classSymbol, context); + + var comparisonInfo = new TypeComparisonInfo(); + var isAssignable = this.sourceIsAssignableToTarget(expressionType, classSymbol.type, expression, context, comparisonInfo); + if (!isAssignable) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class)); + } + } + } + + if (enclosingFunction && enclosingFunction.kind === 524288 /* SetAccessor */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Setters_cannot_return_a_value)); + } + + if (enclosingFunction) { + var enclosingDeclAST = this.getASTForDecl(enclosingFunction); + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation || enclosingFunction.kind === 262144 /* GetAccessor */) { + var signatureSymbol = enclosingFunction.getSignatureSymbol(); + var sigReturnType = signatureSymbol.returnType; + + if (expressionType && sigReturnType) { + var comparisonInfo = new TypeComparisonInfo(); + var upperBound = null; + + if (expressionType.isTypeParameter()) { + upperBound = expressionType.getConstraint(); + + if (upperBound) { + expressionType = upperBound; + } + } + + if (sigReturnType.isTypeParameter()) { + upperBound = sigReturnType.getConstraint(); + + if (upperBound) { + sigReturnType = upperBound; + } + } + + this.resolveDeclaredSymbol(expressionType, context); + this.resolveDeclaredSymbol(sigReturnType, context); + + var isAssignable = this.sourceIsAssignableToTarget(expressionType, sigReturnType, expression, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(expression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol)])); + } + } + } + } + } + }; + + PullTypeResolver.prototype.resolveReturnStatement = function (returnAST, context) { + var enclosingFunction = this.getEnclosingFunctionDeclaration(returnAST); + if (enclosingFunction) { + enclosingFunction.setFlag(4194304 /* HasReturnStatement */); + } + + var returnType = this.getSymbolForAST(returnAST, context); + var canTypeCheckAST = this.canTypeCheckAST(returnAST, context); + if (!returnType || canTypeCheckAST) { + var returnExpr = returnAST.expression; + + var resolvedReturnType = returnExpr === null ? this.semanticInfoChain.voidTypeSymbol : this.resolveReturnExpression(returnExpr, enclosingFunction, context); + + if (!returnType) { + returnType = resolvedReturnType; + this.setSymbolForAST(returnAST, resolvedReturnType, context); + } + + if (returnExpr && canTypeCheckAST) { + this.setTypeChecked(returnExpr, context); + this.typeCheckReturnExpression(returnExpr, resolvedReturnType, enclosingFunction, context); + } + } + + return returnType; + }; + + PullTypeResolver.prototype.resolveSwitchStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckSwitchStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckSwitchStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + var expressionType = this.resolveAST(ast.expression, false, context).type; + + for (var i = 0, n = ast.switchClauses.childCount(); i < n; i++) { + var switchClause = ast.switchClauses.childAt(i); + if (switchClause.kind() === 233 /* CaseSwitchClause */) { + var caseSwitchClause = switchClause; + + var caseClauseExpressionType = this.resolveAST(caseSwitchClause.expression, false, context).type; + this.resolveAST(caseSwitchClause.statements, false, context); + + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsAssignableToTarget(expressionType, caseClauseExpressionType, caseSwitchClause.expression, context, comparisonInfo) && !this.sourceIsAssignableToTarget(caseClauseExpressionType, expressionType, caseSwitchClause.expression, context, comparisonInfo)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(caseSwitchClause.expression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol)])); + } + } + } else { + var defaultSwitchClause = switchClause; + this.resolveAST(defaultSwitchClause.statements, false, context); + } + } + }; + + PullTypeResolver.prototype.resolveLabeledStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckLabeledStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckLabeledStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + var labelIdentifier = ast.identifier.valueText(); + + var breakableLabels = this.getEnclosingLabels(ast, true, false); + + if (TypeScript.ArrayUtilities.contains(breakableLabels, labelIdentifier)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast.identifier, TypeScript.DiagnosticCode.Duplicate_identifier_0, [labelIdentifier])); + } + + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.labelIsOnContinuableConstruct = function (statement) { + switch (statement.kind()) { + case 160 /* LabeledStatement */: + return this.labelIsOnContinuableConstruct(statement.statement); + + case 158 /* WhileStatement */: + case 154 /* ForStatement */: + case 155 /* ForInStatement */: + case 161 /* DoStatement */: + return true; + + default: + return false; + } + }; + + PullTypeResolver.prototype.resolveContinueStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckContinueStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.isIterationStatement = function (ast) { + switch (ast.kind()) { + case 154 /* ForStatement */: + case 155 /* ForInStatement */: + case 158 /* WhileStatement */: + case 161 /* DoStatement */: + return true; + } + + return false; + }; + + PullTypeResolver.prototype.isAnyFunctionExpressionOrDeclaration = function (ast) { + switch (ast.kind()) { + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + case 129 /* FunctionDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 241 /* FunctionPropertyAssignment */: + case 137 /* ConstructorDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + return true; + } + + return false; + }; + + PullTypeResolver.prototype.inSwitchStatement = function (ast) { + while (ast) { + if (ast.kind() === 151 /* SwitchStatement */) { + return true; + } + + if (this.isAnyFunctionExpressionOrDeclaration(ast)) { + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inIterationStatement = function (ast) { + while (ast) { + if (this.isIterationStatement(ast)) { + return true; + } + + if (this.isAnyFunctionExpressionOrDeclaration(ast)) { + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.getEnclosingLabels = function (ast, breakable, crossFunctions) { + var result = []; + + ast = ast.parent; + while (ast) { + if (ast.kind() === 160 /* LabeledStatement */) { + var labeledStatement = ast; + if (breakable) { + result.push(labeledStatement.identifier.valueText()); + } else { + if (this.labelIsOnContinuableConstruct(labeledStatement.statement)) { + result.push(labeledStatement.identifier.valueText()); + } + } + } + + if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) { + break; + } + + ast = ast.parent; + } + + return result; + }; + + PullTypeResolver.prototype.typeCheckContinueStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + if (!this.inIterationStatement(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.continue_statement_can_only_be_used_within_an_enclosing_iteration_statement)); + } else if (ast.identifier) { + var continuableLabels = this.getEnclosingLabels(ast, false, false); + + if (!TypeScript.ArrayUtilities.contains(continuableLabels, ast.identifier.valueText())) { + var continuableLabels = this.getEnclosingLabels(ast, false, true); + + if (TypeScript.ArrayUtilities.contains(continuableLabels, ast.identifier.valueText())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found)); + } + } + } + }; + + PullTypeResolver.prototype.resolveBreakStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckBreakStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckBreakStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + if (ast.identifier) { + var breakableLabels = this.getEnclosingLabels(ast, true, false); + + if (!TypeScript.ArrayUtilities.contains(breakableLabels, ast.identifier.valueText())) { + var breakableLabels = this.getEnclosingLabels(ast, true, true); + if (TypeScript.ArrayUtilities.contains(breakableLabels, ast.identifier.valueText())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found)); + } + } + } else if (!this.inIterationStatement(ast) && !this.inSwitchStatement(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement)); + } + }; + + PullTypeResolver.prototype.resolveAST = function (ast, isContextuallyTyped, context) { + if (!ast) { + return; + } + + var symbol = this.getSymbolForAST(ast, context); + if (symbol && symbol.isResolved) { + this.typeCheckAST(ast, isContextuallyTyped, context); + return symbol; + } + + var nodeType = ast.kind(); + + switch (nodeType) { + case 124 /* ArrayType */: + case 126 /* GenericType */: + case 122 /* ObjectType */: + case 127 /* TypeQuery */: + case 125 /* ConstructorType */: + case 123 /* FunctionType */: + return this.resolveTypeReference(ast, context); + + case 1 /* List */: + return this.resolveList(ast, context); + + case 2 /* SeparatedList */: + return this.resolveSeparatedList(ast, context); + + case 120 /* SourceUnit */: + return this.resolveSourceUnit(ast, context); + + case 132 /* EnumDeclaration */: + return this.resolveEnumDeclaration(ast, context); + + case 130 /* ModuleDeclaration */: + return this.resolveModuleDeclaration(ast, context); + + case 128 /* InterfaceDeclaration */: + return this.resolveInterfaceDeclaration(ast, context); + + case 131 /* ClassDeclaration */: + return this.resolveClassDeclaration(ast, context); + + case 224 /* VariableDeclaration */: + return this.resolveVariableDeclarationList(ast, context); + + case 136 /* MemberVariableDeclaration */: + return this.resolveMemberVariableDeclaration(ast, context); + + case 225 /* VariableDeclarator */: + return this.resolveVariableDeclarator(ast, context); + + case 141 /* PropertySignature */: + return this.resolvePropertySignature(ast, context); + + case 227 /* ParameterList */: + return this.resolveParameterList(ast, context); + + case 242 /* Parameter */: + return this.resolveParameter(ast, context); + + case 243 /* EnumElement */: + return this.resolveEnumElement(ast, context); + + case 232 /* EqualsValueClause */: + return this.resolveEqualsValueClause(ast, isContextuallyTyped, context); + + case 238 /* TypeParameter */: + return this.resolveTypeParameterDeclaration(ast, context); + + case 239 /* Constraint */: + return this.resolveConstraint(ast, context); + + case 133 /* ImportDeclaration */: + return this.resolveImportDeclaration(ast, context); + + case 215 /* ObjectLiteralExpression */: + return this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context); + + case 240 /* SimplePropertyAssignment */: + return this.resolveSimplePropertyAssignment(ast, isContextuallyTyped, context); + + case 241 /* FunctionPropertyAssignment */: + return this.resolveFunctionPropertyAssignment(ast, isContextuallyTyped, context); + + case 11 /* IdentifierName */: + if (isTypesOnlyLocation(ast)) { + return this.resolveTypeNameExpression(ast, context); + } else { + return this.resolveNameExpression(ast, context); + } + + case 212 /* MemberAccessExpression */: + return this.resolveMemberAccessExpression(ast, context); + + case 121 /* QualifiedName */: + return this.resolveQualifiedName(ast, context); + + case 137 /* ConstructorDeclaration */: + return this.resolveConstructorDeclaration(ast, context); + + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + return this.resolveAccessorDeclaration(ast, context); + + case 138 /* IndexMemberDeclaration */: + return this.resolveIndexMemberDeclaration(ast, context); + + case 144 /* IndexSignature */: + return this.resolveIndexSignature(ast, context); + + case 135 /* MemberFunctionDeclaration */: + return this.resolveMemberFunctionDeclaration(ast, context); + + case 142 /* CallSignature */: + return this.resolveCallSignature(ast, context); + + case 143 /* ConstructSignature */: + return this.resolveConstructSignature(ast, context); + + case 145 /* MethodSignature */: + return this.resolveMethodSignature(ast, context); + + case 129 /* FunctionDeclaration */: + return this.resolveAnyFunctionDeclaration(ast, context); + + case 222 /* FunctionExpression */: + return this.resolveFunctionExpression(ast, isContextuallyTyped, context); + + case 219 /* SimpleArrowFunctionExpression */: + return this.resolveSimpleArrowFunctionExpression(ast, isContextuallyTyped, context); + + case 218 /* ParenthesizedArrowFunctionExpression */: + return this.resolveParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context); + + case 214 /* ArrayLiteralExpression */: + return this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context); + + case 35 /* ThisKeyword */: + return this.resolveThisExpression(ast, context); + + case 50 /* SuperKeyword */: + return this.resolveSuperExpression(ast, context); + + case 213 /* InvocationExpression */: + return this.resolveInvocationExpression(ast, context); + + case 216 /* ObjectCreationExpression */: + return this.resolveObjectCreationExpression(ast, context); + + case 220 /* CastExpression */: + return this.resolveCastExpression(ast, context); + + case 244 /* TypeAnnotation */: + return this.resolveTypeAnnotation(ast, context); + + case 134 /* ExportAssignment */: + return this.resolveExportAssignmentStatement(ast, context); + + case 13 /* NumericLiteral */: + return this.semanticInfoChain.numberTypeSymbol; + + case 14 /* StringLiteral */: + return this.semanticInfoChain.stringTypeSymbol; + + case 32 /* NullKeyword */: + return this.semanticInfoChain.nullTypeSymbol; + + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return this.semanticInfoChain.booleanTypeSymbol; + + case 172 /* VoidExpression */: + return this.resolveVoidExpression(ast, context); + + case 174 /* AssignmentExpression */: + return this.resolveAssignmentExpression(ast, context); + + case 167 /* LogicalNotExpression */: + return this.resolveLogicalNotExpression(ast, context); + + case 193 /* NotEqualsWithTypeConversionExpression */: + case 192 /* EqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + case 196 /* LessThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 197 /* GreaterThanExpression */: + return this.resolveLogicalOperation(ast, context); + + case 208 /* AddExpression */: + case 175 /* AddAssignmentExpression */: + return this.resolveBinaryAdditionOperation(ast, context); + + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + case 166 /* BitwiseNotExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return this.resolveUnaryArithmeticOperation(ast, context); + + case 210 /* PostIncrementExpression */: + case 211 /* PostDecrementExpression */: + return this.resolvePostfixUnaryExpression(ast, context); + + case 209 /* SubtractExpression */: + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + case 189 /* BitwiseOrExpression */: + case 191 /* BitwiseAndExpression */: + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + case 190 /* BitwiseExclusiveOrExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + return this.resolveBinaryArithmeticExpression(ast, context); + + case 221 /* ElementAccessExpression */: + return this.resolveElementAccessExpression(ast, context); + + case 187 /* LogicalOrExpression */: + return this.resolveLogicalOrExpression(ast, isContextuallyTyped, context); + + case 188 /* LogicalAndExpression */: + return this.resolveLogicalAndExpression(ast, context); + + case 171 /* TypeOfExpression */: + return this.resolveTypeOfExpression(ast, context); + + case 157 /* ThrowStatement */: + return this.resolveThrowStatement(ast, context); + + case 170 /* DeleteExpression */: + return this.resolveDeleteExpression(ast, context); + + case 186 /* ConditionalExpression */: + return this.resolveConditionalExpression(ast, isContextuallyTyped, context); + + case 12 /* RegularExpressionLiteral */: + return this.resolveRegularExpressionLiteral(); + + case 217 /* ParenthesizedExpression */: + return this.resolveParenthesizedExpression(ast, context); + + case 149 /* ExpressionStatement */: + return this.resolveExpressionStatement(ast, context); + + case 200 /* InstanceOfExpression */: + return this.resolveInstanceOfExpression(ast, context); + + case 173 /* CommaExpression */: + return this.resolveCommaExpression(ast, context); + + case 201 /* InExpression */: + return this.resolveInExpression(ast, context); + + case 154 /* ForStatement */: + return this.resolveForStatement(ast, context); + + case 155 /* ForInStatement */: + return this.resolveForInStatement(ast, context); + + case 158 /* WhileStatement */: + return this.resolveWhileStatement(ast, context); + + case 161 /* DoStatement */: + return this.resolveDoStatement(ast, context); + + case 147 /* IfStatement */: + return this.resolveIfStatement(ast, context); + + case 235 /* ElseClause */: + return this.resolveElseClause(ast, context); + + case 146 /* Block */: + return this.resolveBlock(ast, context); + + case 148 /* VariableStatement */: + return this.resolveVariableStatement(ast, context); + + case 163 /* WithStatement */: + return this.resolveWithStatement(ast, context); + + case 159 /* TryStatement */: + return this.resolveTryStatement(ast, context); + + case 236 /* CatchClause */: + return this.resolveCatchClause(ast, context); + + case 237 /* FinallyClause */: + return this.resolveFinallyClause(ast, context); + + case 150 /* ReturnStatement */: + return this.resolveReturnStatement(ast, context); + + case 151 /* SwitchStatement */: + return this.resolveSwitchStatement(ast, context); + + case 153 /* ContinueStatement */: + return this.resolveContinueStatement(ast, context); + + case 152 /* BreakStatement */: + return this.resolveBreakStatement(ast, context); + + case 160 /* LabeledStatement */: + return this.resolveLabeledStatement(ast, context); + } + + return this.semanticInfoChain.anyTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckAST = function (ast, isContextuallyTyped, context) { + if (!this.canTypeCheckAST(ast, context)) { + return; + } + + var nodeType = ast.kind(); + switch (nodeType) { + case 120 /* SourceUnit */: + this.typeCheckSourceUnit(ast, context); + return; + + case 132 /* EnumDeclaration */: + this.typeCheckEnumDeclaration(ast, context); + return; + + case 130 /* ModuleDeclaration */: + this.typeCheckModuleDeclaration(ast, context); + return; + + case 128 /* InterfaceDeclaration */: + this.typeCheckInterfaceDeclaration(ast, context); + return; + + case 131 /* ClassDeclaration */: + this.typeCheckClassDeclaration(ast, context); + return; + + case 243 /* EnumElement */: + this.typeCheckEnumElement(ast, context); + return; + + case 136 /* MemberVariableDeclaration */: + this.typeCheckMemberVariableDeclaration(ast, context); + return; + + case 225 /* VariableDeclarator */: + this.typeCheckVariableDeclarator(ast, context); + return; + + case 141 /* PropertySignature */: + this.typeCheckPropertySignature(ast, context); + return; + + case 242 /* Parameter */: + this.typeCheckParameter(ast, context); + return; + + case 133 /* ImportDeclaration */: + this.typeCheckImportDeclaration(ast, context); + return; + + case 215 /* ObjectLiteralExpression */: + this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context); + return; + + case 241 /* FunctionPropertyAssignment */: + this.typeCheckFunctionPropertyAssignment(ast, isContextuallyTyped, context); + return; + + case 11 /* IdentifierName */: + if (isTypesOnlyLocation(ast)) { + this.resolveTypeNameExpression(ast, context); + } else { + this.resolveNameExpression(ast, context); + } + return; + + case 212 /* MemberAccessExpression */: + this.resolveMemberAccessExpression(ast, context); + return; + + case 121 /* QualifiedName */: + this.resolveQualifiedName(ast, context); + return; + + case 222 /* FunctionExpression */: + this.typeCheckFunctionExpression(ast, context); + break; + + case 144 /* IndexSignature */: + this.typeCheckIndexSignature(ast, context); + break; + + case 142 /* CallSignature */: + this.typeCheckCallSignature(ast, context); + break; + + case 143 /* ConstructSignature */: + this.typeCheckConstructSignature(ast, context); + break; + + case 129 /* FunctionDeclaration */: { + var funcDecl = ast; + this.typeCheckFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + return; + } + + case 219 /* SimpleArrowFunctionExpression */: + this.typeCheckSimpleArrowFunctionExpression(ast, context); + return; + + case 218 /* ParenthesizedArrowFunctionExpression */: + this.typeCheckParenthesizedArrowFunctionExpression(ast, context); + return; + + case 214 /* ArrayLiteralExpression */: + this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context); + return; + + case 213 /* InvocationExpression */: + this.typeCheckInvocationExpression(ast, context); + return; + + case 216 /* ObjectCreationExpression */: + this.typeCheckObjectCreationExpression(ast, context); + return; + + case 150 /* ReturnStatement */: + this.resolveReturnStatement(ast, context); + return; + + default: + TypeScript.Debug.assert(false, "Failure nodeType: " + TypeScript.SyntaxKind[ast.kind()] + ". Implement typeCheck when symbol is set for the ast as part of resolution."); + } + }; + + PullTypeResolver.prototype.processPostTypeCheckWorkItems = function (context) { + while (this.postTypeCheckWorkitems.length) { + var ast = this.postTypeCheckWorkitems.pop(); + this.postTypeCheck(ast, context); + } + }; + + PullTypeResolver.prototype.postTypeCheck = function (ast, context) { + var nodeType = ast.kind(); + + switch (nodeType) { + case 242 /* Parameter */: + case 225 /* VariableDeclarator */: + this.postTypeCheckVariableDeclaratorOrParameter(ast, context); + return; + + case 131 /* ClassDeclaration */: + this.postTypeCheckClassDeclaration(ast, context); + return; + + case 129 /* FunctionDeclaration */: + this.postTypeCheckFunctionDeclaration(ast, context); + return; + + case 130 /* ModuleDeclaration */: + this.postTypeCheckModuleDeclaration(ast, context); + return; + + case 132 /* EnumDeclaration */: + this.postTypeCheckEnumDeclaration(ast, context); + return; + + case 133 /* ImportDeclaration */: + this.postTypeCheckImportDeclaration(ast, context); + return; + + case 11 /* IdentifierName */: + this.postTypeCheckNameExpression(ast, context); + return; + + default: + TypeScript.Debug.assert(false, "Implement postTypeCheck clause to handle the postTypeCheck work, nodeType: " + TypeScript.SyntaxKind[ast.kind()]); + } + }; + + PullTypeResolver.prototype.resolveRegularExpressionLiteral = function () { + if (this.cachedRegExpInterfaceType()) { + return this.cachedRegExpInterfaceType(); + } else { + return this.semanticInfoChain.anyTypeSymbol; + } + }; + + PullTypeResolver.prototype.postTypeCheckNameExpression = function (nameAST, context) { + this.checkThisCaptureVariableCollides(nameAST, false, context); + }; + + PullTypeResolver.prototype.typeCheckNameExpression = function (nameAST, context) { + this.setTypeChecked(nameAST, context); + this.checkNameForCompilerGeneratedDeclarationCollision(nameAST, false, nameAST, context); + }; + + PullTypeResolver.prototype.resolveNameExpression = function (nameAST, context) { + var nameSymbol = this.getSymbolForAST(nameAST, context); + var foundCached = nameSymbol != null; + + if (!foundCached || this.canTypeCheckAST(nameAST, context)) { + if (this.canTypeCheckAST(nameAST, context)) { + this.typeCheckNameExpression(nameAST, context); + } + nameSymbol = this.computeNameExpression(nameAST, context, true); + } + + this.resolveDeclaredSymbol(nameSymbol, context); + + if (nameSymbol && (nameSymbol.type != this.semanticInfoChain.anyTypeSymbol || nameSymbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) { + this.setSymbolForAST(nameAST, nameSymbol, context); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.isSomeFunctionScope = function (declPath) { + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + if (decl.kind & 1032192 /* SomeFunction */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.computeNameExpression = function (nameAST, context, reportDiagnostics) { + var id = nameAST.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var nameSymbol = null; + var enclosingDecl = this.getEnclosingDeclForAST(nameAST); + + if (TypeScript.isDeclarationASTOrDeclarationNameAST(nameAST)) { + nameSymbol = this.semanticInfoChain.getDeclForAST(nameAST.parent).getSymbol(); + } + + var declPath = enclosingDecl.getParentPath(); + + if (!nameSymbol) { + var nameSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */); + } + + if (!nameSymbol && id === "arguments" && this.isSomeFunctionScope(declPath)) { + nameSymbol = this.cachedFunctionArgumentsSymbol(); + + this.resolveDeclaredSymbol(this.cachedIArgumentsInterfaceType(), context); + } + + if (!nameSymbol) { + nameSymbol = this.getSymbolFromDeclPath(id, declPath, 128 /* TypeAlias */); + + if (nameSymbol && !nameSymbol.isAlias()) { + nameSymbol = null; + } + } + + if (!nameSymbol) { + if (!reportDiagnostics) { + return null; + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + } + + var nameDeclaration = nameSymbol.getDeclarations()[0]; + var nameParentDecl = nameDeclaration.getParentDecl(); + if (nameParentDecl && (nameParentDecl.kind & 1032192 /* SomeFunction */) && (nameParentDecl.flags & 33554432 /* HasDefaultArgs */)) { + var enclosingFunctionAST = this.semanticInfoChain.getASTForDecl(nameParentDecl); + var currentParameterIndex = this.getCurrentParameterIndexForFunction(nameAST, enclosingFunctionAST); + + var parameterList = TypeScript.getParameterList(enclosingFunctionAST); + + if (currentParameterIndex >= 0) { + var foundMatchingParameter = false; + if (parameterList) { + for (var i = 0; i <= currentParameterIndex; i++) { + var candidateParameter = parameterList.parameters.nonSeparatorAt(i); + if (candidateParameter && candidateParameter.identifier.valueText() === id) { + foundMatchingParameter = true; + } + } + } + + if (!foundMatchingParameter) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text(), nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + } + } + + var aliasSymbol = null; + + if (nameSymbol.isType() && nameSymbol.isAlias()) { + aliasSymbol = nameSymbol; + if (!this.inTypeQuery(nameAST)) { + aliasSymbol.setIsUsedAsValue(true); + } + + this.resolveDeclaredSymbol(nameSymbol, context); + + this.resolveDeclaredSymbol(aliasSymbol.assignedValue(), context); + this.resolveDeclaredSymbol(aliasSymbol.assignedContainer(), context); + + var exportAssignmentSymbol = nameSymbol.getExportAssignedValueSymbol(); + + if (exportAssignmentSymbol) { + nameSymbol = exportAssignmentSymbol; + } else { + aliasSymbol = null; + } + } + + if (aliasSymbol) { + this.semanticInfoChain.setAliasSymbolForAST(nameAST, aliasSymbol); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.getCurrentParameterIndexForFunction = function (parameter, funcDecl) { + var parameterList = TypeScript.getParameterList(funcDecl); + if (parameterList) { + while (parameter && parameter.parent) { + if (parameter.parent.parent === parameterList) { + return parameterList.parameters.nonSeparatorIndexOf(parameter); + } + + parameter = parameter.parent; + } + } + + return -1; + }; + + PullTypeResolver.prototype.resolveMemberAccessExpression = function (dottedNameAST, context) { + return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.expression, dottedNameAST.name, context); + }; + + PullTypeResolver.prototype.resolveDottedNameExpression = function (dottedNameAST, expression, name, context) { + var symbol = this.getSymbolForAST(dottedNameAST, context); + var foundCached = symbol != null; + + if (!foundCached || this.canTypeCheckAST(dottedNameAST, context)) { + var canTypeCheckDottedNameAST = this.canTypeCheckAST(dottedNameAST, context); + if (canTypeCheckDottedNameAST) { + this.setTypeChecked(dottedNameAST, context); + } + + symbol = this.computeDottedNameExpression(expression, name, context, canTypeCheckDottedNameAST); + } + + this.resolveDeclaredSymbol(symbol, context); + + if (symbol && (symbol.type != this.semanticInfoChain.anyTypeSymbol || symbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) { + this.setSymbolForAST(dottedNameAST, symbol, context); + this.setSymbolForAST(name, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.computeDottedNameExpression = function (expression, name, context, checkSuperPrivateAndStaticAccess) { + var rhsName = name.valueText(); + if (rhsName.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var lhs = this.resolveAST(expression, false, context); + var lhsType = lhs.type; + + if (lhs.isAlias()) { + if (!this.inTypeQuery(expression)) { + lhs.setIsUsedAsValue(true); + } + lhsType = lhs.getExportAssignedTypeSymbol(); + } + + if (this.isAnyOrEquivalent(lhsType)) { + return lhsType; + } + + if (lhsType.isAlias()) { + lhsType = lhsType.getExportAssignedTypeSymbol(); + } + + if (!lhsType) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Could_not_find_enclosing_symbol_for_dotted_name_0, [name.text()])); + return this.getNewErrorTypeSymbol(); + } + + if (!lhsType.isResolved) { + var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context); + + if (potentiallySpecializedType != lhsType) { + if (!lhs.isType()) { + context.setTypeInContext(lhs, potentiallySpecializedType); + } + + lhsType = potentiallySpecializedType; + } + } + + if (lhsType.isContainer() && !lhsType.isAlias() && !lhsType.isEnum()) { + var instanceSymbol = lhsType.getInstanceSymbol(); + + if (instanceSymbol) { + lhsType = instanceSymbol.type; + } + } + + if (lhsType.isTypeParameter()) { + lhsType = this.substituteUpperBoundForType(lhsType); + } + + if ((lhsType === this.semanticInfoChain.numberTypeSymbol || lhsType.isEnum()) && this.cachedNumberInterfaceType()) { + lhsType = this.cachedNumberInterfaceType(); + } else if (lhsType === this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + lhsType = this.cachedStringInterfaceType(); + } else if (lhsType === this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + lhsType = this.cachedBooleanInterfaceType(); + } + + var nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, lhsType); + + if (!nameSymbol) { + if ((lhsType.getCallSignatures().length || lhsType.getConstructSignatures().length) && this.cachedFunctionInterfaceType()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, this.cachedFunctionInterfaceType()); + } else if (lhsType.kind === 32 /* DynamicModule */) { + var container = lhsType; + var associatedInstance = container.getInstanceSymbol(); + + if (associatedInstance) { + var instanceType = associatedInstance.type; + + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, instanceType); + } + } else { + var associatedType = lhsType.getAssociatedContainerType(); + + if (associatedType && !associatedType.isClass()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, associatedType); + } + } + + if (!nameSymbol && !lhsType.isPrimitive() && this.cachedObjectInterfaceType()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, this.cachedObjectInterfaceType()); + } + + if (!nameSymbol) { + var enclosingDecl = this.getEnclosingDeclForAST(expression); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [name.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + return this.getNewErrorTypeSymbol(rhsName); + } + } + + if (checkSuperPrivateAndStaticAccess) { + this.checkForSuperMemberAccess(expression, name, nameSymbol, context) || this.checkForPrivateMemberAccess(name, lhsType, nameSymbol, context); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.resolveTypeNameExpression = function (nameAST, context) { + var typeNameSymbol = this.getSymbolForAST(nameAST, context); + + if (!typeNameSymbol || !typeNameSymbol.isType() || this.canTypeCheckAST(nameAST, context)) { + if (this.canTypeCheckAST(nameAST, context)) { + this.setTypeChecked(nameAST, context); + } + typeNameSymbol = this.computeTypeNameExpression(nameAST, context); + this.setSymbolForAST(nameAST, typeNameSymbol, context); + } + + this.resolveDeclaredSymbol(typeNameSymbol, context); + + return typeNameSymbol; + }; + + PullTypeResolver.prototype.computeTypeNameExpression = function (nameAST, context) { + var id = nameAST.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var enclosingDecl = this.getEnclosingDeclForAST(nameAST); + + var declPath = enclosingDecl.getParentPath(); + + var onLeftOfDot = this.isLeftSideOfQualifiedName(nameAST); + + var kindToCheckFirst = onLeftOfDot ? 164 /* SomeContainer */ : 58728539 /* SomeType */; + var kindToCheckSecond = onLeftOfDot ? 58728539 /* SomeType */ : 164 /* SomeContainer */; + + var typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckFirst); + + if (!typeNameSymbol) { + typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckSecond); + } + + if (!typeNameSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + + var typeNameSymbolAlias = null; + if (typeNameSymbol.isAlias()) { + typeNameSymbolAlias = typeNameSymbol; + this.resolveDeclaredSymbol(typeNameSymbol, context); + + var aliasedType = typeNameSymbolAlias.getExportAssignedTypeSymbol(); + + this.resolveDeclaredSymbol(aliasedType, context); + } + + if (typeNameSymbol.isTypeParameter()) { + if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */) && (enclosingDecl.flags & 16 /* Static */)) { + var parentDecl = typeNameSymbol.getDeclarations()[0].getParentDecl(); + + if (parentDecl.kind == 8 /* Class */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Static_methods_cannot_reference_class_type_parameters)); + return this.getNewErrorTypeSymbol(); + } + } + } + + if (!typeNameSymbol.isGeneric() && (typeNameSymbol.isClass() || typeNameSymbol.isInterface())) { + typeNameSymbol = TypeScript.PullTypeReferenceSymbol.createTypeReference(typeNameSymbol); + } + + return typeNameSymbol; + }; + + PullTypeResolver.prototype.isLeftSideOfQualifiedName = function (ast) { + return ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.left === ast; + }; + + PullTypeResolver.prototype.resolveGenericTypeReference = function (genericTypeAST, context) { + var genericTypeSymbol = this.resolveAST(genericTypeAST.name, false, context).type; + + if (genericTypeSymbol.isError()) { + return genericTypeSymbol; + } + + if (!genericTypeSymbol.inResolution && !genericTypeSymbol.isResolved) { + this.resolveDeclaredSymbol(genericTypeSymbol, context); + } + + if (genericTypeSymbol.isAlias()) { + genericTypeSymbol = genericTypeSymbol.getExportAssignedTypeSymbol(); + } + + var typeArgs = []; + + if (genericTypeAST.typeArgumentList && genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(genericTypeAST.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + + if (typeArgs[i].isError()) { + typeArgs[i] = this.semanticInfoChain.anyTypeSymbol; + } + } + } + + var typeParameters = genericTypeSymbol.getTypeParameters(); + + if (typeArgs.length && typeArgs.length != typeParameters.length) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Generic_type_0_requires_1_type_argument_s, [genericTypeSymbol.toString(), genericTypeSymbol.getTypeParameters().length])); + return this.getNewErrorTypeSymbol(); + } + + if (!genericTypeSymbol.isResolved) { + var typeDecls = genericTypeSymbol.getDeclarations(); + var childDecls = null; + + for (var i = 0; i < typeDecls.length; i++) { + childDecls = typeDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + } + + var specializedSymbol = this.createInstantiatedType(genericTypeSymbol, typeArgs); + + var typeConstraint = null; + var upperBound = null; + + typeParameters = specializedSymbol.getTypeParameters(); + + var typeConstraintSubstitutionMap = []; + var typeArg = null; + + var instantiatedSubstitutionMap = specializedSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < typeParameters.length; i++) { + typeConstraintSubstitutionMap[typeParameters[i].pullSymbolID] = typeParameters[i]; + } + + for (var id in instantiatedSubstitutionMap) { + typeConstraintSubstitutionMap[id] = instantiatedSubstitutionMap[id]; + } + + for (var iArg = 0; (iArg < typeArgs.length) && (iArg < typeParameters.length); iArg++) { + typeArg = typeArgs[iArg]; + typeConstraint = typeParameters[iArg].getConstraint(); + + typeConstraintSubstitutionMap[typeParameters[iArg].pullSymbolID] = typeArg; + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var j = 0; j < typeParameters.length && j < typeArgs.length; j++) { + if (typeParameters[j] == typeConstraint) { + typeConstraint = typeArgs[j]; + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeConstraintSubstitutionMap); + } + + if (typeArg.isTypeParameter()) { + upperBound = typeArg.getConstraint(); + + if (upperBound) { + typeArg = upperBound; + } + } + + if (typeArg.inResolution || (typeArg.isTypeReference() && typeArg.referencedTypeSymbol.inResolution)) { + return specializedSymbol; + } + if (!this.sourceIsAssignableToTarget(typeArg, typeConstraint, genericTypeAST, context)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(genericTypeAST); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [typeArg.toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[iArg].toString(enclosingSymbol, true)])); + } + } + } + + return specializedSymbol; + }; + + PullTypeResolver.prototype.resolveQualifiedName = function (dottedNameAST, context) { + if (this.inTypeQuery(dottedNameAST)) { + return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.left, dottedNameAST.right, context).type; + } + + var symbol = this.getSymbolForAST(dottedNameAST, context); + if (!symbol || this.canTypeCheckAST(dottedNameAST, context)) { + var canTypeCheck = this.canTypeCheckAST(dottedNameAST, context); + if (canTypeCheck) { + this.setTypeChecked(dottedNameAST, context); + } + + symbol = this.computeQualifiedName(dottedNameAST, context); + this.setSymbolForAST(dottedNameAST, symbol, context); + } + + this.resolveDeclaredSymbol(symbol, context); + + return symbol; + }; + + PullTypeResolver.prototype.computeQualifiedName = function (dottedNameAST, context) { + var rhsName = dottedNameAST.right.valueText(); + if (rhsName.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var enclosingDecl = this.getEnclosingDeclForAST(dottedNameAST); + var lhs = this.resolveAST(dottedNameAST.left, false, context); + + var lhsType = lhs.isAlias() ? lhs.getExportAssignedContainerSymbol() : lhs.type; + + if (this.inClassExtendsHeritageClause(dottedNameAST) && !this.inTypeArgumentList(dottedNameAST)) { + if (lhs.isAlias()) { + lhs.setIsUsedAsValue(true); + } + } + + if (!lhsType) { + return this.getNewErrorTypeSymbol(); + } + + if (this.isAnyOrEquivalent(lhsType)) { + return lhsType; + } + + var onLeftOfDot = this.isLeftSideOfQualifiedName(dottedNameAST); + var isNameOfModule = dottedNameAST.parent.kind() === 130 /* ModuleDeclaration */ && dottedNameAST.parent.name === dottedNameAST; + var memberKind = (onLeftOfDot || isNameOfModule) ? 164 /* SomeContainer */ : 58728539 /* SomeType */; + + var childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, lhsType); + + if (!childTypeSymbol && lhsType.isContainer()) { + var exportedContainer = lhsType.getExportAssignedContainerSymbol(); + + if (exportedContainer) { + childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, exportedContainer); + } + } + + if (!childTypeSymbol && enclosingDecl) { + var parentDecl = enclosingDecl; + + while (parentDecl) { + if (parentDecl.kind & 164 /* SomeContainer */) { + break; + } + + parentDecl = parentDecl.getParentDecl(); + } + + if (parentDecl) { + var enclosingSymbolType = parentDecl.getSymbol().type; + + if (enclosingSymbolType === lhsType) { + childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, lhsType); + } + } + } + + if (!childTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [dottedNameAST.right.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + return this.getNewErrorTypeSymbol(rhsName); + } + + return childTypeSymbol; + }; + + PullTypeResolver.prototype.shouldContextuallyTypeAnyFunctionExpression = function (functionExpressionAST, typeParameters, parameters, returnTypeAnnotation, context) { + if (typeParameters && typeParameters.typeParameters.nonSeparatorCount() > 0) { + return false; + } + + if (returnTypeAnnotation) { + return false; + } + + if (parameters) { + for (var i = 0, n = parameters.length; i < n; i++) { + if (parameters.typeAt(i)) { + return false; + } + } + } + + var contextualFunctionTypeSymbol = context.getContextualType(); + + if (contextualFunctionTypeSymbol) { + this.resolveDeclaredSymbol(contextualFunctionTypeSymbol, context); + var callSignatures = contextualFunctionTypeSymbol.getCallSignatures(); + var exactlyOneCallSignature = callSignatures && callSignatures.length == 1; + if (!exactlyOneCallSignature) { + return false; + } + + var callSignatureIsGeneric = callSignatures[0].typeParameters && callSignatures[0].typeParameters.length > 0; + return !callSignatureIsGeneric; + } + + return false; + }; + + PullTypeResolver.prototype.resolveAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) { + var funcDeclSymbol = null; + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + TypeScript.Debug.assert(functionDecl); + + if (functionDecl && functionDecl.hasSymbol()) { + funcDeclSymbol = functionDecl.getSymbol(); + if (funcDeclSymbol.isResolved || funcDeclSymbol.inResolution) { + return funcDeclSymbol; + } + } + + funcDeclSymbol = functionDecl.getSymbol(); + TypeScript.Debug.assert(funcDeclSymbol); + + var funcDeclType = funcDeclSymbol.type; + var signature = funcDeclType.getCallSignatures()[0]; + funcDeclSymbol.startResolving(); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + var assigningFunctionSignature = null; + if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) { + assigningFunctionSignature = context.getContextualType().getCallSignatures()[0]; + } + + if (parameters) { + var contextParams = []; + + if (assigningFunctionSignature) { + contextParams = assigningFunctionSignature.parameters; + } + + var contextualParametersCount = contextParams.length; + for (var i = 0, n = parameters.length; i < n; i++) { + var actualParameterIsVarArgParameter = (i === (n - 1)) && parameters.lastParameterIsRest(); + var correspondingContextualParameter = null; + var contextualParameterType = null; + + if (i < contextualParametersCount) { + correspondingContextualParameter = contextParams[i]; + } else if (contextualParametersCount && contextParams[contextualParametersCount - 1].isVarArg) { + correspondingContextualParameter = contextParams[contextualParametersCount - 1]; + } + + if (correspondingContextualParameter) { + if (correspondingContextualParameter.isVarArg === actualParameterIsVarArgParameter) { + contextualParameterType = correspondingContextualParameter.type; + } else if (correspondingContextualParameter.isVarArg) { + contextualParameterType = correspondingContextualParameter.type.getElementType(); + } + } + + this.resolveFunctionExpressionParameter(parameters.astAt(i), parameters.identifierAt(i), parameters.typeAt(i), parameters.initializerAt(i), contextualParameterType, functionDecl, context); + } + } + + if (returnTypeAnnotation) { + signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context); + } else { + if (assigningFunctionSignature) { + var returnType = assigningFunctionSignature.returnType; + + if (returnType) { + context.pushContextualType(returnType, context.inProvisionalResolution(), null); + + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, true, functionDecl, context); + context.popContextualType(); + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (this.compilationSettings.noImplicitAny()) { + var functionExpressionName = functionDecl.getFunctionExpressionName(); + + if (functionExpressionName != "") { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionExpressionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } + } else { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, false, functionDecl, context); + } + } + + context.setTypeInContext(funcDeclSymbol, funcDeclType); + funcDeclSymbol.setResolved(); + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckAnyFunctionExpression(funcDeclAST, typeParameters, returnTypeAnnotation, block, bodyExpression, context); + } + + return funcDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckSimpleArrowFunctionExpression = function (arrowFunction, context) { + return this.typeCheckAnyFunctionExpression(arrowFunction, null, null, arrowFunction.block, arrowFunction.expression, context); + }; + + PullTypeResolver.prototype.typeCheckParenthesizedArrowFunctionExpression = function (arrowFunction, context) { + return this.typeCheckAnyFunctionExpression(arrowFunction, arrowFunction.callSignature.typeParameterList, TypeScript.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, context); + }; + + PullTypeResolver.prototype.typeCheckAnyFunctionExpression = function (funcDeclAST, typeParameters, returnTypeAnnotation, block, bodyExpression, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcDeclSymbol = functionDecl.getSymbol(); + var funcDeclType = funcDeclSymbol.type; + var signature = funcDeclType.getCallSignatures()[0]; + var returnTypeSymbol = signature.returnType; + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + context.pushContextualType(null, context.inProvisionalResolution(), null); + if (block) { + this.resolveAST(block, false, context); + } else { + var bodyExpressionType = this.resolveReturnExpression(bodyExpression, functionDecl, context); + this.typeCheckReturnExpression(bodyExpression, bodyExpressionType, functionDecl, context); + } + context.popContextualType(); + + var hasReturn = (functionDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + if (block && returnTypeAnnotation != null && !hasReturn) { + var isVoidOrAny = this.isAnyOrEquivalent(returnTypeSymbol) || returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol; + + if (!isVoidOrAny && !(block.statements.childCount() > 0 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + var funcName = functionDecl.getDisplayName(); + funcName = funcName ? "'" + funcName + "'" : "expression"; + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_0_declared_a_non_void_return_type_but_has_no_return_expression, [funcName])); + } + } + + this.validateVariableDeclarationGroups(functionDecl, context); + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.resolveThisExpression = function (thisExpression, context) { + var enclosingDecl = this.getEnclosingDeclForAST(thisExpression); + var thisTypeSymbol = this.getContextualClassSymbolForEnclosingDecl(thisExpression, enclosingDecl) || this.semanticInfoChain.anyTypeSymbol; + + if (this.canTypeCheckAST(thisExpression, context)) { + this.typeCheckThisExpression(thisExpression, context, enclosingDecl); + } + + return thisTypeSymbol; + }; + + PullTypeResolver.prototype.inTypeArgumentList = function (ast) { + var previous = null; + var current = ast; + + while (current) { + switch (current.kind()) { + case 126 /* GenericType */: + var genericType = current; + if (genericType.typeArgumentList === previous) { + return true; + } + break; + + case 226 /* ArgumentList */: + var argumentList = current; + return argumentList.typeArgumentList === previous; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inClassExtendsHeritageClause = function (ast) { + while (ast) { + switch (ast.kind()) { + case 230 /* ExtendsHeritageClause */: + var heritageClause = ast; + + return heritageClause.parent.parent.kind() === 131 /* ClassDeclaration */; + + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inTypeQuery = function (ast) { + while (ast) { + switch (ast.kind()) { + case 127 /* TypeQuery */: + return true; + case 129 /* FunctionDeclaration */: + case 213 /* InvocationExpression */: + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inArgumentListOfSuperInvocation = function (ast) { + var previous = null; + var current = ast; + while (current) { + switch (current.kind()) { + case 213 /* InvocationExpression */: + var invocationExpression = current; + if (previous === invocationExpression.argumentList && invocationExpression.expression.kind() === 50 /* SuperKeyword */) { + return true; + } + break; + + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inConstructorParameterList = function (ast) { + var previous = null; + var current = ast; + while (current) { + switch (current.kind()) { + case 137 /* ConstructorDeclaration */: + var constructorDecl = current; + return previous === constructorDecl.parameterList; + + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.isFunctionOrNonArrowFunctionExpression = function (decl) { + if (decl.kind === 16384 /* Function */) { + return true; + } else if (decl.kind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) { + return true; + } + + return false; + }; + + PullTypeResolver.prototype.typeCheckThisExpression = function (thisExpression, context, enclosingDecl) { + this.checkForThisCaptureInArrowFunction(thisExpression); + + if (this.inConstructorParameterList(thisExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_constructor_arguments)); + return; + } + + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + return; + } else if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) { + if (currentDecl.getParentDecl() === null) { + return; + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_within_module_bodies)); + return; + } + } else if (currentDecl.kind === 32768 /* ConstructorMethod */) { + if (this.inArgumentListOfSuperInvocation(thisExpression) && this.superCallMustBeFirstStatementInConstructor(currentDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location)); + } + + return; + } else if (currentDecl.kind === 8 /* Class */) { + if (this.inStaticMemberVariableDeclaration(thisExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_static_initializers_in_a_class_body)); + } + + return; + } + } + }; + + PullTypeResolver.prototype.getContextualClassSymbolForEnclosingDecl = function (ast, enclosingDecl) { + var declPath = enclosingDecl.getParentPath(); + + if (declPath.length) { + var isStaticContext = false; + + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + var declFlags = decl.flags; + + if (declFlags & 16 /* Static */) { + isStaticContext = true; + } else if (declKind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) { + return null; + } else if (declKind === 16384 /* Function */) { + return null; + } else if (declKind === 8 /* Class */) { + if (this.inStaticMemberVariableDeclaration(ast)) { + return this.getNewErrorTypeSymbol(); + } else { + var classSymbol = decl.getSymbol(); + if (isStaticContext) { + var constructorSymbol = classSymbol.getConstructorMethod(); + return constructorSymbol.type; + } else { + return classSymbol; + } + } + } + } + } + + return null; + }; + + PullTypeResolver.prototype.inStaticMemberVariableDeclaration = function (ast) { + while (ast) { + if (ast.kind() === 136 /* MemberVariableDeclaration */ && TypeScript.hasModifier(ast.modifiers, 16 /* Static */)) { + return true; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.resolveSuperExpression = function (ast, context) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + var superType = this.semanticInfoChain.anyTypeSymbol; + + var classSymbol = this.getContextualClassSymbolForEnclosingDecl(ast, enclosingDecl); + + if (classSymbol) { + this.resolveDeclaredSymbol(classSymbol, context); + + var parents = classSymbol.getExtendedTypes(); + + if (parents.length) { + superType = parents[0]; + } + } + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckSuperExpression(ast, context, enclosingDecl); + } + + return superType; + }; + + PullTypeResolver.prototype.typeCheckSuperExpression = function (ast, context, enclosingDecl) { + this.setTypeChecked(ast, context); + + this.checkForThisCaptureInArrowFunction(ast); + + var isSuperCall = ast.parent.kind() === 213 /* InvocationExpression */; + var isSuperPropertyAccess = ast.parent.kind() === 212 /* MemberAccessExpression */; + TypeScript.Debug.assert(isSuperCall || isSuperPropertyAccess); + + if (isSuperPropertyAccess) { + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + break; + } else if (currentDecl.kind === 8 /* Class */) { + if (!this.enclosingClassIsDerived(currentDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes)); + return; + } else if (this.inConstructorParameterList(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments)); + return; + } else if (this.inStaticMemberVariableDeclaration(ast)) { + break; + } + + return; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class)); + return; + } else { + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + break; + } else if (currentDecl.kind === 32768 /* ConstructorMethod */) { + var classDecl = currentDecl.getParentDecl(); + + if (!this.enclosingClassIsDerived(classDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes)); + return; + } else if (this.inConstructorParameterList(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments)); + return; + } + + return; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_local_functions_inside_constructors)); + } + }; + + PullTypeResolver.prototype.resolveSimplePropertyAssignment = function (propertyAssignment, isContextuallyTyped, context) { + return this.resolveAST(propertyAssignment.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcProp.callSignature.parameterList), TypeScript.getType(funcProp), funcProp.block, null, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.typeCheckFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) { + this.typeCheckAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.getType(funcProp), funcProp.block, null, context); + }; + + PullTypeResolver.prototype.resolveObjectLiteralExpression = function (expressionAST, isContextuallyTyped, context, additionalResults) { + var symbol = this.getSymbolForAST(expressionAST, context); + + if (!symbol || additionalResults || this.canTypeCheckAST(expressionAST, context)) { + if (this.canTypeCheckAST(expressionAST, context)) { + this.setTypeChecked(expressionAST, context); + } + symbol = this.computeObjectLiteralExpression(expressionAST, isContextuallyTyped, context, additionalResults); + this.setSymbolForAST(expressionAST, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.bindObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralMembers, isUsingExistingSymbol, pullTypeContext) { + var boundMemberSymbols = []; + var memberSymbol; + for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) { + var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i); + + var id = this.getPropertyAssignmentName(propertyAssignment); + var assignmentText = getPropertyAssignmentNameTextFromIdentifier(id); + + var isAccessor = propertyAssignment.kind() === 139 /* GetAccessor */ || propertyAssignment.kind() === 140 /* SetAccessor */; + var decl = this.semanticInfoChain.getDeclForAST(propertyAssignment); + TypeScript.Debug.assert(decl); + + if (propertyAssignment.kind() == 240 /* SimplePropertyAssignment */) { + if (!isUsingExistingSymbol) { + memberSymbol = new TypeScript.PullSymbol(assignmentText.memberName, 4096 /* Property */); + memberSymbol.addDeclaration(decl); + decl.setSymbol(memberSymbol); + } else { + memberSymbol = decl.getSymbol(); + } + } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) { + memberSymbol = decl.getSymbol(); + } else { + TypeScript.Debug.assert(isAccessor); + memberSymbol = decl.getSymbol(); + } + + if (!isUsingExistingSymbol && !isAccessor) { + if (objectLiteralTypeSymbol.findMember(memberSymbol.name, true)) { + pullTypeContext.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(propertyAssignment, TypeScript.DiagnosticCode.Duplicate_identifier_0, [assignmentText.actualText])); + } + + objectLiteralTypeSymbol.addMember(memberSymbol); + } + + boundMemberSymbols.push(memberSymbol); + } + + return boundMemberSymbols; + }; + + PullTypeResolver.prototype.resolveObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralContextualType, objectLiteralMembers, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, pullTypeContext, additionalResults) { + for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) { + var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i); + + var acceptedContextualType = false; + var assigningSymbol = null; + + var id = this.getPropertyAssignmentName(propertyAssignment); + var memberSymbol = boundMemberSymbols[i]; + + if (objectLiteralContextualType) { + assigningSymbol = this.getMemberSymbol(memberSymbol.name, 68147712 /* SomeValue */, objectLiteralContextualType); + + if (!assigningSymbol) { + if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) { + assigningSymbol = numericIndexerSignature; + } else if (stringIndexerSignature) { + assigningSymbol = stringIndexerSignature; + } + } + + if (assigningSymbol) { + this.resolveDeclaredSymbol(assigningSymbol, pullTypeContext); + + var contextualMemberType = assigningSymbol.kind === 4194304 /* IndexSignature */ ? assigningSymbol.returnType : assigningSymbol.type; + pullTypeContext.pushContextualType(contextualMemberType, pullTypeContext.inProvisionalResolution(), null); + + acceptedContextualType = true; + + if (additionalResults) { + additionalResults.membersContextTypeSymbols[i] = contextualMemberType; + } + } + } + + var propertySymbol = this.resolveAST(propertyAssignment, contextualMemberType != null, pullTypeContext); + var memberExpr = this.widenType(propertySymbol.type, propertyAssignment, pullTypeContext); + + if (memberExpr.type) { + if (memberExpr.type.isGeneric()) { + objectLiteralTypeSymbol.setHasGenericMember(); + } + + if (stringIndexerSignature) { + allMemberTypes.push(memberExpr.type); + } + if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) { + allNumericMemberTypes.push(memberExpr.type); + } + } + + if (acceptedContextualType) { + pullTypeContext.popContextualType(); + } + + var isAccessor = propertyAssignment.kind() === 140 /* SetAccessor */ || propertyAssignment.kind() === 139 /* GetAccessor */; + if (!isUsingExistingSymbol) { + if (isAccessor) { + this.setSymbolForAST(id, memberExpr, pullTypeContext); + } else { + pullTypeContext.setTypeInContext(memberSymbol, memberExpr.type); + memberSymbol.setResolved(); + + this.setSymbolForAST(id, memberSymbol, pullTypeContext); + } + } + } + }; + + PullTypeResolver.prototype.computeObjectLiteralExpression = function (objectLitAST, isContextuallyTyped, context, additionalResults) { + var objectLitDecl = this.semanticInfoChain.getDeclForAST(objectLitAST); + TypeScript.Debug.assert(objectLitDecl); + + var typeSymbol = this.getSymbolForAST(objectLitAST, context); + var isUsingExistingSymbol = !!typeSymbol; + + if (!typeSymbol) { + typeSymbol = new TypeScript.PullTypeSymbol("", 16 /* Interface */); + typeSymbol.addDeclaration(objectLitDecl); + this.setSymbolForAST(objectLitAST, typeSymbol, context); + objectLitDecl.setSymbol(typeSymbol); + } + + var propertyAssignments = objectLitAST.propertyAssignments; + var contextualType = null; + + if (isContextuallyTyped) { + contextualType = context.getContextualType(); + this.resolveDeclaredSymbol(contextualType, context); + } + + var stringIndexerSignature = null; + var numericIndexerSignature = null; + var allMemberTypes = null; + var allNumericMemberTypes = null; + + if (contextualType) { + var indexSignatures = this.getBothKindsOfIndexSignatures(contextualType, context); + + stringIndexerSignature = indexSignatures.stringSignature; + numericIndexerSignature = indexSignatures.numericSignature; + + if (stringIndexerSignature) { + allMemberTypes = [stringIndexerSignature.returnType]; + } + + if (numericIndexerSignature) { + allNumericMemberTypes = [numericIndexerSignature.returnType]; + } + } + + if (propertyAssignments) { + if (additionalResults) { + additionalResults.membersContextTypeSymbols = []; + } + + var boundMemberSymbols = this.bindObjectLiteralMembers(objectLitDecl, typeSymbol, propertyAssignments, isUsingExistingSymbol, context); + + this.resolveObjectLiteralMembers(objectLitDecl, typeSymbol, contextualType, propertyAssignments, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, context, additionalResults); + + if (!isUsingExistingSymbol) { + this.stampObjectLiteralWithIndexSignature(typeSymbol, allMemberTypes, stringIndexerSignature, context); + this.stampObjectLiteralWithIndexSignature(typeSymbol, allNumericMemberTypes, numericIndexerSignature, context); + } + } + + typeSymbol.setResolved(); + return typeSymbol; + }; + + PullTypeResolver.prototype.getPropertyAssignmentName = function (propertyAssignment) { + if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 139 /* GetAccessor */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 140 /* SetAccessor */) { + return propertyAssignment.propertyName; + } else { + TypeScript.Debug.assert(false); + } + }; + + PullTypeResolver.prototype.stampObjectLiteralWithIndexSignature = function (objectLiteralSymbol, indexerTypeCandidates, contextualIndexSignature, context) { + if (contextualIndexSignature) { + var typeCollection = { + getLength: function () { + return indexerTypeCandidates.length; + }, + getTypeAtIndex: function (index) { + return indexerTypeCandidates[index]; + } + }; + var decl = objectLiteralSymbol.getDeclarations()[0]; + var indexerReturnType = this.widenType(this.findBestCommonType(typeCollection, context)); + if (indexerReturnType == contextualIndexSignature.returnType) { + objectLiteralSymbol.addIndexSignature(contextualIndexSignature); + } else { + this.semanticInfoChain.addSyntheticIndexSignature(decl, objectLiteralSymbol, this.getASTForDecl(decl), contextualIndexSignature.parameters[0].name, contextualIndexSignature.parameters[0].type, indexerReturnType); + } + } + }; + + PullTypeResolver.prototype.resolveArrayLiteralExpression = function (arrayLit, isContextuallyTyped, context) { + var symbol = this.getSymbolForAST(arrayLit, context); + if (!symbol || this.canTypeCheckAST(arrayLit, context)) { + if (this.canTypeCheckAST(arrayLit, context)) { + this.setTypeChecked(arrayLit, context); + } + symbol = this.computeArrayLiteralExpressionSymbol(arrayLit, isContextuallyTyped, context); + this.setSymbolForAST(arrayLit, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.computeArrayLiteralExpressionSymbol = function (arrayLit, isContextuallyTyped, context) { + var elements = arrayLit.expressions; + var elementType = null; + var elementTypes = []; + var comparisonInfo = new TypeComparisonInfo(); + var contextualElementType = null; + comparisonInfo.onlyCaptureFirstError = true; + + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + + this.resolveDeclaredSymbol(contextualType, context); + + if (contextualType) { + var indexSignatures = this.getBothKindsOfIndexSignatures(contextualType, context); + if (indexSignatures.numericSignature) { + contextualElementType = indexSignatures.numericSignature.returnType; + } + } + } + + if (elements) { + if (contextualElementType) { + context.pushContextualType(contextualElementType, context.inProvisionalResolution(), null); + } + + for (var i = 0, n = elements.nonSeparatorCount(); i < n; i++) { + elementTypes.push(this.resolveAST(elements.nonSeparatorAt(i), contextualElementType !== null, context).type); + } + + if (contextualElementType) { + context.popContextualType(); + } + } + + if (elementTypes.length) { + elementType = elementTypes[0]; + } + var collection; + if (contextualElementType) { + if (!elementType) { + elementType = contextualElementType; + } + + collection = { + getLength: function () { + return elements.nonSeparatorCount() + 1; + }, + getTypeAtIndex: function (index) { + return index === 0 ? contextualElementType : elementTypes[index - 1]; + } + }; + } else { + collection = { + getLength: function () { + return elements.nonSeparatorCount(); + }, + getTypeAtIndex: function (index) { + return elementTypes[index]; + } + }; + } + + elementType = elementType ? this.findBestCommonType(collection, context, comparisonInfo) : elementType; + + if (!elementType) { + elementType = this.semanticInfoChain.undefinedTypeSymbol; + } + + var arraySymbol = elementType.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + + elementType.setArrayType(arraySymbol); + } + + return arraySymbol; + }; + + PullTypeResolver.prototype.resolveElementAccessExpression = function (callEx, context) { + var symbolAndDiagnostic = this.computeElementAccessExpressionSymbolAndDiagnostic(callEx, context); + + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckElementAccessExpression(callEx, context, symbolAndDiagnostic); + } + + return symbolAndDiagnostic.symbol; + }; + + PullTypeResolver.prototype.typeCheckElementAccessExpression = function (callEx, context, symbolAndDiagnostic) { + this.setTypeChecked(callEx, context); + context.postDiagnostic(symbolAndDiagnostic.diagnostic); + }; + + PullTypeResolver.prototype.computeElementAccessExpressionSymbolAndDiagnostic = function (callEx, context) { + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var indexType = this.resolveAST(callEx.argumentExpression, false, context).type; + + var targetTypeSymbol = targetSymbol.type; + + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + return { symbol: targetTypeSymbol }; + } + + var elementType = targetTypeSymbol.getElementType(); + + var isNumberIndex = indexType === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(indexType); + + if (elementType && isNumberIndex) { + return { symbol: elementType }; + } + + if (callEx.argumentExpression.kind() === 14 /* StringLiteral */ || callEx.argumentExpression.kind() === 13 /* NumericLiteral */) { + var memberName = callEx.argumentExpression.kind() === 14 /* StringLiteral */ ? TypeScript.stripStartAndEndQuotes(callEx.argumentExpression.text()) : callEx.argumentExpression.valueText(); + + var member = this.getMemberSymbol(memberName, 68147712 /* SomeValue */, targetTypeSymbol); + + if (member) { + this.resolveDeclaredSymbol(member, context); + + return { symbol: member.type }; + } + } + + if (targetTypeSymbol == this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + targetTypeSymbol = this.cachedStringInterfaceType(); + } + + var signatures = this.getBothKindsOfIndexSignatures(targetTypeSymbol, context); + + var stringSignature = signatures.stringSignature; + var numberSignature = signatures.numericSignature; + + if (numberSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol)) { + return { symbol: numberSignature.returnType || this.semanticInfoChain.anyTypeSymbol }; + } else if (stringSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol)) { + return { symbol: stringSignature.returnType || this.semanticInfoChain.anyTypeSymbol }; + } else if (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol) { + return { symbol: this.semanticInfoChain.anyTypeSymbol }; + } else { + return { + symbol: this.getNewErrorTypeSymbol(), + diagnostic: this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Value_of_type_0_is_not_indexable_by_type_1, [targetTypeSymbol.toString(), indexType.toString()]) + }; + } + }; + + PullTypeResolver.prototype.getBothKindsOfIndexSignatures = function (enclosingType, context) { + var signatures = enclosingType.getIndexSignatures(); + + var stringSignature = null; + var numberSignature = null; + var signature = null; + var paramSymbols; + var paramType; + + for (var i = 0; i < signatures.length; i++) { + if (stringSignature && numberSignature) { + break; + } + + signature = signatures[i]; + if (!signature.isResolved) { + this.resolveDeclaredSymbol(signature, context); + } + + paramSymbols = signature.parameters; + + if (paramSymbols.length) { + paramType = paramSymbols[0].type; + + if (!stringSignature && paramType === this.semanticInfoChain.stringTypeSymbol) { + stringSignature = signature; + continue; + } else if (!numberSignature && paramType === this.semanticInfoChain.numberTypeSymbol) { + numberSignature = signature; + continue; + } + } + } + + return { + numericSignature: numberSignature, + stringSignature: stringSignature + }; + }; + + PullTypeResolver.prototype.resolveBinaryAdditionOperation = function (binaryExpression, context) { + var lhsExpression = this.resolveAST(binaryExpression.left, false, context); + var lhsType = lhsExpression.type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + if (TypeScript.PullHelpers.symbolIsEnum(lhsType)) { + lhsType = this.semanticInfoChain.numberTypeSymbol; + } else if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) { + if (rhsType != this.semanticInfoChain.nullTypeSymbol && rhsType != this.semanticInfoChain.undefinedTypeSymbol) { + lhsType = rhsType; + } else { + lhsType = this.semanticInfoChain.anyTypeSymbol; + } + } + + if (TypeScript.PullHelpers.symbolIsEnum(rhsType)) { + rhsType = this.semanticInfoChain.numberTypeSymbol; + } else if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) { + if (lhsType != this.semanticInfoChain.nullTypeSymbol && lhsType != this.semanticInfoChain.undefinedTypeSymbol) { + rhsType = lhsType; + } else { + rhsType = this.semanticInfoChain.anyTypeSymbol; + } + } + + var exprType = null; + + if (lhsType === this.semanticInfoChain.stringTypeSymbol || rhsType === this.semanticInfoChain.stringTypeSymbol) { + exprType = this.semanticInfoChain.stringTypeSymbol; + } else if (this.isAnyOrEquivalent(lhsType) || this.isAnyOrEquivalent(rhsType)) { + exprType = this.semanticInfoChain.anyTypeSymbol; + } else if (rhsType === this.semanticInfoChain.numberTypeSymbol && lhsType === this.semanticInfoChain.numberTypeSymbol) { + exprType = this.semanticInfoChain.numberTypeSymbol; + } + + if (this.canTypeCheckAST(binaryExpression, context)) { + this.setTypeChecked(binaryExpression, context); + + if (exprType) { + if (binaryExpression.kind() === 175 /* AddAssignmentExpression */) { + if (!this.isReference(binaryExpression.left, lhsExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } + + this.checkAssignability(binaryExpression.left, exprType, lhsType, context); + } + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_expression_types_not_known_to_support_the_addition_operator)); + } + } + + if (!exprType) { + exprType = this.semanticInfoChain.anyTypeSymbol; + } + + return exprType; + }; + + PullTypeResolver.prototype.bestCommonTypeOfTwoTypes = function (type1, type2, context) { + return this.findBestCommonType({ + getLength: function () { + return 2; + }, + getTypeAtIndex: function (index) { + switch (index) { + case 0: + return type1; + case 1: + return type2; + } + } + }, context); + }; + + PullTypeResolver.prototype.bestCommonTypeOfThreeTypes = function (type1, type2, type3, context) { + return this.findBestCommonType({ + getLength: function () { + return 3; + }, + getTypeAtIndex: function (index) { + switch (index) { + case 0: + return type1; + case 1: + return type2; + case 2: + return type3; + } + } + }, context); + }; + + PullTypeResolver.prototype.resolveLogicalOrExpression = function (binex, isContextuallyTyped, context) { + if (this.canTypeCheckAST(binex, context)) { + this.setTypeChecked(binex, context); + } + + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + var leftType = this.resolveAST(binex.left, isContextuallyTyped, context).type; + var rightType = this.resolveAST(binex.right, isContextuallyTyped, context).type; + + return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context); + } else { + var leftType = this.resolveAST(binex.left, false, context).type; + + context.pushContextualType(leftType, context.inProvisionalResolution(), null); + var rightType = this.resolveAST(binex.right, true, context).type; + context.popContextualType(); + + return this.bestCommonTypeOfTwoTypes(leftType, rightType, context); + } + }; + + PullTypeResolver.prototype.resolveLogicalAndExpression = function (binex, context) { + if (this.canTypeCheckAST(binex, context)) { + this.setTypeChecked(binex, context); + + this.resolveAST(binex.left, false, context); + } + + return this.resolveAST(binex.right, false, context).type; + }; + + PullTypeResolver.prototype.computeTypeOfConditionalExpression = function (leftType, rightType, isContextuallyTyped, context) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context); + } else { + return this.bestCommonTypeOfTwoTypes(leftType, rightType, context); + } + }; + + PullTypeResolver.prototype.resolveConditionalExpression = function (trinex, isContextuallyTyped, context) { + var leftType = this.resolveAST(trinex.whenTrue, isContextuallyTyped, context).type; + var rightType = this.resolveAST(trinex.whenFalse, isContextuallyTyped, context).type; + + var expressionType = this.computeTypeOfConditionalExpression(leftType, rightType, isContextuallyTyped, context); + + var conditionalTypesAreValid = this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context); + + if (this.canTypeCheckAST(trinex, context)) { + this.setTypeChecked(trinex, context); + this.resolveAST(trinex.condition, false, context); + + if (!this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context)) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_2_or_3, [expressionType.toString(), leftType.toString(), rightType.toString(), contextualType.toString()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_or_2, [expressionType.toString(), leftType.toString(), rightType.toString()])); + } + } + } + + if (!conditionalTypesAreValid) { + return this.getNewErrorTypeSymbol(); + } + + return expressionType; + }; + + PullTypeResolver.prototype.conditionExpressionTypesAreValid = function (leftType, rightType, expressionType, isContextuallyTyped, context) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + if (this.typesAreIdentical(expressionType, leftType) || this.typesAreIdentical(expressionType, rightType) || this.typesAreIdentical(expressionType, contextualType)) { + return true; + } + } else { + if (this.typesAreIdentical(expressionType, leftType) || this.typesAreIdentical(expressionType, rightType)) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.resolveParenthesizedExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + } + + return this.resolveAST(ast.expression, false, context); + }; + + PullTypeResolver.prototype.resolveExpressionStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveInvocationExpression = function (callEx, context, additionalResults) { + var symbol = this.getSymbolForAST(callEx, context); + + if (!symbol || !symbol.isResolved) { + if (!additionalResults) { + additionalResults = new PullAdditionalCallResolutionData(); + } + symbol = this.computeInvocationExpressionSymbol(callEx, context, additionalResults); + if (this.canTypeCheckAST(callEx, context)) { + this.setTypeChecked(callEx, context); + } + if (symbol != this.semanticInfoChain.anyTypeSymbol) { + this.setSymbolForAST(callEx, symbol, context); + } + this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults); + } else { + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckInvocationExpression(callEx, context); + } + + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (additionalResults && (callResolutionData != additionalResults)) { + additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols; + additionalResults.candidateSignature = callResolutionData.candidateSignature; + additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures; + additionalResults.targetSymbol = callResolutionData.targetSymbol; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.typeCheckInvocationExpression = function (callEx, context) { + this.setTypeChecked(callEx, context); + var targetSymbol = this.resolveAST(callEx.expression, false, context); + + if (callEx.argumentList.arguments) { + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + + var len = callEx.argumentList.arguments.nonSeparatorCount(); + for (var i = 0; i < len; i++) { + var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null; + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) { + context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]); + } + }; + + PullTypeResolver.prototype.computeInvocationExpressionSymbol = function (callEx, context, additionalResults) { + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var targetAST = this.getCallTargetErrorSpanAST(callEx); + + var targetTypeSymbol = targetSymbol.type; + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + this.resolveAST(callEx.argumentList.arguments, false, context); + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + if (targetTypeSymbol === this.semanticInfoChain.anyTypeSymbol) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Untyped_function_calls_may_not_accept_type_arguments), additionalResults, context); + return this.getNewErrorTypeSymbol(); + } + } + + return this.semanticInfoChain.anyTypeSymbol; + } + + var isSuperCall = false; + + if (callEx.expression.kind() === 50 /* SuperKeyword */) { + isSuperCall = true; + + if (targetTypeSymbol.isClass()) { + targetSymbol = targetTypeSymbol.getConstructorMethod(); + this.resolveDeclaredSymbol(targetSymbol, context); + targetTypeSymbol = targetSymbol.type; + } else { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Calls_to_super_are_only_valid_inside_a_class), additionalResults, context); + this.resolveAST(callEx.argumentList.arguments, false, context); + + return this.getNewErrorTypeSymbol(); + } + } + + var signatures = isSuperCall ? targetTypeSymbol.getConstructSignatures() : targetTypeSymbol.getCallSignatures(); + + if (!signatures.length && (targetTypeSymbol.kind == 33554432 /* ConstructorType */)) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, [targetTypeSymbol.toString()]), additionalResults, context); + } + + var typeArgs = null; + var typeReplacementMap = null; + var couldNotFindGenericOverload = false; + var couldNotAssignToConstraint; + var constraintDiagnostic = null; + var typeArgumentCountDiagnostic = null; + var diagnostics = []; + + if (callEx.argumentList.typeArgumentList) { + typeArgs = []; + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + } + } + } else if (isSuperCall && targetTypeSymbol.isGeneric()) { + typeArgs = targetTypeSymbol.getTypeArguments(); + } + + var triedToInferTypeArgs = false; + + var resolvedSignatures = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters; + var typeConstraint = null; + var beforeResolutionSignatures = signatures; + var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < signatures.length; i++) { + typeParameters = signatures[i].getTypeParameters(); + couldNotAssignToConstraint = false; + + if (signatures[i].isGeneric() && typeParameters.length) { + if (typeArgs) { + if (typeArgs.length == typeParameters.length) { + inferredTypeArgs = typeArgs; + } else { + typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, typeArgs.length]); + continue; + } + } else if (!typeArgs && callEx.argumentList.arguments && callEx.argumentList.arguments.nonSeparatorCount()) { + inferredTypeArgs = this.inferArgumentTypesForSignature(signatures[i], new TypeScript.ArgumentInferenceContext(this, callEx.argumentList.arguments), new TypeComparisonInfo(), context); + triedToInferTypeArgs = true; + } else { + inferredTypeArgs = []; + } + + if (inferredTypeArgs) { + typeReplacementMap = []; + + if (inferredTypeArgs.length) { + if (inferredTypeArgs.length != typeParameters.length) { + continue; + } + + if (targetTypeReplacementMap) { + for (var symbolID in targetTypeReplacementMap) { + if (targetTypeReplacementMap.hasOwnProperty(symbolID)) { + typeReplacementMap[symbolID] = targetTypeReplacementMap[symbolID]; + } + } + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = inferredTypeArgs[j]; + } + for (var j = 0; j < typeParameters.length; j++) { + typeConstraint = typeParameters[j].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var k = 0; k < typeParameters.length && k < inferredTypeArgs.length; k++) { + if (typeParameters[k] == typeConstraint) { + typeConstraint = inferredTypeArgs[k]; + } else { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[j], typeConstraint, targetAST, context, null, true)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST); + constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]); + couldNotAssignToConstraint = true; + } + + if (couldNotAssignToConstraint) { + break; + } + } + } + } else { + if (triedToInferTypeArgs) { + continue; + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = this.semanticInfoChain.emptyTypeSymbol; + } + } + + if (couldNotAssignToConstraint) { + continue; + } + + specializedSignature = this.instantiateSignature(signatures[i], typeReplacementMap, true); + + if (specializedSignature) { + resolvedSignatures[resolvedSignatures.length] = specializedSignature; + } + } + } else { + if (!(callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) { + resolvedSignatures[resolvedSignatures.length] = signatures[i]; + } + } + } + + if (signatures.length && !resolvedSignatures.length) { + couldNotFindGenericOverload = true; + } + + signatures = resolvedSignatures; + + var errorCondition = null; + if (!signatures.length) { + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = beforeResolutionSignatures; + additionalResults.candidateSignature = beforeResolutionSignatures && beforeResolutionSignatures.length ? beforeResolutionSignatures[0] : null; + + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + this.resolveAST(callEx.argumentList.arguments, false, context); + + if (!couldNotFindGenericOverload) { + if (this.cachedFunctionInterfaceType() && this.sourceIsSubtypeOfTarget(targetTypeSymbol, this.cachedFunctionInterfaceType(), targetAST, context)) { + if (callEx.argumentList.typeArgumentList) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context); + } + return this.semanticInfoChain.anyTypeSymbol; + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature), additionalResults, context); + } else if (constraintDiagnostic) { + this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context); + } else if (typeArgumentCountDiagnostic) { + this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context); + } else { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context); + } + + return this.getNewErrorTypeSymbol(); + } + + var signature = this.resolveOverloads(callEx, signatures, callEx.argumentList.typeArgumentList != null, context, diagnostics); + var useBeforeResolutionSignatures = signature == null; + + if (!signature) { + for (var i = 0; i < diagnostics.length; i++) { + this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context); + + errorCondition = this.getNewErrorTypeSymbol(); + + if (!signatures.length) { + return errorCondition; + } + + signature = signatures[0]; + } + + if (!signature.isGeneric() && callEx.argumentList.typeArgumentList) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context); + } else if (signature.isGeneric() && callEx.argumentList.typeArgumentList && signature.getTypeParameters() && (callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount() != signature.getTypeParameters().length)) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [signature.getTypeParameters().length, callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()]), additionalResults, context); + } + + var returnType = isSuperCall ? this.semanticInfoChain.voidTypeSymbol : signature.returnType; + + var actualParametersContextTypeSymbols = []; + if (callEx.argumentList.arguments) { + var len = callEx.argumentList.arguments.nonSeparatorCount(); + var params = signature.parameters; + var contextualType = null; + var signatureDecl = signature.getDeclarations()[0]; + + for (var i = 0; i < len; i++) { + if (params.length) { + if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) { + this.resolveDeclaredSymbol(params[i], context); + contextualType = params[i].type; + } else if (signature.hasVarArgs) { + contextualType = params[params.length - 1].type; + if (contextualType.isArrayNamedTypeReference()) { + contextualType = contextualType.getElementType(); + } + } + } + + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + actualParametersContextTypeSymbols[i] = contextualType; + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + additionalResults.targetSymbol = targetSymbol; + if (useBeforeResolutionSignatures && beforeResolutionSignatures) { + additionalResults.resolvedSignatures = beforeResolutionSignatures; + additionalResults.candidateSignature = beforeResolutionSignatures[0]; + } else { + additionalResults.resolvedSignatures = signatures; + additionalResults.candidateSignature = signature; + } + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + if (errorCondition) { + return errorCondition; + } + + if (!returnType) { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + + return returnType; + }; + + PullTypeResolver.prototype.resolveObjectCreationExpression = function (callEx, context, additionalResults) { + var symbol = this.getSymbolForAST(callEx, context); + + if (!symbol || !symbol.isResolved) { + if (!additionalResults) { + additionalResults = new PullAdditionalCallResolutionData(); + } + symbol = this.computeObjectCreationExpressionSymbol(callEx, context, additionalResults); + if (this.canTypeCheckAST(callEx, context)) { + this.setTypeChecked(callEx, context); + } + this.setSymbolForAST(callEx, symbol, context); + this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults); + } else { + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckObjectCreationExpression(callEx, context); + } + + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (additionalResults && (callResolutionData != additionalResults)) { + additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols; + additionalResults.candidateSignature = callResolutionData.candidateSignature; + additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures; + additionalResults.targetSymbol = callResolutionData.targetSymbol; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.typeCheckObjectCreationExpression = function (callEx, context) { + this.setTypeChecked(callEx, context); + this.resolveAST(callEx.expression, false, context); + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (callEx.argumentList) { + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + var len = callEx.argumentList.arguments.nonSeparatorCount(); + + for (var i = 0; i < len; i++) { + var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null; + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) { + context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]); + } + }; + + PullTypeResolver.prototype.postOverloadResolutionDiagnostics = function (diagnostic, additionalResults, context) { + if (!context.inProvisionalResolution()) { + additionalResults.diagnosticsFromOverloadResolution.push(diagnostic); + } + context.postDiagnostic(diagnostic); + }; + + PullTypeResolver.prototype.computeObjectCreationExpressionSymbol = function (callEx, context, additionalResults) { + var returnType = null; + + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var targetTypeSymbol = targetSymbol.isType() ? targetSymbol : targetSymbol.type; + + var targetAST = this.getCallTargetErrorSpanAST(callEx); + + var constructSignatures = targetTypeSymbol.getConstructSignatures(); + + var typeArgs = null; + var typeReplacementMap = null; + var usedCallSignaturesInstead = false; + var couldNotAssignToConstraint; + var constraintDiagnostic = null; + var typeArgumentCountDiagnostic = null; + var diagnostics = []; + + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + if (callEx.argumentList) { + this.resolveAST(callEx.argumentList.arguments, false, context); + } + + return targetTypeSymbol; + } + + if (!constructSignatures.length) { + constructSignatures = targetTypeSymbol.getCallSignatures(); + usedCallSignaturesInstead = true; + + if (this.compilationSettings.noImplicitAny()) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type), additionalResults, context); + } + } + + if (constructSignatures.length) { + if (callEx.argumentList && callEx.argumentList.typeArgumentList) { + typeArgs = []; + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + } + } + } + + if (targetTypeSymbol.isGeneric()) { + var resolvedSignatures = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters; + var typeConstraint = null; + var triedToInferTypeArgs; + var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < constructSignatures.length; i++) { + couldNotAssignToConstraint = false; + + if (constructSignatures[i].isGeneric()) { + typeParameters = constructSignatures[i].getTypeParameters(); + + if (typeArgs) { + if (typeArgs.length == typeParameters.length) { + inferredTypeArgs = typeArgs; + } else { + typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, typeArgs.length]); + continue; + } + } else if (!typeArgs && callEx.argumentList && callEx.argumentList.arguments && callEx.argumentList.arguments.nonSeparatorCount()) { + inferredTypeArgs = this.inferArgumentTypesForSignature(constructSignatures[i], new TypeScript.ArgumentInferenceContext(this, callEx.argumentList.arguments), new TypeComparisonInfo(), context); + triedToInferTypeArgs = true; + } else { + inferredTypeArgs = []; + } + + if (inferredTypeArgs) { + typeReplacementMap = []; + + if (inferredTypeArgs.length) { + if (inferredTypeArgs.length < typeParameters.length) { + continue; + } + + if (targetTypeReplacementMap) { + for (var symbolID in targetTypeReplacementMap) { + if (targetTypeReplacementMap.hasOwnProperty(symbolID)) { + typeReplacementMap[symbolID] = targetTypeReplacementMap[symbolID]; + } + } + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = inferredTypeArgs[j]; + } + for (var j = 0; j < typeParameters.length; j++) { + typeConstraint = typeParameters[j].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var k = 0; k < typeParameters.length && k < inferredTypeArgs.length; k++) { + if (typeParameters[k] == typeConstraint) { + typeConstraint = inferredTypeArgs[k]; + } else { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[j], typeConstraint, targetAST, context, null, true)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST); + constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]); + couldNotAssignToConstraint = true; + } + + if (couldNotAssignToConstraint) { + break; + } + } + } + } else { + if (triedToInferTypeArgs) { + continue; + } else { + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = this.semanticInfoChain.emptyTypeSymbol; + } + } + } + + if (couldNotAssignToConstraint) { + continue; + } + + specializedSignature = this.instantiateSignature(constructSignatures[i], typeReplacementMap, true); + + if (specializedSignature) { + resolvedSignatures[resolvedSignatures.length] = specializedSignature; + } + } + } else { + if (!(callEx.argumentList && callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) { + resolvedSignatures[resolvedSignatures.length] = constructSignatures[i]; + } + } + } + + constructSignatures = resolvedSignatures; + } + + var signature = this.resolveOverloads(callEx, constructSignatures, callEx.argumentList && callEx.argumentList.typeArgumentList != null, context, diagnostics); + + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = constructSignatures; + additionalResults.candidateSignature = signature; + additionalResults.actualParametersContextTypeSymbols = []; + + if (!constructSignatures.length) { + if (constraintDiagnostic) { + this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context); + } else if (typeArgumentCountDiagnostic) { + this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context); + } + + return this.getNewErrorTypeSymbol(); + } + + var errorCondition = null; + + if (!signature) { + for (var i = 0; i < diagnostics.length; i++) { + this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_new_expression), additionalResults, context); + + errorCondition = this.getNewErrorTypeSymbol(); + + if (!constructSignatures.length) { + return errorCondition; + } + + signature = constructSignatures[0]; + } + + returnType = signature.returnType; + + if (returnType && !signature.isGeneric() && returnType.isGeneric() && !returnType.getIsSpecialized()) { + if (typeArgs && typeArgs.length) { + returnType = this.createInstantiatedType(returnType, typeArgs); + } else { + returnType = this.instantiateTypeToAny(returnType, context); + } + } + + if (usedCallSignaturesInstead) { + if (returnType != this.semanticInfoChain.voidTypeSymbol) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Call_signatures_used_in_a_new_expression_must_have_a_void_return_type), additionalResults, context); + + return this.getNewErrorTypeSymbol(); + } else { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + } + + if (!returnType) { + returnType = signature.returnType; + + if (!returnType) { + returnType = targetTypeSymbol; + } + } + + var actualParametersContextTypeSymbols = []; + if (callEx.argumentList && callEx.argumentList.arguments) { + var len = callEx.argumentList.arguments.nonSeparatorCount(); + var params = signature.parameters; + var contextualType = null; + var signatureDecl = signature.getDeclarations()[0]; + + for (var i = 0; i < len; i++) { + if (params.length) { + if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) { + this.resolveDeclaredSymbol(params[i], context); + contextualType = params[i].type; + } else if (signature.hasVarArgs) { + contextualType = params[params.length - 1].type; + if (contextualType.isArrayNamedTypeReference()) { + contextualType = contextualType.getElementType(); + } + } + } + + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + actualParametersContextTypeSymbols[i] = contextualType; + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = constructSignatures; + additionalResults.candidateSignature = signature; + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + if (errorCondition) { + return errorCondition; + } + + if (!returnType) { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + + return returnType; + } else if (callEx.argumentList) { + this.resolveAST(callEx.argumentList.arguments, false, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Invalid_new_expression), additionalResults, context); + + return this.getNewErrorTypeSymbol(); + }; + + PullTypeResolver.prototype.instantiateSignatureInContext = function (signatureA, signatureB, context) { + var typeReplacementMap = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters = signatureA.getTypeParameters(); + var typeConstraint = null; + + var fixedParameterTypes = []; + + for (var i = 0; i < signatureB.parameters.length; i++) { + fixedParameterTypes.push(signatureB.parameters[i].isVarArg ? signatureB.parameters[i].type.getElementType() : signatureB.parameters[i].type); + } + + inferredTypeArgs = this.inferArgumentTypesForSignature(signatureA, new TypeScript.ArgumentInferenceContext(this, fixedParameterTypes), new TypeComparisonInfo(), context); + + var functionTypeA = signatureA.functionType; + var functionTypeB = signatureB.functionType; + var enclosingTypeParameterMap; + + if (functionTypeA) { + enclosingTypeParameterMap = functionTypeA.getTypeParameterArgumentMap(); + + for (var id in enclosingTypeParameterMap) { + typeReplacementMap[id] = enclosingTypeParameterMap[id]; + } + } + + if (functionTypeB) { + enclosingTypeParameterMap = functionTypeB.getTypeParameterArgumentMap(); + + for (var id in enclosingTypeParameterMap) { + typeReplacementMap[id] = enclosingTypeParameterMap[id]; + } + } + + for (var i = 0; i < typeParameters.length; i++) { + typeReplacementMap[typeParameters[i].pullSymbolID] = inferredTypeArgs[i]; + } + for (var i = 0; i < typeParameters.length; i++) { + typeConstraint = typeParameters[i].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var j = 0; j < typeParameters.length && j < inferredTypeArgs.length; j++) { + if (typeParameters[j] == typeConstraint) { + typeConstraint = inferredTypeArgs[j]; + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[i], typeConstraint, null, context, null, true)) { + if (this.signaturesAreIdentical(signatureA, signatureB, true)) { + return signatureA; + } else { + return null; + } + } + } + } + + return this.instantiateSignature(signatureA, typeReplacementMap, true); + }; + + PullTypeResolver.prototype.resolveCastExpression = function (assertionExpression, context) { + var typeAssertionType = this.resolveTypeReference(assertionExpression.type, context).type; + + if (this.canTypeCheckAST(assertionExpression, context)) { + this.typeCheckCastExpression(assertionExpression, context, typeAssertionType); + } + + return typeAssertionType; + }; + + PullTypeResolver.prototype.typeCheckCastExpression = function (assertionExpression, context, typeAssertionType) { + this.setTypeChecked(assertionExpression, context); + + context.pushContextualType(typeAssertionType, context.inProvisionalResolution(), null); + var exprType = this.resolveAST(assertionExpression.expression, true, context).type; + context.popContextualType(); + + this.resolveDeclaredSymbol(typeAssertionType, context); + this.resolveDeclaredSymbol(exprType, context); + + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(typeAssertionType, exprType, assertionExpression, context, comparisonInfo) || this.sourceIsAssignableToTarget(exprType, typeAssertionType, assertionExpression, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(assertionExpression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.resolveAssignmentExpression = function (binaryExpression, context) { + var leftExpr = this.resolveAST(binaryExpression.left, false, context); + var leftType = leftExpr.type; + + context.pushContextualType(leftType, context.inProvisionalResolution(), null); + var rightType = this.resolveAST(binaryExpression.right, true, context).type; + context.popContextualType(); + + rightType = this.getInstanceTypeForAssignment(binaryExpression.left, rightType, context); + + if (this.canTypeCheckAST(binaryExpression, context)) { + this.setTypeChecked(binaryExpression, context); + + if (!this.isReference(binaryExpression.left, leftExpr)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } else { + this.checkAssignability(binaryExpression.left, rightType, leftExpr.type, context); + } + } + + return rightType; + }; + + PullTypeResolver.prototype.getInstanceTypeForAssignment = function (lhs, type, context) { + var typeToReturn = type; + if (typeToReturn && typeToReturn.isAlias()) { + typeToReturn = typeToReturn.getExportAssignedTypeSymbol(); + } + + if (typeToReturn && typeToReturn.isContainer() && !typeToReturn.isEnum()) { + var instanceTypeSymbol = typeToReturn.getInstanceType(); + + if (!instanceTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lhs, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [type.toString()])); + typeToReturn = null; + } else { + typeToReturn = instanceTypeSymbol; + } + } + + return typeToReturn; + }; + + PullTypeResolver.prototype.widenType = function (type, ast, context) { + if (type === this.semanticInfoChain.undefinedTypeSymbol || type === this.semanticInfoChain.nullTypeSymbol || type.isError()) { + return this.semanticInfoChain.anyTypeSymbol; + } + + if (type.isArrayNamedTypeReference()) { + var elementType = this.widenType(type.getElementType(), null, context); + + if (this.compilationSettings.noImplicitAny() && ast && ast.kind() === 214 /* ArrayLiteralExpression */) { + if (elementType === this.semanticInfoChain.anyTypeSymbol && type.getElementType() !== this.semanticInfoChain.anyTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Array_Literal_implicitly_has_an_any_type_from_widening)); + } + } + + var arraySymbol = elementType.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + } + + return arraySymbol; + } + + return type; + }; + + PullTypeResolver.prototype.findBestCommonType = function (collection, context, comparisonInfo) { + var len = collection.getLength(); + + for (var i = 0; i < len; i++) { + var candidateType = collection.getTypeAtIndex(i); + if (this.typeIsBestCommonTypeCandidate(candidateType, collection, context)) { + return candidateType; + } + } + + return this.semanticInfoChain.emptyTypeSymbol; + }; + + PullTypeResolver.prototype.typeIsBestCommonTypeCandidate = function (candidateType, collection, context) { + for (var i = 0; i < collection.getLength(); i++) { + var otherType = collection.getTypeAtIndex(i); + if (candidateType == otherType) { + continue; + } + + if (candidateType.isTypeParameter() && !otherType.isTypeParameter()) { + return false; + } else if (!candidateType.isTypeParameter() && otherType.isTypeParameter()) { + continue; + } else if (!this.sourceIsSubtypeOfTarget(otherType, candidateType, null, context)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.typesAreIdenticalInEnclosingTypes = function (t1, t2, t1EnclosingType, t2EnclosingType, val) { + t1 = this.getSymbolForRelationshipCheck(t1); + t2 = this.getSymbolForRelationshipCheck(t2); + + if (t1 === t2) { + return true; + } + + if (t1 && t2) { + var t1GenerativeTypeKind = t1EnclosingType ? t1.getGenerativeTypeClassification(t1EnclosingType) : 0 /* Unknown */; + var t2GenerativeTypeKind = t2EnclosingType ? t2.getGenerativeTypeClassification(t2EnclosingType) : 0 /* Unknown */; + if (t1GenerativeTypeKind == 3 /* InfinitelyExpanding */ || t2GenerativeTypeKind == 3 /* InfinitelyExpanding */) { + return this.infinitelyExpandingTypesAreIdentical(t1, t2); + } + } + + return this.typesAreIdentical(t1, t2, val); + }; + + PullTypeResolver.prototype.typesAreIdentical = function (t1, t2, val) { + t1 = this.getSymbolForRelationshipCheck(t1); + t2 = this.getSymbolForRelationshipCheck(t2); + + if (t1 === t2) { + return true; + } + + if (!t1 || !t2) { + return false; + } + + if (val && t1.isPrimitive() && t1.isStringConstant() && t2 === this.semanticInfoChain.stringTypeSymbol) { + return (val.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(val.text()) === TypeScript.stripStartAndEndQuotes(t1.name)); + } + + if (val && t2.isPrimitive() && t2.isStringConstant() && t2 === this.semanticInfoChain.stringTypeSymbol) { + return (val.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(val.text()) === TypeScript.stripStartAndEndQuotes(t2.name)); + } + + if (t1.isPrimitive() && t1.isStringConstant() && t2.isPrimitive() && t2.isStringConstant()) { + return TypeScript.stripStartAndEndQuotes(t1.name) === TypeScript.stripStartAndEndQuotes(t2.name); + } + + if (t1.isPrimitive() || t2.isPrimitive()) { + return false; + } + + if (t1.isError() && t2.isError()) { + return true; + } + + if (t1.isTypeParameter() != t2.isTypeParameter()) { + return false; + } else if (t1.isTypeParameter()) { + var t1ParentDeclaration = t1.getDeclarations()[0].getParentDecl(); + var t2ParentDeclaration = t2.getDeclarations()[0].getParentDecl(); + + if (t1ParentDeclaration === t2ParentDeclaration) { + return this.symbolsShareDeclaration(t1, t2); + } else { + return false; + } + } + + var isIdentical = this.identicalCache.valueAt(t1.pullSymbolID, t2.pullSymbolID); + if (isIdentical != undefined) { + return isIdentical; + } + + if ((t1.kind & 64 /* Enum */) || (t2.kind & 64 /* Enum */)) { + return t1.getAssociatedContainerType() === t2 || t2.getAssociatedContainerType() === t1; + } + + if (t1.isPrimitive() != t2.isPrimitive()) { + return false; + } + + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, false); + + if (t1.hasMembers() && t2.hasMembers()) { + var t1Members = t1.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + var t2Members = t2.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + if (t1Members.length != t2Members.length) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + var t1MemberSymbol = null; + var t2MemberSymbol = null; + + var t1MemberType = null; + var t2MemberType = null; + + for (var iMember = 0; iMember < t1Members.length; iMember++) { + t1MemberSymbol = t1Members[iMember]; + t2MemberSymbol = this.getMemberSymbol(t1MemberSymbol.name, 68147712 /* SomeValue */, t2); + + if (!t2MemberSymbol || (t1MemberSymbol.isOptional != t2MemberSymbol.isOptional)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + t1MemberType = t1MemberSymbol.type; + t2MemberType = t2MemberSymbol.type; + + if (!this.typesAreIdenticalInEnclosingTypes(t1MemberType, t2MemberType, t1, t2)) { + return false; + } + } + } else if (t1.hasMembers() || t2.hasMembers()) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + var t1CallSigs = t1.getCallSignatures(); + var t2CallSigs = t2.getCallSignatures(); + + var t1ConstructSigs = t1.getConstructSignatures(); + var t2ConstructSigs = t2.getConstructSignatures(); + + var t1IndexSigs = t1.getIndexSignatures(); + var t2IndexSigs = t2.getIndexSignatures(); + + if (!this.signatureGroupsAreIdentical(t1CallSigs, t2CallSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + if (!this.signatureGroupsAreIdentical(t1ConstructSigs, t2ConstructSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + if (!this.signatureGroupsAreIdentical(t1IndexSigs, t2IndexSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.signatureGroupsAreIdentical = function (sg1, sg2) { + if (sg1 === sg2) { + return true; + } + + if (!sg1 || !sg2) { + return false; + } + + if (sg1.length != sg2.length) { + return false; + } + + var sig1 = null; + var sig2 = null; + var sigsMatch = false; + + for (var iSig1 = 0; iSig1 < sg1.length; iSig1++) { + sig1 = sg1[iSig1]; + + for (var iSig2 = 0; iSig2 < sg2.length; iSig2++) { + sig2 = sg2[iSig2]; + + if (this.signaturesAreIdentical(sig1, sig2)) { + sigsMatch = true; + break; + } + } + + if (sigsMatch) { + sigsMatch = false; + continue; + } + + return false; + } + + return true; + }; + + PullTypeResolver.prototype.signaturesAreIdentical = function (s1, s2, includingReturnType) { + if (typeof includingReturnType === "undefined") { includingReturnType = true; } + if (s1 === s2) { + return true; + } + + if (s1.hasVarArgs != s2.hasVarArgs) { + return false; + } + + if (s1.nonOptionalParamCount != s2.nonOptionalParamCount) { + return false; + } + + if (!!(s1.typeParameters && s1.typeParameters.length) != !!(s2.typeParameters && s2.typeParameters.length)) { + return false; + } + + if (s1.typeParameters && s2.typeParameters && (s1.typeParameters.length != s2.typeParameters.length)) { + return false; + } + + if (s1.parameters.length != s2.parameters.length) { + return false; + } + + this.resolveDeclaredSymbol(s1); + this.resolveDeclaredSymbol(s2); + + var s1Params = s1.parameters; + var s2Params = s2.parameters; + + if (includingReturnType && !this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, s1.functionType, s2.functionType)) { + return false; + } + + for (var iParam = 0; iParam < s1Params.length; iParam++) { + if (!this.typesAreIdenticalInEnclosingTypes(s1Params[iParam].type, s2Params[iParam].type, s1.functionType, s2.functionType)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.substituteUpperBoundForType = function (type) { + if (!type || !type.isTypeParameter()) { + return type; + } + + var constraint = type.getConstraint(); + + if (constraint && (constraint != type)) { + return this.substituteUpperBoundForType(constraint); + } + + return type; + }; + + PullTypeResolver.prototype.symbolsShareDeclaration = function (symbol1, symbol2) { + var decls1 = symbol1.getDeclarations(); + var decls2 = symbol2.getDeclarations(); + + if (decls1.length && decls2.length) { + return decls1[0].isEqual(decls2[0]); + } + + return false; + }; + + PullTypeResolver.prototype.sourceExtendsTarget = function (source, target, context) { + if (source.isGeneric() != target.isGeneric()) { + return false; + } + + if (source.isTypeReference() && target.isTypeReference()) { + if (source.referencedTypeSymbol.hasBase(target.referencedTypeSymbol)) { + var sourceTypeArguments = source.getTypeArguments(); + var targetTypeArguments = target.getTypeArguments(); + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + return false; + } + + for (var i = 0; i < targetTypeArguments.length; i++) { + if (!this.sourceExtendsTarget(sourceTypeArguments[i], targetTypeArguments[i], context)) { + return false; + } + } + + return true; + } + } + + if (source.hasBase(target)) { + return true; + } + + if (context.isInBaseTypeResolution() && (source.kind & (16 /* Interface */ | 8 /* Class */)) && (target.kind & (16 /* Interface */ | 8 /* Class */))) { + var sourceDecls = source.getDeclarations(); + var extendsSymbol = null; + + for (var i = 0; i < sourceDecls.length; i++) { + var sourceAST = this.semanticInfoChain.getASTForDecl(sourceDecls[i]); + var extendsClause = TypeScript.getExtendsHeritageClause(sourceAST.heritageClauses); + + if (extendsClause) { + for (var j = 0; j < extendsClause.typeNames.nonSeparatorCount(); j++) { + extendsSymbol = this.semanticInfoChain.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(j)); + + if (extendsSymbol && (extendsSymbol == target || this.sourceExtendsTarget(extendsSymbol, target, context))) { + return true; + } + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.sourceIsSubtypeOfTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIsRelatableToTarget(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceMembersAreSubtypeOfTargetMembers = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceMembersAreRelatableToTargetMembers(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourcePropertyIsSubtypeOfTargetProperty = function (source, target, sourceProp, targetProp, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceCallSignaturesAreSubtypeOfTargetCallSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceCallSignaturesAreRelatableToTargetCallSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.typeIsSubtypeOfFunction = function (source, ast, context) { + if (source.getCallSignatures().length || source.getConstructSignatures().length) { + return true; + } + + return this.cachedFunctionInterfaceType() && this.sourceIsSubtypeOfTarget(source, this.cachedFunctionInterfaceType(), ast, context); + }; + + PullTypeResolver.prototype.signatureIsSubtypeOfTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.signatureIsRelatableToTarget(s1, s2, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIsAssignableToTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIsRelatableToTarget(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.signatureIsAssignableToTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.signatureIsRelatableToTarget(s1, s2, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.getSymbolForRelationshipCheck = function (symbol) { + if (symbol && symbol.isTypeReference()) { + return symbol.getReferencedTypeSymbol(); + } + + return symbol; + }; + + PullTypeResolver.prototype.sourceIsRelatableToTargetInEnclosingTypes = function (source, target, sourceEnclosingType, targetEnclosingType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + source = this.getSymbolForRelationshipCheck(source); + target = this.getSymbolForRelationshipCheck(target); + + if (source === target) { + return true; + } + + if (source && target) { + var sourceGenerativeTypeKind = sourceEnclosingType ? source.getGenerativeTypeClassification(sourceEnclosingType) : 0 /* Unknown */; + var targetGenerativeTypeKind = targetEnclosingType ? target.getGenerativeTypeClassification(targetEnclosingType) : 0 /* Unknown */; + if (sourceGenerativeTypeKind == 3 /* InfinitelyExpanding */ || targetGenerativeTypeKind == 3 /* InfinitelyExpanding */) { + return this.infinitelyExpandingSourceTypeIsRelatableToTargetType(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + } + } + + return this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIsRelatableToTarget = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + source = this.getSymbolForRelationshipCheck(source); + target = this.getSymbolForRelationshipCheck(target); + + if (source === target) { + return true; + } + + if (!(source && target)) { + return true; + } + + var sourceSubstitution = source; + + if (source == this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedStringInterfaceType(), context); + sourceSubstitution = this.cachedStringInterfaceType(); + } else if (source == this.semanticInfoChain.numberTypeSymbol && this.cachedNumberInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedNumberInterfaceType(), context); + sourceSubstitution = this.cachedNumberInterfaceType(); + } else if (source == this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedBooleanInterfaceType(), context); + sourceSubstitution = this.cachedBooleanInterfaceType(); + } else if (TypeScript.PullHelpers.symbolIsEnum(source) && this.cachedNumberInterfaceType()) { + sourceSubstitution = this.cachedNumberInterfaceType(); + } else if (source.isTypeParameter()) { + sourceSubstitution = this.substituteUpperBoundForType(source); + } + + if (comparisonCache.valueAt(source.pullSymbolID, target.pullSymbolID) != undefined) { + return true; + } + + if (source === this.semanticInfoChain.stringTypeSymbol && target.isPrimitive() && target.isStringConstant()) { + return comparisonInfo && comparisonInfo.stringConstantVal && (comparisonInfo.stringConstantVal.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(comparisonInfo.stringConstantVal.text()) === TypeScript.stripStartAndEndQuotes(target.name)); + } + + if (assignableTo) { + if (this.isAnyOrEquivalent(source) || this.isAnyOrEquivalent(target)) { + return true; + } + } else { + if (this.isAnyOrEquivalent(target)) { + return true; + } + + if (target === this.semanticInfoChain.stringTypeSymbol && source.isPrimitive() && source.isStringConstant()) { + return true; + } + } + + if (source.isPrimitive() && source.isStringConstant() && target.isPrimitive() && target.isStringConstant()) { + return TypeScript.stripStartAndEndQuotes(source.name) === TypeScript.stripStartAndEndQuotes(target.name); + } + + if (source === this.semanticInfoChain.undefinedTypeSymbol) { + return true; + } + + if ((source === this.semanticInfoChain.nullTypeSymbol) && (target != this.semanticInfoChain.undefinedTypeSymbol && target != this.semanticInfoChain.voidTypeSymbol)) { + return true; + } + + if (target == this.semanticInfoChain.voidTypeSymbol) { + if (source == this.semanticInfoChain.undefinedTypeSymbol || source == this.semanticInfoChain.nullTypeSymbol) { + return true; + } + + return false; + } else if (source == this.semanticInfoChain.voidTypeSymbol) { + if (target == this.semanticInfoChain.anyTypeSymbol) { + return true; + } + + return false; + } + + if (target === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(source)) { + return true; + } + + if (source === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(target)) { + return assignableTo; + } + + if (TypeScript.PullHelpers.symbolIsEnum(target) && TypeScript.PullHelpers.symbolIsEnum(source)) { + return this.symbolsShareDeclaration(target, source); + } + + if ((source.kind & 64 /* Enum */) || (target.kind & 64 /* Enum */)) { + return false; + } + + if (source.getIsSpecialized() && target.getIsSpecialized()) { + if (TypeScript.PullHelpers.getRootType(source) == TypeScript.PullHelpers.getRootType(target)) { + var sourceTypeArguments = source.getTypeArguments(); + var targetTypeArguments = target.getTypeArguments(); + + if (sourceTypeArguments && targetTypeArguments) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, false); + + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.sourceIsRelatableToTarget(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + break; + } + } + + if (i == sourceTypeArguments.length) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true); + return true; + } else { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + } + } + } + } + + if (sourceSubstitution.isPrimitive() || target.isPrimitive()) { + return false; + } + + if (target.isTypeParameter()) { + if (source.isTypeParameter() && (source === sourceSubstitution)) { + return this.typesAreIdentical(target, source); + } else { + if (isComparingInstantiatedSignatures) { + target = this.substituteUpperBoundForType(target); + } else { + return this.typesAreIdentical(target, sourceSubstitution); + } + } + } + + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, false); + + if ((source.kind & 8216 /* SomeInstantiatableType */) && (target.kind & 8216 /* SomeInstantiatableType */) && this.sourceExtendsTarget(source, target, context)) { + return true; + } + + if (this.cachedObjectInterfaceType() && target === this.cachedObjectInterfaceType()) { + return true; + } + + if (this.cachedFunctionInterfaceType() && (sourceSubstitution.getCallSignatures().length || sourceSubstitution.getConstructSignatures().length) && target.hasBase(this.cachedFunctionInterfaceType())) { + return true; + } + + if (target.hasMembers() && !this.sourceMembersAreRelatableToTargetMembers(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceCallSignaturesAreRelatableToTargetCallSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.sourceMembersAreRelatableToTargetMembers = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetProps = target.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + for (var itargetProp = 0; itargetProp < targetProps.length; itargetProp++) { + var targetProp = targetProps[itargetProp]; + var sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, source); + + this.resolveDeclaredSymbol(targetProp, context); + + var targetPropType = targetProp.type; + + if (sourceProp && sourceProp.anyDeclHasFlag(16 /* Static */) && source.isClass()) { + sourceProp = null; + } + + if (!sourceProp) { + if (this.cachedObjectInterfaceType()) { + sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, this.cachedObjectInterfaceType()); + } + + if (!sourceProp) { + if (this.cachedFunctionInterfaceType() && (targetPropType.getCallSignatures().length || targetPropType.getConstructSignatures().length)) { + sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, this.cachedFunctionInterfaceType()); + } + + if (!sourceProp) { + if (!(targetProp.isOptional)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_is_missing_property_1_from_type_2, [source.toString(enclosingSymbol), targetProp.getScopedNameEx().toString(), target.toString(enclosingSymbol)])); + } + return false; + } + continue; + } + } + } + + if (!this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.infinitelyExpandingSourceTypeIsRelatableToTargetType = function (sourceType, targetType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var widenedTargetType = this.widenType(targetType); + var widenedSourceType = this.widenType(sourceType); + + if ((widenedSourceType != this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType != this.semanticInfoChain.anyTypeSymbol)) { + var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType); + var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType); + + if (sourceTypeNamedTypeReference != targetTypeNamedTypeReference) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_do_not_refer_to_same_named_type, [sourceType.getScopedNameEx(enclosingSymbol).toString(), targetType.toString(enclosingSymbol)])); + } + return false; + } + + var sourceTypeArguments = sourceType.getTypeArguments(); + var targetTypeArguments = targetType.getTypeArguments(); + + if (!sourceTypeArguments && !targetTypeArguments) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + } + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)])); + } + return false; + } + + var comparisonInfoTypeArgumentsCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoTypeArgumentsCheck = new TypeComparisonInfo(comparisonInfo); + } + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.sourceIsRelatableToTarget(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + + if (comparisonInfoTypeArgumentsCheck && comparisonInfoTypeArgumentsCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol), comparisonInfoTypeArgumentsCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(message); + } + } + } + } + + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.infinitelyExpandingTypesAreIdentical = function (sourceType, targetType) { + var widenedTargetType = this.widenType(targetType); + var widenedSourceType = this.widenType(sourceType); + + if ((widenedSourceType != this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType != this.semanticInfoChain.anyTypeSymbol)) { + var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType); + var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType); + if (sourceTypeNamedTypeReference != targetTypeNamedTypeReference) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + + var sourceTypeArguments = sourceType.getTypeArguments(); + var targetTypeArguments = targetType.getTypeArguments(); + + if (!sourceTypeArguments && !targetTypeArguments) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + } + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.typesAreIdentical(sourceTypeArguments[i], targetTypeArguments[i])) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + } + } + + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.sourcePropertyIsRelatableToTargetProperty = function (source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetPropIsPrivate = targetProp.anyDeclHasFlag(2 /* Private */); + var sourcePropIsPrivate = sourceProp.anyDeclHasFlag(2 /* Private */); + + if (targetPropIsPrivate != sourcePropIsPrivate) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (targetPropIsPrivate) { + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2, [targetProp.getScopedNameEx().toString(), sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol)])); + } else { + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2, [targetProp.getScopedNameEx().toString(), sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol)])); + } + comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */; + } + return false; + } else if (sourcePropIsPrivate && targetPropIsPrivate) { + var targetDecl = targetProp.getDeclarations()[0]; + var sourceDecl = sourceProp.getDeclarations()[0]; + + if (!targetDecl.isEqual(sourceDecl)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + + comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_define_property_2_as_private, [sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol), targetProp.getScopedNameEx().toString()])); + } + + return false; + } + } + + this.resolveDeclaredSymbol(sourceProp, context); + + var sourcePropType = sourceProp.type; + var targetPropType = targetProp.type; + + if (comparisonCache.valueAt(sourcePropType.pullSymbolID, targetPropType.pullSymbolID)) { + return true; + } + + var comparisonInfoPropertyTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoPropertyTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + if (this.sourceIsRelatableToTargetInEnclosingTypes(sourcePropType, targetPropType, source, target, assignableTo, comparisonCache, ast, context, comparisonInfoPropertyTypeCheck, isComparingInstantiatedSignatures)) { + return true; + } + + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.flags |= 32 /* IncompatiblePropertyTypes */; + var message; + if (comparisonInfoPropertyTypeCheck && comparisonInfoPropertyTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3, [targetProp.getScopedNameEx().toString(), source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoPropertyTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible, [targetProp.getScopedNameEx().toString(), source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(message); + } + + return false; + }; + + PullTypeResolver.prototype.sourceCallSignaturesAreRelatableToTargetCallSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetCallSigs = target.getCallSignatures(); + + if (targetCallSigs.length) { + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + var sourceCallSigs = source.getCallSignatures(); + if (!this.signatureGroupIsRelatableToTarget(sourceCallSigs, targetCallSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (sourceCallSigs.length && targetCallSigs.length) { + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + } else { + var hasSig = targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + var lacksSig = !targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_call_signature_but_type_1_lacks_one, [hasSig, lacksSig]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.sourceConstructSignaturesAreRelatableToTargetConstructSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetConstructSigs = target.getConstructSignatures(); + if (targetConstructSigs.length) { + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + var sourceConstructSigs = source.getConstructSignatures(); + if (!this.signatureGroupIsRelatableToTarget(sourceConstructSigs, targetConstructSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + var message; + if (sourceConstructSigs.length && targetConstructSigs.length) { + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + } else { + var hasSig = targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + var lacksSig = !targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_construct_signature_but_type_1_lacks_one, [hasSig, lacksSig]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.sourceIndexSignaturesAreRelatableToTargetIndexSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetIndexSigs = this.getBothKindsOfIndexSignatures(target, context); + var targetStringSig = targetIndexSigs.stringSignature; + var targetNumberSig = targetIndexSigs.numericSignature; + + if (targetStringSig || targetNumberSig) { + var sourceIndexSigs = this.getBothKindsOfIndexSignatures(source, context); + var sourceStringSig = sourceIndexSigs.stringSignature; + var sourceNumberSig = sourceIndexSigs.numericSignature; + + var comparable = true; + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + if (targetStringSig) { + if (sourceStringSig) { + comparable = this.signatureIsAssignableToTarget(sourceStringSig, targetStringSig, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures); + } else { + comparable = false; + } + } + + if (comparable && targetNumberSig) { + if (sourceNumberSig) { + comparable = this.signatureIsAssignableToTarget(sourceNumberSig, targetNumberSig, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures); + } else if (sourceStringSig) { + comparable = this.sourceIsAssignableToTarget(sourceStringSig.returnType, targetNumberSig.returnType, ast, context, comparisonInfoSignatuesTypeCheck); + } else { + comparable = false; + } + } + + if (!comparable) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.signatureGroupIsRelatableToTarget = function (sourceSG, targetSG, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + if (sourceSG === targetSG) { + return true; + } + + if (!(sourceSG.length && targetSG.length)) { + return false; + } + + var mSig = null; + var nSig = null; + var foundMatch = false; + + var targetExcludeDefinition = targetSG.length > 1; + var sourceExcludeDefinition = sourceSG.length > 1; + for (var iMSig = 0; iMSig < targetSG.length; iMSig++) { + mSig = targetSG[iMSig]; + + if (mSig.isStringConstantOverloadSignature() || (targetExcludeDefinition && mSig.isDefinition())) { + continue; + } + + for (var iNSig = 0; iNSig < sourceSG.length; iNSig++) { + nSig = sourceSG[iNSig]; + + if (nSig.isStringConstantOverloadSignature() || (sourceExcludeDefinition && nSig.isDefinition())) { + continue; + } + + if (this.signatureIsRelatableToTarget(nSig, mSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + foundMatch = true; + break; + } + } + + if (foundMatch) { + foundMatch = false; + continue; + } + return false; + } + + return true; + }; + + PullTypeResolver.prototype.signatureIsRelatableToTarget = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var sourceParameters = sourceSig.parameters; + var targetParameters = targetSig.parameters; + + if (!sourceParameters || !targetParameters) { + return false; + } + + var targetVarArgCount = targetSig.nonOptionalParamCount; + var sourceVarArgCount = sourceSig.nonOptionalParamCount; + + if (sourceVarArgCount > targetVarArgCount) { + if (comparisonInfo) { + comparisonInfo.flags |= 3 /* SourceSignatureHasTooManyParameters */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signature_expects_0_or_fewer_parameters, [targetVarArgCount])); + } + return false; + } + + if (sourceSig.isGeneric()) { + sourceSig = this.instantiateSignatureInContext(sourceSig, targetSig, context); + + if (!sourceSig) { + return false; + } else { + sourceParameters = sourceSig.parameters; + } + } + + comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, false); + + var sourceReturnType = sourceSig.returnType; + var targetReturnType = targetSig.returnType; + + if (targetReturnType != this.semanticInfoChain.voidTypeSymbol) { + if (!this.sourceIsRelatableToTargetInEnclosingTypes(sourceReturnType, targetReturnType, sourceSig.functionType, targetSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + comparisonInfo.flags |= 16 /* IncompatibleReturnTypes */; + } + + return false; + } + } + + var len = (sourceVarArgCount < targetVarArgCount && (sourceSig.hasVarArgs || (sourceParameters.length > sourceVarArgCount))) ? targetVarArgCount : sourceVarArgCount; + + if (!len) { + len = (sourceParameters.length < targetParameters.length) ? sourceParameters.length : targetParameters.length; + } + + var sourceParamType = null; + var targetParamType = null; + var sourceParamName = ""; + var targetParamName = ""; + + for (var iSource = 0, iTarget = 0; iSource < len; iSource++, iTarget++) { + if (iSource < sourceParameters.length && (!sourceSig.hasVarArgs || iSource < sourceVarArgCount)) { + sourceParamType = sourceParameters[iSource].type; + sourceParamName = sourceParameters[iSource].name; + } else if (iSource === sourceVarArgCount) { + sourceParamType = sourceParameters[iSource].type; + if (sourceParamType.isArrayNamedTypeReference()) { + sourceParamType = sourceParamType.getElementType(); + } + sourceParamName = sourceParameters[iSource].name; + } + + if (iTarget < targetParameters.length && !targetSig.hasVarArgs && (!targetVarArgCount || (iTarget < targetVarArgCount))) { + targetParamType = targetParameters[iTarget].type; + targetParamName = targetParameters[iTarget].name; + } else if (targetSig.hasVarArgs && iTarget === targetVarArgCount) { + targetParamType = targetParameters[iTarget].type; + + if (targetParamType.isArrayNamedTypeReference()) { + targetParamType = targetParamType.getElementType(); + } + targetParamName = targetParameters[iTarget].name; + } + + if (!(this.sourceIsRelatableToTargetInEnclosingTypes(sourceParamType, targetParamType, sourceSig.functionType, targetSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) || this.sourceIsRelatableToTargetInEnclosingTypes(targetParamType, sourceParamType, targetSig.functionType, sourceSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures))) { + if (comparisonInfo) { + comparisonInfo.flags |= 64 /* IncompatibleParameterTypes */; + } + + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.resolveOverloads = function (application, group, haveTypeArgumentsAtCallSite, context, diagnostics) { + var _this = this; + var hasOverloads = group.length > 1; + var comparisonInfo = new TypeComparisonInfo(); + var args = application.argumentList ? application.argumentList.arguments : null; + + var initialCandidates = TypeScript.ArrayUtilities.where(group, function (signature) { + if (hasOverloads && signature.isDefinition()) { + return false; + } + + if (haveTypeArgumentsAtCallSite && !signature.isGeneric()) { + return false; + } + + return _this.overloadHasCorrectArity(signature, args); + }); + + var firstAssignableButNotSupertypeSignature = null; + var firstAssignableWithProvisionalErrorsSignature = null; + + for (var i = 0; i < initialCandidates.length; i++) { + var applicability = this.overloadIsApplicable(initialCandidates[i], args, context, comparisonInfo); + if (applicability === 3 /* Subtype */) { + return initialCandidates[i]; + } else if (applicability === 2 /* AssignableWithNoProvisionalErrors */ && !firstAssignableButNotSupertypeSignature) { + firstAssignableButNotSupertypeSignature = initialCandidates[i]; + } else if (applicability === 1 /* AssignableButWithProvisionalErrors */ && !firstAssignableWithProvisionalErrorsSignature) { + firstAssignableWithProvisionalErrorsSignature = initialCandidates[i]; + } + } + + if (firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature) { + return firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature; + } else { + var target = this.getCallTargetErrorSpanAST(application); + if (comparisonInfo.message) { + diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0, [comparisonInfo.message])); + } else { + diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target, null)); + } + } + + return null; + }; + + PullTypeResolver.prototype.getCallTargetErrorSpanAST = function (callEx) { + return (callEx.expression.kind() === 212 /* MemberAccessExpression */) ? callEx.expression.name : callEx.expression; + }; + + PullTypeResolver.prototype.overloadHasCorrectArity = function (signature, args) { + if (args == null) { + return signature.nonOptionalParamCount === 0; + } + + var numberOfArgs = (args.nonSeparatorCount() && args.nonSeparatorCount() === args.separatorCount()) ? args.separatorCount() + 1 : args.nonSeparatorCount(); + if (numberOfArgs < signature.nonOptionalParamCount) { + return false; + } + if (!signature.hasVarArgs && numberOfArgs > signature.parameters.length) { + return false; + } + + return true; + }; + + PullTypeResolver.prototype.overloadIsApplicable = function (signature, args, context, comparisonInfo) { + if (args === null) { + return 3 /* Subtype */; + } + + var isInVarArg = false; + var parameters = signature.parameters; + var paramType = null; + + var overloadApplicability = 3 /* Subtype */; + + for (var i = 0; i < args.nonSeparatorCount(); i++) { + if (!isInVarArg) { + this.resolveDeclaredSymbol(parameters[i], context); + + if (parameters[i].isVarArg) { + paramType = parameters[i].type.getElementType() || this.getNewErrorTypeSymbol(parameters[i].type.getName()); + isInVarArg = true; + } else { + paramType = parameters[i].type; + } + } + + var statusOfCurrentArgument = this.overloadIsApplicableForArgument(paramType, args.nonSeparatorAt(i), i, context, comparisonInfo); + + if (statusOfCurrentArgument === 0 /* NotAssignable */) { + return 0 /* NotAssignable */; + } else if (statusOfCurrentArgument === 1 /* AssignableButWithProvisionalErrors */) { + overloadApplicability = 1 /* AssignableButWithProvisionalErrors */; + } else if (overloadApplicability !== 1 /* AssignableButWithProvisionalErrors */ && statusOfCurrentArgument === 2 /* AssignableWithNoProvisionalErrors */) { + overloadApplicability = 2 /* AssignableWithNoProvisionalErrors */; + } + } + + return overloadApplicability; + }; + + PullTypeResolver.prototype.overloadIsApplicableForArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (paramType.isAny()) { + return 3 /* Subtype */; + } else if (paramType.isError()) { + return 1 /* AssignableButWithProvisionalErrors */; + } else if (arg.kind() === 219 /* SimpleArrowFunctionExpression */) { + var simpleArrowFunction = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, null, TypeScript.Parameters.fromIdentifier(simpleArrowFunction.identifier), null, simpleArrowFunction.block, simpleArrowFunction.expression, argIndex, context, comparisonInfo); + } else if (arg.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + var arrowFunction = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, arrowFunction.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(arrowFunction.callSignature.parameterList), TypeScript.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, argIndex, context, comparisonInfo); + } else if (arg.kind() === 222 /* FunctionExpression */) { + var functionExpression = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, functionExpression.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(functionExpression.callSignature.parameterList), TypeScript.getType(functionExpression), functionExpression.block, null, argIndex, context, comparisonInfo); + } else if (arg.kind() === 215 /* ObjectLiteralExpression */) { + return this.overloadIsApplicableForObjectLiteralArgument(paramType, arg, argIndex, context, comparisonInfo); + } else if (arg.kind() === 214 /* ArrayLiteralExpression */) { + return this.overloadIsApplicableForArrayLiteralArgument(paramType, arg, argIndex, context, comparisonInfo); + } else { + return this.overloadIsApplicableForOtherArgument(paramType, arg, argIndex, context, comparisonInfo); + } + }; + + PullTypeResolver.prototype.overloadIsApplicableForAnyFunctionExpressionArgument = function (paramType, arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, argIndex, context, comparisonInfo) { + if (this.cachedFunctionInterfaceType() && paramType === this.cachedFunctionInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + + var argSym = this.resolveAnyFunctionExpression(arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForObjectLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (this.cachedObjectInterfaceType() && paramType === this.cachedObjectInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + var argSym = this.resolveObjectLiteralExpression(arg, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForArrayLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (paramType === this.cachedArrayInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + var argSym = this.resolveArrayLiteralExpression(arg, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForOtherArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + var argSym = this.resolveAST(arg, false, context); + + if (argSym.type.isAlias()) { + var aliasSym = argSym.type; + argSym = aliasSym.getExportAssignedTypeSymbol(); + } + + comparisonInfo.stringConstantVal = arg; + return this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + }; + + PullTypeResolver.prototype.overloadIsApplicableForArgumentHelper = function (paramType, argSym, argumentIndex, comparisonInfo, arg, context) { + var tempComparisonInfo = new TypeComparisonInfo(); + tempComparisonInfo.stringConstantVal = comparisonInfo.stringConstantVal; + if (!context.hasProvisionalErrors() && this.sourceIsSubtypeOfTarget(argSym.type, paramType, arg, context, tempComparisonInfo)) { + return 3 /* Subtype */; + } + + if (this.sourceIsAssignableToTarget(argSym.type, paramType, arg, context, comparisonInfo.message ? tempComparisonInfo : comparisonInfo)) { + return context.hasProvisionalErrors() ? 1 /* AssignableButWithProvisionalErrors */ : 2 /* AssignableWithNoProvisionalErrors */; + } + + if (!comparisonInfo.message) { + var enclosingSymbol = this.getEnclosingSymbolForAST(arg); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_apply_type_0_to_argument_1_which_is_of_type_2, [paramType.toString(enclosingSymbol), (argumentIndex + 1), argSym.getTypeName(enclosingSymbol)])); + } + + return 0 /* NotAssignable */; + }; + + PullTypeResolver.prototype.inferArgumentTypesForSignature = function (signature, argContext, comparisonInfo, context) { + var cxt = null; + + var parameters = signature.parameters; + var typeParameters = signature.getTypeParameters(); + + var parameterType = null; + var argCount = argContext.getInferenceArgumentCount(); + + for (var i = 0; i < typeParameters.length; i++) { + argContext.addInferenceRoot(typeParameters[i]); + } + + for (var i = 0; i < argCount; i++) { + if (i >= parameters.length) { + break; + } + + parameterType = parameters[i].type; + + if (signature.hasVarArgs && (i >= signature.nonOptionalParamCount - 1) && parameterType.isArrayNamedTypeReference()) { + parameterType = parameterType.getElementType(); + } + + var inferenceCandidates = argContext.getInferenceCandidates(); + + if (inferenceCandidates.length) { + for (var j = 0; j < inferenceCandidates.length; j++) { + argContext.resetRelationshipCache(); + var substitutions = inferenceCandidates[j]; + + context.pushContextualType(parameterType, true, substitutions); + + this.relateTypeToTypeParameters(argContext.getArgumentTypeSymbolAtIndex(i, context), parameterType, false, argContext, context); + + cxt = context.popContextualType(); + } + } else { + context.pushContextualType(parameterType, true, []); + + this.relateTypeToTypeParameters(argContext.getArgumentTypeSymbolAtIndex(i, context), parameterType, false, argContext, context); + + cxt = context.popContextualType(); + } + } + + var inferenceResults = argContext.inferArgumentTypes(this, context); + + if (inferenceResults.unfit) { + return null; + } + + var resultTypes = []; + + for (var i = 0; i < typeParameters.length; i++) { + for (var j = 0; j < inferenceResults.results.length; j++) { + if ((inferenceResults.results[j].param == typeParameters[i]) && inferenceResults.results[j].type) { + resultTypes[resultTypes.length] = inferenceResults.results[j].type; + break; + } + } + } + + if (!argCount && !resultTypes.length && typeParameters.length) { + for (var i = 0; i < typeParameters.length; i++) { + resultTypes[resultTypes.length] = this.semanticInfoChain.emptyTypeSymbol; + } + } else if (resultTypes.length < typeParameters.length) { + for (var i = resultTypes.length; i < typeParameters.length; i++) { + resultTypes[i] = this.semanticInfoChain.emptyTypeSymbol; + } + } + + var inferringAtCallExpression = argContext.argumentASTs && argContext.argumentASTs.parent && argContext.argumentASTs.parent.kind() === 226 /* ArgumentList */ && (argContext.argumentASTs.parent.parent.kind() === 213 /* InvocationExpression */ || argContext.argumentASTs.parent.parent.kind() === 216 /* ObjectCreationExpression */); + + if (inferringAtCallExpression) { + if (!this.typeParametersAreInScopeAtArgumentList(typeParameters, argContext.argumentASTs)) { + for (var i = 0; i < resultTypes.length; i++) { + if (resultTypes[i].wrapsSomeTypeParameter(argContext.candidateCache)) { + resultTypes[i] = this.semanticInfoChain.emptyTypeSymbol; + } + } + } + } + + return resultTypes; + }; + + PullTypeResolver.prototype.typeParametersAreInScopeAtArgumentList = function (typeParameters, args) { + var enclosingDecl = this.getEnclosingDeclForAST(args); + var typeParameterParentDecl = typeParameters[0].getDeclarations()[0].getParentDecl(); + return enclosingDecl.getParentPath().indexOf(typeParameterParentDecl) > -1; + }; + + PullTypeResolver.prototype.relateTypeToTypeParametersInEnclosingType = function (expressionType, parameterType, expressionTypeEnclosingType, parameterTypeEnclosingType, shouldFix, argContext, context) { + if (expressionType && parameterType) { + var expressionTypeGenerativeTypeClassification = expressionTypeEnclosingType ? expressionType.getGenerativeTypeClassification(expressionTypeEnclosingType) : 0 /* Unknown */; + var parameterTypeGenerativeTypeClassification = parameterTypeEnclosingType ? parameterType.getGenerativeTypeClassification(parameterTypeEnclosingType) : 0 /* Unknown */; + if (expressionTypeGenerativeTypeClassification == 3 /* InfinitelyExpanding */ || parameterTypeGenerativeTypeClassification == 3 /* InfinitelyExpanding */) { + this.relateInifinitelyExpandingTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + return; + } + } + this.relateTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.relateTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + if (!expressionType || !parameterType) { + return; + } + + if (expressionType.isError()) { + expressionType = this.semanticInfoChain.anyTypeSymbol; + } + + if (parameterType.isTypeParameter()) { + argContext.addCandidateForInference(parameterType, expressionType, shouldFix); + return; + } + + var parameterDeclarations = parameterType.getDeclarations(); + var expressionDeclarations = expressionType.getDeclarations(); + + if (!parameterType.isArrayNamedTypeReference() && parameterDeclarations.length && expressionDeclarations.length && !(parameterType.isTypeParameter() || expressionType.isTypeParameter()) && (parameterDeclarations[0].isEqual(expressionDeclarations[0]) || (expressionType.isGeneric() && parameterType.isGeneric() && this.sourceIsSubtypeOfTarget(this.instantiateTypeToAny(expressionType, context), this.instantiateTypeToAny(parameterType, context), null, context, null))) && expressionType.isGeneric()) { + this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + } + + if (expressionType.isArrayNamedTypeReference() && parameterType.isArrayNamedTypeReference()) { + this.relateArrayTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + + return; + } + + this.relateObjectTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.relateTypeArgumentsOfTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + var typeParameters = parameterType.getTypeArgumentsOrTypeParameters(); + var typeArguments = expressionType.getTypeArguments(); + + if (!typeArguments) { + typeParameters = parameterType.getTypeArguments(); + typeArguments = expressionType.getTypeArgumentsOrTypeParameters(); + } + + if (typeParameters && typeArguments && typeParameters.length === typeArguments.length) { + for (var i = 0; i < typeParameters.length; i++) { + if (typeArguments[i] != typeParameters[i]) { + this.relateTypeToTypeParameters(typeArguments[i], typeParameters[i], true, argContext, context); + } + } + } + }; + + PullTypeResolver.prototype.relateInifinitelyExpandingTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + if (!expressionType || !parameterType) { + return; + } + + var expressionTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(expressionType); + var parameterTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(parameterType); + if (expressionTypeNamedTypeReference != parameterTypeNamedTypeReference) { + return; + } + + var expressionTypeTypeArguments = expressionType.getTypeArguments(); + var parameterTypeParameters = parameterType.getTypeParameters(); + + if (expressionTypeTypeArguments && parameterTypeParameters && expressionTypeTypeArguments.length === parameterTypeParameters.length) { + for (var i = 0; i < expressionTypeTypeArguments.length; i++) { + this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + } + } + }; + + PullTypeResolver.prototype.relateFunctionSignatureToTypeParameters = function (expressionSignature, parameterSignature, argContext, context) { + var expressionParams = expressionSignature.parameters; + var expressionReturnType = expressionSignature.returnType; + + var parameterParams = parameterSignature.parameters; + var parameterReturnType = parameterSignature.returnType; + + var len = parameterParams.length < expressionParams.length ? parameterParams.length : expressionParams.length; + + for (var i = 0; i < len; i++) { + this.relateTypeToTypeParametersInEnclosingType(expressionParams[i].type, parameterParams[i].type, expressionSignature.functionType, parameterSignature.functionType, true, argContext, context); + } + + this.relateTypeToTypeParametersInEnclosingType(expressionReturnType, parameterReturnType, expressionSignature.functionType, parameterSignature.functionType, false, argContext, context); + }; + + PullTypeResolver.prototype.relateObjectTypeToTypeParameters = function (objectType, parameterType, shouldFix, argContext, context) { + var parameterTypeMembers = parameterType.getMembers(); + var parameterSignatures; + + var objectMember; + var objectSignatures; + + if (argContext.alreadyRelatingTypes(objectType, parameterType)) { + return; + } + + var objectTypeArguments = objectType.getTypeArguments(); + var parameterTypeParameters = parameterType.getTypeParameters(); + + if (objectTypeArguments) { + if (objectTypeArguments.length === parameterTypeParameters.length) { + for (var i = 0; i < objectTypeArguments.length; i++) { + argContext.addCandidateForInference(parameterTypeParameters[i], objectTypeArguments[i], shouldFix); + } + } else if (parameterType == this.semanticInfoChain.anyTypeSymbol) { + for (var i = 0; i < objectTypeArguments.length; i++) { + this.relateTypeToTypeParameters(parameterType, objectTypeArguments[i], shouldFix, argContext, context); + } + } + } + + for (var i = 0; i < parameterTypeMembers.length; i++) { + objectMember = this.getMemberSymbol(parameterTypeMembers[i].name, 68147712 /* SomeValue */, objectType); + if (objectMember) { + this.relateTypeToTypeParametersInEnclosingType(objectMember.type, parameterTypeMembers[i].type, objectType, parameterType, shouldFix, argContext, context); + } + } + + parameterSignatures = parameterType.getCallSignatures(); + objectSignatures = objectType.getCallSignatures(); + + if ((parameterSignatures.length == 1) && (objectSignatures.length == 1) && !objectSignatures[0].isGeneric() && (parameterSignatures[0].nonOptionalParamCount >= objectSignatures[0].nonOptionalParamCount)) { + this.relateFunctionSignatureToTypeParameters(objectSignatures[0], parameterSignatures[0], argContext, context); + } + + parameterSignatures = parameterType.getConstructSignatures(); + objectSignatures = objectType.getConstructSignatures(); + + if ((parameterSignatures.length == 1) && (objectSignatures.length == 1) && !objectSignatures[0].isGeneric() && (parameterSignatures[0].nonOptionalParamCount >= objectSignatures[0].nonOptionalParamCount)) { + this.relateFunctionSignatureToTypeParameters(objectSignatures[0], parameterSignatures[0], argContext, context); + } + + var parameterIndexSignatures = this.getBothKindsOfIndexSignatures(parameterType, context); + var objectIndexSignatures = this.getBothKindsOfIndexSignatures(objectType, context); + + if (parameterIndexSignatures.stringSignature && objectIndexSignatures.stringSignature) { + this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.stringSignature, parameterIndexSignatures.stringSignature, argContext, context); + } + if (parameterIndexSignatures.numericSignature && objectIndexSignatures.numericSignature) { + this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.numericSignature, parameterIndexSignatures.numericSignature, argContext, context); + } + }; + + PullTypeResolver.prototype.relateArrayTypeToTypeParameters = function (argArrayType, parameterArrayType, shouldFix, argContext, context) { + var argElement = argArrayType.getElementType(); + var paramElement = parameterArrayType.getElementType(); + + this.relateTypeToTypeParameters(argElement, paramElement, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.instantiateTypeToAny = function (typeToSpecialize, context) { + var typeParameters = typeToSpecialize.getTypeParameters(); + + if (!typeParameters.length) { + return typeToSpecialize; + } + + var typeArguments = null; + + if (!this._cachedAnyTypeArgs) { + this._cachedAnyTypeArgs = [ + [this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol] + ]; + } + + if (typeParameters.length < this._cachedAnyTypeArgs.length) { + typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1]; + } else { + typeArguments = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol; + } + } + + var type = this.createInstantiatedType(typeToSpecialize, typeArguments); + + return type; + }; + + PullTypeResolver.typeCheck = function (compilationSettings, semanticInfoChain, document) { + var sourceUnit = document.sourceUnit(); + + var resolver = semanticInfoChain.getResolver(); + var context = new TypeScript.PullTypeResolutionContext(resolver, true, sourceUnit.fileName()); + + if (resolver.canTypeCheckAST(sourceUnit, context)) { + resolver.resolveAST(sourceUnit, false, context); + resolver.validateVariableDeclarationGroups(semanticInfoChain.getDeclForAST(sourceUnit), context); + + while (resolver.typeCheckCallBacks.length) { + var callBack = resolver.typeCheckCallBacks.pop(); + callBack(context); + } + + resolver.processPostTypeCheckWorkItems(context); + } + }; + + PullTypeResolver.prototype.validateVariableDeclarationGroups = function (enclosingDecl, context) { + var importDeclarationNames = null; + if (enclosingDecl.kind & (4 /* Container */ | 32 /* DynamicModule */ | 1 /* Script */)) { + var childDecls = enclosingDecl.getChildDecls(); + for (var i = 0, n = childDecls.length; i < n; i++) { + var childDecl = childDecls[i]; + if (childDecl.kind === 128 /* TypeAlias */) { + importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject(); + importDeclarationNames[childDecl.name] = true; + } + } + } + + var declGroups = enclosingDecl.getVariableDeclGroups(); + + for (var i = 0, i_max = declGroups.length; i < i_max; i++) { + var firstSymbol = null; + var firstSymbolType = null; + + if (enclosingDecl.kind === 1 /* Script */ && declGroups[i].length) { + var name = declGroups[i][0].name; + var candidateSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 512 /* Variable */, enclosingDecl); + if (candidateSymbol && candidateSymbol.isResolved) { + if (!candidateSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */)) { + firstSymbol = candidateSymbol; + firstSymbolType = candidateSymbol.type; + } + } + + var importSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 128 /* TypeAlias */, null); + if (importSymbol && importSymbol.isAlias()) { + importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject(); + } + } + + for (var j = 0, j_max = declGroups[i].length; j < j_max; j++) { + var decl = declGroups[i][j]; + var boundDeclAST = this.semanticInfoChain.getASTForDecl(decl); + + var name = decl.name; + + if (importDeclarationNames && importDeclarationNames[name]) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Variable_declaration_cannot_have_the_same_name_as_an_import_declaration)); + continue; + } + + var symbol = decl.getSymbol(); + var symbolType = symbol.type; + + if (j === 0 && !firstSymbol) { + firstSymbol = symbol; + firstSymbolType = symbolType; + continue; + } + + if (symbolType && firstSymbolType && symbolType !== firstSymbolType && !this.typesAreIdentical(symbolType, firstSymbolType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, [symbol.getScopedName(), firstSymbolType.toString(), symbolType.toString()])); + continue; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckFunctionOverloads = function (funcDecl, context, signature, allSignatures) { + if (!signature) { + var functionSignatureInfo = TypeScript.PullHelpers.getSignatureForFuncDecl(this.semanticInfoChain.getDeclForAST(funcDecl)); + signature = functionSignatureInfo.signature; + allSignatures = functionSignatureInfo.allSignatures; + } + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSymbol = functionDeclaration.getSymbol(); + + var definitionSignature = null; + for (var i = allSignatures.length - 1; i >= 0; i--) { + if (allSignatures[i].isDefinition()) { + definitionSignature = allSignatures[i]; + break; + } + } + + if (!signature.isDefinition()) { + for (var i = 0; i < allSignatures.length; i++) { + if (allSignatures[i] === signature) { + break; + } + + if (this.signaturesAreIdentical(allSignatures[i], signature, false)) { + if (!this.typesAreIdentical(allSignatures[i].returnType, signature.returnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overloads_cannot_differ_only_by_return_type)); + } else if (funcDecl.kind() === 137 /* ConstructorDeclaration */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_constructor_overload_signature)); + } else if (functionDeclaration.kind === 2097152 /* ConstructSignature */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_construct_signature)); + } else if (functionDeclaration.kind === 1048576 /* CallSignature */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_call_signature)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_signature_for_0, [funcSymbol.getScopedNameEx().toString()])); + } + + break; + } + } + } + + var isConstantOverloadSignature = signature.isStringConstantOverloadSignature(); + if (isConstantOverloadSignature) { + if (signature.isDefinition()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_implementation_cannot_use_specialized_type)); + } else { + var foundSubtypeSignature = false; + for (var i = 0; i < allSignatures.length; i++) { + if (allSignatures[i].isDefinition() || allSignatures[i] === signature) { + continue; + } + + if (!allSignatures[i].isResolved) { + this.resolveDeclaredSymbol(allSignatures[i], context); + } + + if (allSignatures[i].isStringConstantOverloadSignature()) { + continue; + } + + if (this.signatureIsSubtypeOfTarget(signature, allSignatures[i], null, context)) { + foundSubtypeSignature = true; + break; + } + } + + if (!foundSubtypeSignature) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Specialized_overload_signature_is_not_subtype_of_any_non_specialized_signature)); + } + } + } else if (definitionSignature && definitionSignature != signature) { + var comparisonInfo = new TypeComparisonInfo(); + + if (!definitionSignature.isResolved) { + this.resolveDeclaredSymbol(definitionSignature, context); + } + + if (!this.signatureIsAssignableToTarget(definitionSignature, signature, funcDecl, context, comparisonInfo)) { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition_NL_0, [comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition)); + } + } + } + + var signatureForVisibilityCheck = definitionSignature; + if (!definitionSignature) { + if (allSignatures[0] === signature) { + return; + } + signatureForVisibilityCheck = allSignatures[0]; + } + + if (funcDecl.kind() !== 137 /* ConstructorDeclaration */ && functionDeclaration.kind !== 2097152 /* ConstructSignature */ && signatureForVisibilityCheck && signature != signatureForVisibilityCheck) { + var errorCode; + + if (signatureForVisibilityCheck.anyDeclHasFlag(2 /* Private */) != signature.anyDeclHasFlag(2 /* Private */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_public_or_private; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(1 /* Exported */) != signature.anyDeclHasFlag(1 /* Exported */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_exported_or_not_exported; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(8 /* Ambient */) != signature.anyDeclHasFlag(8 /* Ambient */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_ambient_or_non_ambient; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(128 /* Optional */) != signature.anyDeclHasFlag(128 /* Optional */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_optional_or_required; + } + + if (errorCode) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, errorCode)); + } + } + }; + + PullTypeResolver.prototype.checkSymbolPrivacy = function (declSymbol, symbol, privacyErrorReporter) { + if (!symbol || symbol.kind === 2 /* Primitive */) { + return; + } + + if (symbol.isType()) { + var typeSymbol = symbol; + var isNamedType = typeSymbol.isNamedTypeSymbol(); + + if (typeSymbol.isArrayNamedTypeReference()) { + this.checkSymbolPrivacy(declSymbol, typeSymbol.getElementType(), privacyErrorReporter); + return; + } + + if (!isNamedType) { + var typeOfSymbol = typeSymbol.getTypeOfSymbol(); + if (typeOfSymbol) { + this.checkSymbolPrivacy(declSymbol, typeOfSymbol, privacyErrorReporter); + return; + } + } + + if (typeSymbol.inSymbolPrivacyCheck) { + return; + } + + typeSymbol.inSymbolPrivacyCheck = true; + + var typars = typeSymbol.getTypeArgumentsOrTypeParameters(); + if (typars) { + for (var i = 0; i < typars.length; i++) { + this.checkSymbolPrivacy(declSymbol, typars[i], privacyErrorReporter); + } + } + + if (!isNamedType) { + var members = typeSymbol.getMembers(); + for (var i = 0; i < members.length; i++) { + this.checkSymbolPrivacy(declSymbol, members[i].type, privacyErrorReporter); + } + + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getCallSignatures(), privacyErrorReporter); + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getConstructSignatures(), privacyErrorReporter); + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getIndexSignatures(), privacyErrorReporter); + } else if (typeSymbol.kind == 8192 /* TypeParameter */) { + this.checkSymbolPrivacy(declSymbol, typeSymbol.getConstraint(), privacyErrorReporter); + } + + typeSymbol.inSymbolPrivacyCheck = false; + + if (!isNamedType) { + return; + } + } + + if (declSymbol.isExternallyVisible()) { + var symbolIsVisible = symbol.isExternallyVisible(); + + if (symbolIsVisible && symbol.kind != 8192 /* TypeParameter */) { + var symbolPath = symbol.pathToRoot(); + var declSymbolPath = declSymbol.pathToRoot(); + + if (symbolPath[symbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1].kind == 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1] != symbolPath[symbolPath.length - 1]) { + symbolIsVisible = false; + var declSymbolScope = declSymbolPath[declSymbolPath.length - 1]; + for (var i = symbolPath.length - 1; i >= 0; i--) { + var aliasSymbols = symbolPath[i].getExternalAliasedSymbols(declSymbolScope); + if (aliasSymbols) { + symbolIsVisible = true; + aliasSymbols[0].setTypeUsedExternally(true); + break; + } + } + symbol = symbolPath[symbolPath.length - 1]; + } + } else if (symbol.kind == 128 /* TypeAlias */) { + var aliasSymbol = symbol; + symbolIsVisible = true; + aliasSymbol.setTypeUsedExternally(true); + } + + if (!symbolIsVisible) { + privacyErrorReporter(symbol); + } + } + }; + + PullTypeResolver.prototype.checkTypePrivacyOfSignatures = function (declSymbol, signatures, privacyErrorReporter) { + for (var i = 0; i < signatures.length; i++) { + var signature = signatures[i]; + if (signatures.length > 1 && signature.isDefinition()) { + continue; + } + + var typeParams = signature.getTypeParameters(); + for (var j = 0; j < typeParams.length; j++) { + this.checkSymbolPrivacy(declSymbol, typeParams[j], privacyErrorReporter); + } + + var params = signature.parameters; + for (var j = 0; j < params.length; j++) { + var paramType = params[j].type; + this.checkSymbolPrivacy(declSymbol, paramType, privacyErrorReporter); + } + + var returnType = signature.returnType; + this.checkSymbolPrivacy(declSymbol, returnType, privacyErrorReporter); + } + }; + + PullTypeResolver.prototype.typeParameterOfTypeDeclarationPrivacyErrorReporter = function (classOrInterface, indexOfTypeParameter, typeParameter, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + var messageCode; + + var typeParameters = classOrInterface.kind() === 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList; + + var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(indexOfTypeParameter); + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1; + } + } else { + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1; + } + } + + var messageArguments = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.baseListPrivacyErrorReporter = function (classOrInterface, declSymbol, baseAst, isExtendedType, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + var messageCode; + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + if (isExtendedType) { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_class_from_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_interface_from_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_interface_from_inaccessible_module_1; + } + } else { + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + if (isExtendedType) { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_private_class_1; + } else { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_private_interface_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_private_interface_1; + } + } + + var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseAst, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.variablePrivacyErrorReporter = function (declAST, declSymbol, symbol, context) { + var typeSymbol = symbol; + var enclosingDecl = this.getEnclosingDecl(declSymbol.getDeclarations()[0]); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isProperty = declSymbol.kind === 4096 /* Property */; + var isPropertyOfClass = false; + var declParent = declSymbol.getContainer(); + if (declParent && (declParent.kind === 8 /* Class */ || declParent.kind === 32768 /* ConstructorMethod */)) { + isPropertyOfClass = true; + } + + var messageCode; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (declSymbol.anyDeclHasFlag(16 /* Static */)) { + messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_is_using_inaccessible_module_1; + } else if (isProperty) { + if (isPropertyOfClass) { + messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_is_using_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_variable_0_is_using_inaccessible_module_1; + } + } else { + if (declSymbol.anyDeclHasFlag(16 /* Static */)) { + messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_has_or_is_using_private_type_1; + } else if (isProperty) { + if (isPropertyOfClass) { + messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_has_or_is_using_private_type_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_variable_0_has_or_is_using_private_type_1; + } + } + + var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.checkFunctionTypePrivacy = function (funcDeclAST, isStatic, typeParameters, parameters, returnTypeAnnotation, block, context) { + var _this = this; + if (funcDeclAST.kind() === 222 /* FunctionExpression */ || funcDeclAST.kind() === 241 /* FunctionPropertyAssignment */ || (funcDeclAST.kind() === 139 /* GetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (funcDeclAST.kind() === 140 /* SetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) { + return; + } + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var functionSymbol = functionDecl.getSymbol(); + ; + var functionSignature; + + var isGetter = funcDeclAST.kind() === 139 /* GetAccessor */; + var isSetter = funcDeclAST.kind() === 140 /* SetAccessor */; + var isIndexSignature = functionDecl.kind === 4194304 /* IndexSignature */; + + if (isGetter || isSetter) { + var accessorSymbol = functionSymbol; + functionSignature = (isGetter ? accessorSymbol.getGetter() : accessorSymbol.getSetter()).type.getCallSignatures()[0]; + } else { + if (!functionSymbol) { + var parentDecl = functionDecl.getParentDecl(); + functionSymbol = parentDecl.getSymbol(); + if (functionSymbol && functionSymbol.isType() && !functionSymbol.isNamedTypeSymbol()) { + return; + } + } else if (functionSymbol.kind == 65536 /* Method */ && !isStatic && !functionSymbol.getContainer().isNamedTypeSymbol()) { + return; + } + functionSignature = functionDecl.getSignatureSymbol(); + } + + if (typeParameters && !isGetter && !isSetter && !isIndexSignature && funcDeclAST.kind() !== 137 /* ConstructorDeclaration */) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(i); + var typeParameter = this.resolveTypeParameterDeclaration(typeParameterAST, context); + this.checkSymbolPrivacy(functionSymbol, typeParameter, function (symbol) { + return _this.functionTypeArgumentArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, typeParameterAST, typeParameter, symbol, context); + }); + } + } + + if (!isGetter && !isIndexSignature) { + var funcParams = functionSignature.parameters; + for (var i = 0; i < funcParams.length; i++) { + this.checkSymbolPrivacy(functionSymbol, funcParams[i].type, function (symbol) { + return _this.functionArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, parameters, i, funcParams[i], symbol, context); + }); + } + } + + if (!isSetter) { + this.checkSymbolPrivacy(functionSymbol, functionSignature.returnType, function (symbol) { + return _this.functionReturnTypePrivacyErrorReporter(funcDeclAST, isStatic, returnTypeAnnotation, block, functionSignature.returnType, symbol, context); + }); + } + }; + + PullTypeResolver.prototype.functionTypeArgumentArgumentTypePrivacyErrorReporter = function (declAST, isStatic, typeParameterAST, typeParameter, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + var messageCode; + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_is_using_inaccessible_module_1; + } + } else { + if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_has_or_is_using_private_type_1; + } + } + + if (messageCode) { + var messageArgs = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArgs)); + } + }; + + PullTypeResolver.prototype.functionArgumentTypePrivacyErrorReporter = function (declAST, isStatic, parameters, argIndex, paramSymbol, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isGetter = declAST.kind() === 139 /* GetAccessor */; + var isSetter = declAST.kind() === 140 /* SetAccessor */; + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + var messageCode; + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (declAST.kind() === 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1; + } else if (isSetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1; + } + } else if (!isGetter) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_is_using_inaccessible_module_1; + } + } else { + if (declAST.kind() === 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1; + } else if (isSetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1; + } + } else if (!isGetter && decl.kind !== 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_has_or_is_using_private_type_1; + } + } + + if (messageCode) { + var parameter = parameters.astAt(argIndex); + + var messageArgs = [paramSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(parameter, messageCode, messageArgs)); + } + }; + + PullTypeResolver.prototype.functionReturnTypePrivacyErrorReporter = function (declAST, isStatic, returnTypeAnnotation, block, funcReturnType, symbol, context) { + var _this = this; + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + + var isGetter = declAST.kind() === 139 /* GetAccessor */; + var isSetter = declAST.kind() === 140 /* SetAccessor */; + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var messageCode = null; + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (isGetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (decl.kind === 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0; + } + } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_is_using_inaccessible_module_0; + } + } else { + if (isGetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (decl.kind === 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0; + } + } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_has_or_is_using_private_type_0; + } + } + + if (messageCode) { + var messageArguments = [typeSymbolName]; + var reportOnFuncDecl = false; + + if (returnTypeAnnotation) { + var returnExpressionSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + + if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, messageCode, messageArguments)); + } + } + + if (block) { + var reportErrorOnReturnExpressions = function (ast, walker) { + var go = true; + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + go = false; + break; + + case 150 /* ReturnStatement */: + var returnStatement = ast; + var returnExpressionSymbol = _this.resolveAST(returnStatement.expression, false, context).type; + + if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(returnStatement, messageCode, messageArguments)); + } else { + reportOnFuncDecl = true; + } + go = false; + break; + + default: + break; + } + + walker.options.goChildren = go; + return ast; + }; + + TypeScript.getAstWalkerFactory().walk(block, reportErrorOnReturnExpressions); + } + + if (reportOnFuncDecl) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments)); + } + } + }; + + PullTypeResolver.prototype.enclosingClassIsDerived = function (classDecl) { + TypeScript.Debug.assert(classDecl.kind === 8 /* Class */); + + var classSymbol = classDecl.getSymbol(); + return classSymbol.getExtendedTypes().length > 0; + }; + + PullTypeResolver.prototype.isSuperInvocationExpression = function (ast) { + if (ast.kind() === 213 /* InvocationExpression */) { + var invocationExpression = ast; + if (invocationExpression.expression.kind() === 50 /* SuperKeyword */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.isSuperInvocationExpressionStatement = function (node) { + if (node && node.kind() === 149 /* ExpressionStatement */) { + var expressionStatement = node; + if (this.isSuperInvocationExpression(expressionStatement.expression)) { + return true; + } + } + return false; + }; + + PullTypeResolver.prototype.getFirstStatementOfBlockOrNull = function (block) { + if (block && block.statements && block.statements.childCount() > 0) { + return block.statements.childAt(0); + } + + return null; + }; + + PullTypeResolver.prototype.superCallMustBeFirstStatementInConstructor = function (constructorDecl) { + TypeScript.Debug.assert(constructorDecl.kind === 32768 /* ConstructorMethod */); + + if (constructorDecl) { + var enclosingClass = constructorDecl.getParentDecl(); + + var classSymbol = enclosingClass.getSymbol(); + if (classSymbol.getExtendedTypes().length === 0) { + return false; + } + + var classMembers = classSymbol.getMembers(); + for (var i = 0, n1 = classMembers.length; i < n1; i++) { + var member = classMembers[i]; + + if (member.kind === 4096 /* Property */) { + var declarations = member.getDeclarations(); + for (var j = 0, n2 = declarations.length; j < n2; j++) { + var declaration = declarations[j]; + var ast = this.semanticInfoChain.getASTForDecl(declaration); + if (ast.kind() === 242 /* Parameter */) { + return true; + } + + if (ast.kind() === 136 /* MemberVariableDeclaration */) { + var variableDeclarator = ast; + if (variableDeclarator.variableDeclarator.equalsValueClause) { + return true; + } + } + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.checkForThisCaptureInArrowFunction = function (expression) { + var enclosingDecl = this.getEnclosingDeclForAST(expression); + + var declPath = enclosingDecl.getParentPath(); + + if (declPath.length) { + var inArrowFunction = false; + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + var declFlags = decl.flags; + + if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) { + inArrowFunction = true; + continue; + } + + if (inArrowFunction) { + if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) { + decl.setFlags(decl.flags | 262144 /* MustCaptureThis */); + + if (declKind === 8 /* Class */) { + var constructorSymbol = decl.getSymbol().getConstructorMethod(); + var constructorDecls = constructorSymbol.getDeclarations(); + for (var i = 0; i < constructorDecls.length; i++) { + constructorDecls[i].flags = constructorDecls[i].flags | 262144 /* MustCaptureThis */; + } + } + break; + } + } else if (declKind === 16384 /* Function */ || declKind === 131072 /* FunctionExpression */) { + break; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckMembersAgainstIndexer = function (containerType, containerTypeDecl, context) { + var indexSignatures = this.getBothKindsOfIndexSignatures(containerType, context); + var stringSignature = indexSignatures.stringSignature; + var numberSignature = indexSignatures.numericSignature; + + if (stringSignature || numberSignature) { + var members = containerTypeDecl.getChildDecls(); + for (var i = 0; i < members.length; i++) { + var member = members[i]; + if ((member.name || (member.kind === 4096 /* Property */ && member.name === "")) && member.kind !== 32768 /* ConstructorMethod */ && !TypeScript.hasFlag(member.flags, 16 /* Static */)) { + var memberSymbol = member.getSymbol(); + var relevantSignature = this.determineRelevantIndexerForMember(memberSymbol, numberSignature, stringSignature); + if (relevantSignature) { + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsSubtypeOfTarget(memberSymbol.type, relevantSignature.returnType, member.ast(), context, comparisonInfo)) { + this.reportErrorThatMemberIsNotSubtypeOfIndexer(memberSymbol, relevantSignature, member.ast(), context, comparisonInfo); + } + } + } + } + } + }; + + PullTypeResolver.prototype.determineRelevantIndexerForMember = function (member, numberIndexSignature, stringIndexSignature) { + if (numberIndexSignature && TypeScript.PullHelpers.isNameNumeric(member.name)) { + return numberIndexSignature; + } else if (stringIndexSignature) { + return stringIndexSignature; + } + + return null; + }; + + PullTypeResolver.prototype.reportErrorThatMemberIsNotSubtypeOfIndexer = function (member, indexSignature, astForError, context, comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(astForError); + if (indexSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol) { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)])); + } + } else { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_subtypes_of_string_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_subtypes_of_string_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.typeCheckIfTypeMemberPropertyOkToOverride = function (typeSymbol, extendedType, typeMember, extendedTypeMember, enclosingDecl, comparisonInfo) { + if (!typeSymbol.isClass()) { + return true; + } + + var typeMemberKind = typeMember.kind; + var extendedMemberKind = extendedTypeMember.kind; + + if (typeMemberKind === extendedMemberKind) { + return true; + } + + var errorCode; + if (typeMemberKind === 4096 /* Property */) { + if (typeMember.isAccessor()) { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; + } else { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + } + } else if (typeMemberKind === 65536 /* Method */) { + if (extendedTypeMember.isAccessor()) { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } else { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; + } + } + + var message = TypeScript.getDiagnosticMessage(errorCode, [typeSymbol.toString(), typeMember.getScopedNameEx().toString(), extendedType.toString()]); + comparisonInfo.addMessage(message); + return false; + }; + + PullTypeResolver.prototype.typeCheckIfTypeExtendsType = function (classOrInterface, name, typeSymbol, extendedType, enclosingDecl, context) { + var typeMembers = typeSymbol.getMembers(); + + var comparisonInfo = new TypeComparisonInfo(); + var foundError = false; + var foundError1 = false; + var foundError2 = false; + + for (var i = 0; i < typeMembers.length; i++) { + var propName = typeMembers[i].name; + var extendedTypeProp = extendedType.findMember(propName, true); + if (extendedTypeProp) { + this.resolveDeclaredSymbol(extendedTypeProp, context); + foundError1 = !this.typeCheckIfTypeMemberPropertyOkToOverride(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, enclosingDecl, comparisonInfo); + + if (!foundError1) { + foundError2 = !this.sourcePropertyIsSubtypeOfTargetProperty(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, classOrInterface, context, comparisonInfo); + } + + if (foundError1 || foundError2) { + foundError = true; + break; + } + } + } + + if (!foundError && typeSymbol.hasOwnCallSignatures()) { + foundError = !this.sourceCallSignaturesAreSubtypeOfTargetCallSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.hasOwnConstructSignatures()) { + foundError = !this.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.hasOwnIndexSignatures()) { + foundError = !this.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.isClass()) { + var typeConstructorType = typeSymbol.getConstructorMethod().type; + var typeConstructorTypeMembers = typeConstructorType.getMembers(); + if (typeConstructorTypeMembers.length) { + var extendedConstructorType = extendedType.getConstructorMethod().type; + var comparisonInfoForPropTypeCheck = new TypeComparisonInfo(comparisonInfo); + + for (var i = 0; i < typeConstructorTypeMembers.length; i++) { + var propName = typeConstructorTypeMembers[i].name; + var extendedConstructorTypeProp = extendedConstructorType.findMember(propName, true); + if (extendedConstructorTypeProp) { + if (!extendedConstructorTypeProp.isResolved) { + this.resolveDeclaredSymbol(extendedConstructorTypeProp, context); + } + + var typeConstructorTypePropType = typeConstructorTypeMembers[i].type; + var extendedConstructorTypePropType = extendedConstructorTypeProp.type; + if (!this.sourceIsSubtypeOfTarget(typeConstructorTypePropType, extendedConstructorTypePropType, classOrInterface, context, comparisonInfoForPropTypeCheck)) { + var propMessage; + var enclosingSymbol = this.getEnclosingSymbolForAST(classOrInterface); + if (comparisonInfoForPropTypeCheck.message) { + propMessage = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3, [extendedConstructorTypeProp.getScopedNameEx().toString(), typeSymbol.toString(enclosingSymbol), extendedType.toString(enclosingSymbol), comparisonInfoForPropTypeCheck.message]); + } else { + propMessage = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible, [extendedConstructorTypeProp.getScopedNameEx().toString(), typeSymbol.toString(enclosingSymbol), extendedType.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(propMessage); + foundError = true; + break; + } + } + } + } + } + + if (foundError) { + var errorCode; + if (typeSymbol.isClass()) { + errorCode = TypeScript.DiagnosticCode.Class_0_cannot_extend_class_1_NL_2; + } else { + if (extendedType.isClass()) { + errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_class_1_NL_2; + } else { + errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_interface_1_NL_2; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, errorCode, [typeSymbol.getScopedName(), extendedType.getScopedName(), comparisonInfo.message])); + } + }; + + PullTypeResolver.prototype.typeCheckIfClassImplementsType = function (classDecl, classSymbol, implementedType, enclosingDecl, context) { + var comparisonInfo = new TypeComparisonInfo(); + var foundError = !this.sourceMembersAreSubtypeOfTargetMembers(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceCallSignaturesAreSubtypeOfTargetCallSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + } + } + } + + if (foundError) { + var enclosingSymbol = this.getEnclosingSymbolForAST(classDecl); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(classDecl.identifier, TypeScript.DiagnosticCode.Class_0_declares_interface_1_but_does_not_implement_it_NL_2, [classSymbol.getScopedName(enclosingSymbol), implementedType.getScopedName(enclosingSymbol), comparisonInfo.message])); + } + }; + + PullTypeResolver.prototype.hasClassTypeSymbolConflictAsValue = function (valueDeclAST, typeSymbol, enclosingDecl, context) { + var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST); + var valueSymbol = this.computeNameExpression(valueDeclAST, context, false); + var valueSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST); + + this.semanticInfoChain.setAliasSymbolForAST(valueDeclAST, typeSymbolAlias); + + if (typeSymbolAlias && valueSymbolAlias) { + return typeSymbolAlias != valueSymbolAlias; + } + + if (!valueSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */)) { + return true; + } + + var associatedContainerType = valueSymbol.type ? valueSymbol.type.getAssociatedContainerType() : null; + + if (associatedContainerType) { + return associatedContainerType != typeSymbol.getRootSymbol(); + } + + return true; + }; + + PullTypeResolver.prototype.typeCheckBase = function (classOrInterface, name, typeSymbol, baseDeclAST, isExtendedType, enclosingDecl, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + + var baseType = this.resolveTypeReference(baseDeclAST, context).type; + + if (!baseType) { + return; + } + + var typeDeclIsClass = typeSymbol.isClass(); + + if (!typeSymbol.isValidBaseKind(baseType, isExtendedType)) { + if (!baseType.isError()) { + if (isExtendedType) { + if (typeDeclIsClass) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_extend_another_class)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.An_interface_may_only_extend_another_class_or_interface)); + } + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_implement_another_class_or_interface)); + } + } + return; + } else if (typeDeclIsClass && isExtendedType && baseDeclAST.kind() == 11 /* IdentifierName */) { + if (this.hasClassTypeSymbolConflictAsValue(baseDeclAST, baseType, enclosingDecl, context)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.Type_reference_0_in_extends_clause_does_not_reference_constructor_function_for_1, [baseDeclAST.text(), baseType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + } + } + + if (baseType.hasBase(typeSymbol)) { + typeSymbol.setHasBaseTypeConflict(); + baseType.setHasBaseTypeConflict(); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, typeDeclIsClass ? TypeScript.DiagnosticCode.Class_0_is_recursively_referenced_as_a_base_type_of_itself : TypeScript.DiagnosticCode.Interface_0_is_recursively_referenced_as_a_base_type_of_itself, [typeSymbol.getScopedName()])); + return; + } + + if (isExtendedType) { + this.typeCheckIfTypeExtendsType(classOrInterface, name, typeSymbol, baseType, enclosingDecl, context); + } else { + TypeScript.Debug.assert(classOrInterface.kind() === 131 /* ClassDeclaration */); + + this.typeCheckIfClassImplementsType(classOrInterface, typeSymbol, baseType, enclosingDecl, context); + } + + this.checkSymbolPrivacy(typeSymbol, baseType, function (errorSymbol) { + return _this.baseListPrivacyErrorReporter(classOrInterface, typeSymbol, baseDeclAST, isExtendedType, errorSymbol, context); + }); + }; + + PullTypeResolver.prototype.typeCheckBases = function (classOrInterface, name, heritageClauses, typeSymbol, enclosingDecl, context) { + var _this = this; + var extendsClause = TypeScript.getExtendsHeritageClause(heritageClauses); + var implementsClause = TypeScript.getImplementsHeritageClause(heritageClauses); + if (!extendsClause && !implementsClause) { + return; + } + + var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */; + + if (extendsClause) { + for (var i = 0; i < extendsClause.typeNames.nonSeparatorCount(); i++) { + this.typeCheckBase(classOrInterface, name, typeSymbol, extendsClause.typeNames.nonSeparatorAt(i), true, enclosingDecl, context); + } + } + + if (typeSymbol.isClass()) { + if (implementsClause) { + for (var i = 0; i < implementsClause.typeNames.nonSeparatorCount(); i++) { + this.typeCheckBase(classOrInterface, name, typeSymbol, implementsClause.typeNames.nonSeparatorAt(i), false, enclosingDecl, context); + } + } + } else if (extendsClause && !typeSymbol.hasBaseTypeConflict() && typeSymbol.getExtendedTypes().length > 1) { + var firstInterfaceASTWithExtendsClause = TypeScript.ArrayUtilities.firstOrDefault(typeSymbol.getDeclarations(), function (decl) { + return decl.ast().heritageClauses !== null; + }).ast(); + if (classOrInterface === firstInterfaceASTWithExtendsClause) { + this.typeCheckCallBacks.push(function (context) { + _this.checkTypeCompatibilityBetweenBases(classOrInterface.identifier, typeSymbol, context); + }); + } + } + }; + + PullTypeResolver.prototype.checkTypeCompatibilityBetweenBases = function (name, typeSymbol, context) { + var derivedIndexSignatures = typeSymbol.getOwnIndexSignatures(); + + var inheritedMembersMap = TypeScript.createIntrinsicsObject(); + var inheritedIndexSignatures = new InheritedIndexSignatureInfo(); + + var typeHasOwnNumberIndexer = false; + var typeHasOwnStringIndexer = false; + + if (typeSymbol.hasOwnIndexSignatures()) { + var ownIndexSignatures = typeSymbol.getOwnIndexSignatures(); + for (var i = 0; i < ownIndexSignatures.length; i++) { + if (ownIndexSignatures[i].parameters[0].type === this.semanticInfoChain.numberTypeSymbol) { + typeHasOwnNumberIndexer = true; + } else { + typeHasOwnStringIndexer = true; + } + } + } + var baseTypes = typeSymbol.getExtendedTypes(); + for (var i = 0; i < baseTypes.length; i++) { + if (this.checkNamedPropertyTypeIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedMembersMap, context) || this.checkIndexSignatureIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedIndexSignatures, typeHasOwnNumberIndexer, typeHasOwnStringIndexer, context)) { + return; + } + } + + if (this.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature(name, typeSymbol, inheritedIndexSignatures, context)) { + return; + } + + this.checkInheritedMembersAgainstInheritedIndexSignatures(name, typeSymbol, inheritedIndexSignatures, inheritedMembersMap, context); + }; + + PullTypeResolver.prototype.checkNamedPropertyTypeIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, inheritedMembersMap, context) { + var baseMembers = baseTypeSymbol.getAllMembers(4096 /* Property */ | 65536 /* Method */, 0 /* all */); + for (var i = 0; i < baseMembers.length; i++) { + var member = baseMembers[i]; + var memberName = member.name; + + if (interfaceSymbol.findMember(memberName, false)) { + continue; + } + + if (inheritedMembersMap[memberName]) { + var prevMember = inheritedMembersMap[memberName]; + if (prevMember.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(member.type, prevMember.memberSymbol.type)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_not_identical, [memberName, prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + inheritedMembersMap[memberName] = new MemberWithBaseOrigin(member, baseTypeSymbol); + } + } + + return false; + }; + + PullTypeResolver.prototype.checkIndexSignatureIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, allInheritedSignatures, derivedTypeHasOwnNumberSignature, derivedTypeHasOwnStringSignature, context) { + if (derivedTypeHasOwnNumberSignature && derivedTypeHasOwnStringSignature) { + return false; + } + + var indexSignaturesFromThisBaseType = baseTypeSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignaturesFromThisBaseType.length; i++) { + var currentInheritedSignature = indexSignaturesFromThisBaseType[i]; + + var parameterTypeIsString = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.stringTypeSymbol; + var parameterTypeIsNumber = !parameterTypeIsString; + if (parameterTypeIsString && derivedTypeHasOwnStringSignature || parameterTypeIsNumber && derivedTypeHasOwnNumberSignature) { + continue; + } + + if (parameterTypeIsString) { + if (allInheritedSignatures.stringSignatureWithBaseOrigin) { + if (allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.stringSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_string_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + allInheritedSignatures.stringSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol); + } + } else if (parameterTypeIsNumber) { + if (allInheritedSignatures.numberSignatureWithBaseOrigin) { + if (allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.numberSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_number_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + allInheritedSignatures.numberSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol); + } + } + } + + return false; + }; + + PullTypeResolver.prototype.checkInheritedMembersAgainstInheritedIndexSignatures = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, inheritedMembers, context) { + if (!inheritedIndexSignatures.stringSignatureWithBaseOrigin && !inheritedIndexSignatures.numberSignatureWithBaseOrigin) { + return false; + } + + var comparisonInfo = new TypeComparisonInfo(); + var stringSignature = inheritedIndexSignatures.stringSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature; + var numberSignature = inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature; + for (var memberName in inheritedMembers) { + var memberWithBaseOrigin = inheritedMembers[memberName]; + if (!memberWithBaseOrigin) { + continue; + } + + var relevantSignature = this.determineRelevantIndexerForMember(memberWithBaseOrigin.memberSymbol, numberSignature, stringSignature); + if (!relevantSignature) { + continue; + } + + var relevantSignatureIsNumberSignature = relevantSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol; + var signatureBaseOrigin = relevantSignatureIsNumberSignature ? inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin : inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin; + + if (signatureBaseOrigin === memberWithBaseOrigin.baseOrigin) { + continue; + } + + var memberIsSubtype = this.sourceIsSubtypeOfTarget(memberWithBaseOrigin.memberSymbol.type, relevantSignature.returnType, interfaceName, context, comparisonInfo); + + if (!memberIsSubtype) { + var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName); + if (relevantSignatureIsNumberSignature) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_a_subtype_of_number_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + } else { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_a_subtype_of_string_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + } + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, context) { + if (inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin) { + if (inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin === inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin) { + return false; + } + + var comparisonInfo = new TypeComparisonInfo(); + var signatureIsSubtype = this.sourceIsSubtypeOfTarget(inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature.returnType, inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature.returnType, interfaceName, context, comparisonInfo); + + if (!signatureIsSubtype) { + var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName); + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_number_indexer_in_type_0_is_not_a_subtype_of_string_indexer_type_in_type_1_NL_2, [ + inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), + inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [ + interfaceSymbol.getDisplayName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), + inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.checkAssignability = function (ast, source, target, context) { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(source, target, ast, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.isReference = function (ast, astSymbol) { + if (ast.kind() === 217 /* ParenthesizedExpression */) { + return this.isReference(ast.expression, astSymbol); + } + + if (ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */ && ast.kind() !== 221 /* ElementAccessExpression */) { + return false; + } + + if (ast.kind() === 11 /* IdentifierName */) { + if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(4096 /* Enum */)) { + return false; + } + + if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(102400 /* SomeInitializedModule */)) { + return false; + } + + if (astSymbol.kind === 32768 /* ConstructorMethod */) { + return false; + } + } + + if (ast.kind() === 212 /* MemberAccessExpression */ && astSymbol.kind === 67108864 /* EnumMember */) { + return false; + } + + return true; + }; + + PullTypeResolver.prototype.checkForSuperMemberAccess = function (expression, name, resolvedName, context) { + if (resolvedName) { + if (expression.kind() === 50 /* SuperKeyword */ && !resolvedName.isError() && resolvedName.kind !== 65536 /* Method */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword)); + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.getEnclosingDeclForAST = function (ast) { + return this.semanticInfoChain.getEnclosingDecl(ast); + }; + + PullTypeResolver.prototype.getEnclosingSymbolForAST = function (ast) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + return enclosingDecl ? enclosingDecl.getSymbol() : null; + }; + + PullTypeResolver.prototype.checkForPrivateMemberAccess = function (name, expressionType, resolvedName, context) { + if (resolvedName) { + if (resolvedName.anyDeclHasFlag(2 /* Private */)) { + var memberContainer = resolvedName.getContainer(); + if (memberContainer && memberContainer.kind === 33554432 /* ConstructorType */) { + memberContainer = memberContainer.getAssociatedContainerType(); + } + + if (memberContainer && memberContainer.isClass()) { + var memberClass = memberContainer.getDeclarations()[0].ast(); + TypeScript.Debug.assert(memberClass); + + var containingClass = this.getEnclosingClassDeclaration(name); + + if (!containingClass || containingClass !== memberClass) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode._0_1_is_inaccessible, [memberContainer.toString(null, false), name.text()])); + return true; + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.instantiateType = function (type, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + if (type.isPrimitive()) { + return type; + } + + if (type.isError()) { + return type; + } + + if (typeParameterArgumentMap[type.pullSymbolID]) { + return typeParameterArgumentMap[type.pullSymbolID]; + } + + if (type.isTypeParameter() && type.isFunctionTypeParameter()) { + return type; + } + + type._resolveDeclaredSymbol(); + if (type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + return type; + }; + + PullTypeResolver.prototype.instantiateSignature = function (signature, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + if (!signature.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return signature; + } + + var typeArguments = []; + + TypeScript.nSpecializedSignaturesCreated++; + + var instantiatedSignature = new TypeScript.PullSignatureSymbol(signature.kind); + instantiatedSignature.setRootSymbol(signature); + + var typeParameters = signature.getTypeParameters(); + var constraint = null; + var typeParameter = null; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = typeParameters[i]; + + instantiatedSignature.addTypeParameter(typeParameter); + } + + instantiatedSignature.returnType = this.instantiateType((signature.returnType || this.semanticInfoChain.anyTypeSymbol), typeParameterArgumentMap, instantiateFunctionTypeParameters); + + if (instantiateFunctionTypeParameters) { + instantiatedSignature.functionType = this.instantiateType(signature.functionType, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + var parameters = signature.parameters; + var parameter = null; + + if (parameters) { + for (var j = 0; j < parameters.length; j++) { + parameter = new TypeScript.PullSymbol(parameters[j].name, 2048 /* Parameter */); + parameter.setRootSymbol(parameters[j]); + + if (parameters[j].isOptional) { + parameter.isOptional = true; + } + if (parameters[j].isVarArg) { + parameter.isVarArg = true; + instantiatedSignature.hasVarArgs = true; + } + instantiatedSignature.addParameter(parameter, parameter.isOptional); + + parameter.type = this.instantiateType(parameters[j].type, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + } + + return instantiatedSignature; + }; + PullTypeResolver.globalTypeCheckPhase = 0; + return PullTypeResolver; + })(); + TypeScript.PullTypeResolver = PullTypeResolver; + + var TypeComparisonInfo = (function () { + function TypeComparisonInfo(sourceComparisonInfo) { + this.onlyCaptureFirstError = false; + this.flags = 0 /* SuccessfulComparison */; + this.message = ""; + this.stringConstantVal = null; + this.indent = 1; + if (sourceComparisonInfo) { + this.flags = sourceComparisonInfo.flags; + this.onlyCaptureFirstError = sourceComparisonInfo.onlyCaptureFirstError; + this.stringConstantVal = sourceComparisonInfo.stringConstantVal; + this.indent = sourceComparisonInfo.indent + 1; + } + } + TypeComparisonInfo.prototype.indentString = function () { + var result = ""; + + for (var i = 0; i < this.indent; i++) { + result += "\t"; + } + + return result; + }; + + TypeComparisonInfo.prototype.addMessage = function (message) { + if (!this.onlyCaptureFirstError && this.message) { + this.message = this.message + TypeScript.newLine() + this.indentString() + message; + } else { + this.message = this.indentString() + message; + } + }; + return TypeComparisonInfo; + })(); + TypeScript.TypeComparisonInfo = TypeComparisonInfo; + + function getPropertyAssignmentNameTextFromIdentifier(identifier) { + if (identifier.kind() === 11 /* IdentifierName */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else if (identifier.kind() === 14 /* StringLiteral */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else if (identifier.kind() === 13 /* NumericLiteral */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + TypeScript.getPropertyAssignmentNameTextFromIdentifier = getPropertyAssignmentNameTextFromIdentifier; + + function isTypesOnlyLocation(ast) { + while (ast && ast.parent) { + switch (ast.parent.kind()) { + case 244 /* TypeAnnotation */: + return true; + case 127 /* TypeQuery */: + return false; + case 125 /* ConstructorType */: + var constructorType = ast.parent; + if (constructorType.type === ast) { + return true; + } + break; + case 123 /* FunctionType */: + var functionType = ast.parent; + if (functionType.type === ast) { + return true; + } + break; + case 239 /* Constraint */: + var constraint = ast.parent; + if (constraint.type === ast) { + return true; + } + break; + case 220 /* CastExpression */: + var castExpression = ast.parent; + return castExpression.type === ast; + case 230 /* ExtendsHeritageClause */: + case 231 /* ImplementsHeritageClause */: + return true; + case 228 /* TypeArgumentList */: + return true; + case 131 /* ClassDeclaration */: + case 128 /* InterfaceDeclaration */: + case 130 /* ModuleDeclaration */: + case 129 /* FunctionDeclaration */: + case 145 /* MethodSignature */: + case 212 /* MemberAccessExpression */: + case 242 /* Parameter */: + return false; + } + + ast = ast.parent; + } + + return false; + } + TypeScript.isTypesOnlyLocation = isTypesOnlyLocation; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.declCacheHit = 0; + TypeScript.declCacheMiss = 0; + TypeScript.symbolCacheHit = 0; + TypeScript.symbolCacheMiss = 0; + + var sentinalEmptyArray = []; + + var SemanticInfoChain = (function () { + function SemanticInfoChain(compiler, logger) { + this.compiler = compiler; + this.logger = logger; + this.documents = []; + this.fileNameToDocument = TypeScript.createIntrinsicsObject(); + this.anyTypeDecl = null; + this.booleanTypeDecl = null; + this.numberTypeDecl = null; + this.stringTypeDecl = null; + this.nullTypeDecl = null; + this.undefinedTypeDecl = null; + this.voidTypeDecl = null; + this.undefinedValueDecl = null; + this.anyTypeSymbol = null; + this.booleanTypeSymbol = null; + this.numberTypeSymbol = null; + this.stringTypeSymbol = null; + this.nullTypeSymbol = null; + this.undefinedTypeSymbol = null; + this.voidTypeSymbol = null; + this.undefinedValueSymbol = null; + this.emptyTypeSymbol = null; + this.astSymbolMap = []; + this.astAliasSymbolMap = []; + this.astCallResolutionDataMap = []; + this.declSymbolMap = []; + this.declSignatureSymbolMap = []; + this.declCache = null; + this.symbolCache = null; + this.fileNameToDiagnostics = null; + this._binder = null; + this._resolver = null; + this._topLevelDecls = null; + this._fileNames = null; + var span = new TypeScript.TextSpan(0, 0); + var globalDecl = new TypeScript.RootPullDecl("", "", 0 /* Global */, 0 /* None */, span, this, false); + this.documents[0] = new TypeScript.Document(this.compiler, this, "", [], null, 0 /* None */, 0, false, null, globalDecl); + + this.anyTypeDecl = new TypeScript.NormalPullDecl("any", "any", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.booleanTypeDecl = new TypeScript.NormalPullDecl("boolean", "boolean", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.numberTypeDecl = new TypeScript.NormalPullDecl("number", "number", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.stringTypeDecl = new TypeScript.NormalPullDecl("string", "string", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.voidTypeDecl = new TypeScript.NormalPullDecl("void", "void", 2 /* Primitive */, 0 /* None */, globalDecl, span); + + this.nullTypeDecl = new TypeScript.RootPullDecl("null", "", 2 /* Primitive */, 0 /* None */, span, this, false); + this.undefinedTypeDecl = new TypeScript.RootPullDecl("undefined", "", 2 /* Primitive */, 0 /* None */, span, this, false); + this.undefinedValueDecl = new TypeScript.NormalPullDecl("undefined", "undefined", 512 /* Variable */, 8 /* Ambient */, globalDecl, span); + + this.invalidate(); + } + SemanticInfoChain.prototype.getDocument = function (fileName) { + var document = this.fileNameToDocument[fileName]; + return document ? document : null; + }; + + SemanticInfoChain.prototype.lineMap = function (fileName) { + return this.getDocument(fileName).lineMap(); + }; + + SemanticInfoChain.prototype.fileNames = function () { + if (this._fileNames === null) { + this._fileNames = this.documents.slice(1).map(function (s) { + return s.fileName; + }); + } + + return this._fileNames; + }; + + SemanticInfoChain.prototype.bindPrimitiveSymbol = function (decl, newSymbol) { + newSymbol.addDeclaration(decl); + decl.setSymbol(newSymbol); + newSymbol.setResolved(); + + return newSymbol; + }; + + SemanticInfoChain.prototype.addPrimitiveTypeSymbol = function (decl) { + var newSymbol = new TypeScript.PullPrimitiveTypeSymbol(decl.name); + return this.bindPrimitiveSymbol(decl, newSymbol); + }; + + SemanticInfoChain.prototype.addPrimitiveValueSymbol = function (decl, type) { + var newSymbol = new TypeScript.PullSymbol(decl.name, 512 /* Variable */); + newSymbol.type = type; + return this.bindPrimitiveSymbol(decl, newSymbol); + }; + + SemanticInfoChain.prototype.resetGlobalSymbols = function () { + this.anyTypeSymbol = this.addPrimitiveTypeSymbol(this.anyTypeDecl); + this.booleanTypeSymbol = this.addPrimitiveTypeSymbol(this.booleanTypeDecl); + this.numberTypeSymbol = this.addPrimitiveTypeSymbol(this.numberTypeDecl); + this.stringTypeSymbol = this.addPrimitiveTypeSymbol(this.stringTypeDecl); + this.voidTypeSymbol = this.addPrimitiveTypeSymbol(this.voidTypeDecl); + this.nullTypeSymbol = this.addPrimitiveTypeSymbol(this.nullTypeDecl); + this.undefinedTypeSymbol = this.addPrimitiveTypeSymbol(this.undefinedTypeDecl); + this.undefinedValueSymbol = this.addPrimitiveValueSymbol(this.undefinedValueDecl, this.undefinedTypeSymbol); + + var span = new TypeScript.TextSpan(0, 0); + var emptyTypeDecl = new TypeScript.PullSynthesizedDecl("{}", "{}", 8388608 /* ObjectType */, 0 /* None */, null, span, this); + var emptyTypeSymbol = new TypeScript.PullTypeSymbol("{}", 8388608 /* ObjectType */); + emptyTypeDecl.setSymbol(emptyTypeSymbol); + emptyTypeSymbol.addDeclaration(emptyTypeDecl); + emptyTypeSymbol.setResolved(); + this.emptyTypeSymbol = emptyTypeSymbol; + }; + + SemanticInfoChain.prototype.addDocument = function (document) { + var fileName = document.fileName; + + var existingIndex = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) { + return u.fileName === fileName; + }); + if (existingIndex < 0) { + this.documents.push(document); + } else { + this.documents[existingIndex] = document; + } + + this.fileNameToDocument[fileName] = document; + + this.invalidate(); + }; + + SemanticInfoChain.prototype.removeDocument = function (fileName) { + TypeScript.Debug.assert(fileName !== "", "Can't remove the semantic info for the global decl."); + var index = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) { + return u.fileName === fileName; + }); + if (index > 0) { + this.fileNameToDocument[fileName] = undefined; + this.documents.splice(index, 1); + this.invalidate(); + } + }; + + SemanticInfoChain.prototype.getDeclPathCacheID = function (declPath, declKind) { + var cacheID = ""; + + for (var i = 0; i < declPath.length; i++) { + cacheID += "#" + declPath[i]; + } + + return cacheID + "#" + declKind.toString(); + }; + + SemanticInfoChain.prototype.findTopLevelSymbol = function (name, kind, doNotGoPastThisDecl) { + var cacheID = this.getDeclPathCacheID([name], kind); + + var symbol = this.symbolCache[cacheID]; + + if (!symbol) { + for (var i = 0, n = this.documents.length; i < n; i++) { + var topLevelDecl = this.documents[i].topLevelDecl(); + + var symbol = this.findTopLevelSymbolInDecl(topLevelDecl, name, kind, doNotGoPastThisDecl); + if (symbol) { + break; + } + + if (doNotGoPastThisDecl && topLevelDecl.name == doNotGoPastThisDecl.fileName()) { + return null; + } + } + + if (symbol) { + this.symbolCache[cacheID] = symbol; + } + } + + return symbol; + }; + + SemanticInfoChain.prototype.findTopLevelSymbolInDecl = function (topLevelDecl, name, kind, doNotGoPastThisDecl) { + var doNotGoPastThisPosition = doNotGoPastThisDecl && doNotGoPastThisDecl.fileName() === topLevelDecl.fileName() ? doNotGoPastThisDecl.ast().start() : -1; + + var foundDecls = topLevelDecl.searchChildDecls(name, kind); + + for (var j = 0; j < foundDecls.length; j++) { + var foundDecl = foundDecls[j]; + + if (doNotGoPastThisPosition !== -1 && foundDecl.ast() && foundDecl.ast().start() > doNotGoPastThisPosition) { + break; + } + + var symbol = foundDecls[j].getSymbol(); + if (symbol) { + return symbol; + } + } + + return null; + }; + + SemanticInfoChain.prototype.findExternalModule = function (id) { + id = TypeScript.normalizePath(id); + + var dtsFile = id + ".d.ts"; + var dtsCacheID = this.getDeclPathCacheID([dtsFile], 32 /* DynamicModule */); + var symbol = this.symbolCache[dtsCacheID]; + if (symbol) { + return symbol; + } + + var tsFile = id + ".ts"; + var tsCacheID = this.getDeclPathCacheID([tsFile], 32 /* DynamicModule */); + symbol = this.symbolCache[tsCacheID]; + if (symbol != undefined) { + return symbol; + } + + symbol = null; + for (var i = 0; i < this.documents.length; i++) { + var document = this.documents[i]; + var topLevelDecl = document.topLevelDecl(); + + if (topLevelDecl.isExternalModule()) { + var isDtsFile = document.fileName == dtsFile; + if (isDtsFile || document.fileName == tsFile) { + var dynamicModuleDecl = topLevelDecl.getChildDecls()[0]; + symbol = dynamicModuleDecl.getSymbol(); + this.symbolCache[dtsCacheID] = isDtsFile ? symbol : null; + this.symbolCache[tsCacheID] = !TypeScript.isDTSFile ? symbol : null; + return symbol; + } + } + } + + this.symbolCache[dtsCacheID] = null; + this.symbolCache[tsCacheID] = null; + + return symbol; + }; + + SemanticInfoChain.prototype.findAmbientExternalModuleInGlobalContext = function (id) { + var cacheID = this.getDeclPathCacheID([id], 32 /* DynamicModule */); + + var symbol = this.symbolCache[cacheID]; + if (symbol == undefined) { + symbol = null; + for (var i = 0; i < this.documents.length; i++) { + var document = this.documents[i]; + var topLevelDecl = document.topLevelDecl(); + + if (!topLevelDecl.isExternalModule()) { + var dynamicModules = topLevelDecl.searchChildDecls(id, 32 /* DynamicModule */); + if (dynamicModules.length) { + symbol = dynamicModules[0].getSymbol(); + break; + } + } + } + + this.symbolCache[cacheID] = symbol; + } + + return symbol; + }; + + SemanticInfoChain.prototype.findDecls = function (declPath, declKind) { + var cacheID = this.getDeclPathCacheID(declPath, declKind); + + if (declPath.length) { + var cachedDecls = this.declCache[cacheID]; + + if (cachedDecls && cachedDecls.length) { + TypeScript.declCacheHit++; + return cachedDecls; + } + } + + TypeScript.declCacheMiss++; + + var declsToSearch = this.topLevelDecls(); + + var decls = TypeScript.sentinelEmptyArray; + var path; + var foundDecls = TypeScript.sentinelEmptyArray; + var keepSearching = (declKind & 164 /* SomeContainer */) || (declKind & 16 /* Interface */); + + for (var i = 0; i < declPath.length; i++) { + path = declPath[i]; + decls = TypeScript.sentinelEmptyArray; + + for (var j = 0; j < declsToSearch.length; j++) { + foundDecls = declsToSearch[j].searchChildDecls(path, declKind); + + for (var k = 0; k < foundDecls.length; k++) { + if (decls == TypeScript.sentinelEmptyArray) { + decls = []; + } + decls[decls.length] = foundDecls[k]; + } + + if (foundDecls.length && !keepSearching) { + break; + } + } + + declsToSearch = decls; + + if (!declsToSearch) { + break; + } + } + + if (decls.length) { + this.declCache[cacheID] = decls; + } + + return decls; + }; + + SemanticInfoChain.prototype.findDeclsFromPath = function (declPath, declKind) { + var declString = []; + + for (var i = 0, n = declPath.length; i < n; i++) { + if (declPath[i].kind & 1 /* Script */) { + continue; + } + + declString.push(declPath[i].name); + } + + return this.findDecls(declString, declKind); + }; + + SemanticInfoChain.prototype.findSymbol = function (declPath, declType) { + var cacheID = this.getDeclPathCacheID(declPath, declType); + + if (declPath.length) { + var cachedSymbol = this.symbolCache[cacheID]; + + if (cachedSymbol) { + TypeScript.symbolCacheHit++; + return cachedSymbol; + } + } + + TypeScript.symbolCacheMiss++; + + var decls = this.findDecls(declPath, declType); + var symbol = null; + + if (decls.length) { + var decl = decls[0]; + if (TypeScript.hasFlag(declType, 164 /* SomeContainer */)) { + var valueDecl = decl.getValueDecl(); + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + } + + symbol = decl.getSymbol(); + + if (symbol) { + this.symbolCache[cacheID] = symbol; + } + } + + return symbol; + }; + + SemanticInfoChain.prototype.cacheGlobalSymbol = function (symbol, kind) { + var cacheID1 = this.getDeclPathCacheID([symbol.name], kind); + var cacheID2 = this.getDeclPathCacheID([symbol.name], symbol.kind); + + if (!this.symbolCache[cacheID1]) { + this.symbolCache[cacheID1] = symbol; + } + + if (!this.symbolCache[cacheID2]) { + this.symbolCache[cacheID2] = symbol; + } + }; + + SemanticInfoChain.prototype.invalidate = function (oldSettings, newSettings) { + if (typeof oldSettings === "undefined") { oldSettings = null; } + if (typeof newSettings === "undefined") { newSettings = null; } + TypeScript.PullTypeResolver.globalTypeCheckPhase++; + + var cleanStart = new Date().getTime(); + + this.astSymbolMap.length = 0; + this.astAliasSymbolMap.length = 0; + this.astCallResolutionDataMap.length = 0; + + this.declCache = TypeScript.createIntrinsicsObject(); + this.symbolCache = TypeScript.createIntrinsicsObject(); + this.fileNameToDiagnostics = TypeScript.createIntrinsicsObject(); + this._binder = null; + this._resolver = null; + this._topLevelDecls = null; + this._fileNames = null; + + this.declSymbolMap.length = 0; + this.declSignatureSymbolMap.length = 0; + + if (oldSettings && newSettings) { + if (this.settingsChangeAffectsSyntax(oldSettings, newSettings)) { + for (var i = 1, n = this.documents.length; i < n; i++) { + this.documents[i].invalidate(); + } + } + } + + TypeScript.pullSymbolID = 0; + TypeScript.globalTyvarID = 0; + + this.resetGlobalSymbols(); + + var cleanEnd = new Date().getTime(); + }; + + SemanticInfoChain.prototype.settingsChangeAffectsSyntax = function (before, after) { + return before.allowAutomaticSemicolonInsertion() !== after.allowAutomaticSemicolonInsertion() || before.codeGenTarget() !== after.codeGenTarget() || before.propagateEnumConstants() != after.propagateEnumConstants(); + }; + + SemanticInfoChain.prototype.setSymbolForAST = function (ast, symbol) { + this.astSymbolMap[ast.syntaxID()] = symbol; + }; + + SemanticInfoChain.prototype.getSymbolForAST = function (ast) { + return this.astSymbolMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.setAliasSymbolForAST = function (ast, symbol) { + this.astAliasSymbolMap[ast.syntaxID()] = symbol; + }; + + SemanticInfoChain.prototype.getAliasSymbolForAST = function (ast) { + return this.astAliasSymbolMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.getCallResolutionDataForAST = function (ast) { + return this.astCallResolutionDataMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.setCallResolutionDataForAST = function (ast, callResolutionData) { + if (callResolutionData) { + this.astCallResolutionDataMap[ast.syntaxID()] = callResolutionData; + } + }; + + SemanticInfoChain.prototype.setSymbolForDecl = function (decl, symbol) { + this.declSymbolMap[decl.declID] = symbol; + }; + + SemanticInfoChain.prototype.getSymbolForDecl = function (decl) { + return this.declSymbolMap[decl.declID]; + }; + + SemanticInfoChain.prototype.setSignatureSymbolForDecl = function (decl, signatureSymbol) { + this.declSignatureSymbolMap[decl.declID] = signatureSymbol; + }; + + SemanticInfoChain.prototype.getSignatureSymbolForDecl = function (decl) { + return this.declSignatureSymbolMap[decl.declID]; + }; + + SemanticInfoChain.prototype.addDiagnostic = function (diagnostic) { + var fileName = diagnostic.fileName(); + var diagnostics = this.fileNameToDiagnostics[fileName]; + if (!diagnostics) { + diagnostics = []; + this.fileNameToDiagnostics[fileName] = diagnostics; + } + + diagnostics.push(diagnostic); + }; + + SemanticInfoChain.prototype.getDiagnostics = function (fileName) { + var diagnostics = this.fileNameToDiagnostics[fileName]; + return diagnostics ? diagnostics : []; + }; + + SemanticInfoChain.prototype.getBinder = function () { + if (!this._binder) { + this._binder = new TypeScript.PullSymbolBinder(this); + } + + return this._binder; + }; + + SemanticInfoChain.prototype.getResolver = function () { + if (!this._resolver) { + this._resolver = new TypeScript.PullTypeResolver(this.compiler.compilationSettings(), this); + } + + return this._resolver; + }; + + SemanticInfoChain.prototype.addSyntheticIndexSignature = function (containingDecl, containingSymbol, ast, indexParamName, indexParamType, returnType) { + var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + var indexParameterSymbol = new TypeScript.PullSymbol(indexParamName, 2048 /* Parameter */); + indexParameterSymbol.type = indexParamType; + indexSignature.addParameter(indexParameterSymbol); + indexSignature.returnType = returnType; + indexSignature.setResolved(); + indexParameterSymbol.setResolved(); + + containingSymbol.addIndexSignature(indexSignature); + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + var indexSigDecl = new TypeScript.PullSynthesizedDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, containingDecl, span, containingDecl.semanticInfoChain()); + var indexParamDecl = new TypeScript.PullSynthesizedDecl(indexParamName, indexParamName, 2048 /* Parameter */, 0 /* None */, indexSigDecl, span, containingDecl.semanticInfoChain()); + indexSigDecl.setSignatureSymbol(indexSignature); + indexParamDecl.setSymbol(indexParameterSymbol); + indexSignature.addDeclaration(indexSigDecl); + indexParameterSymbol.addDeclaration(indexParamDecl); + }; + + SemanticInfoChain.prototype.getDeclForAST = function (ast) { + var document = this.getDocument(ast.fileName()); + + if (document) { + return document._getDeclForAST(ast); + } + + return null; + }; + + SemanticInfoChain.prototype.getEnclosingDecl = function (ast) { + return this.getDocument(ast.fileName()).getEnclosingDecl(ast); + }; + + SemanticInfoChain.prototype.setDeclForAST = function (ast, decl) { + this.getDocument(decl.fileName())._setDeclForAST(ast, decl); + }; + + SemanticInfoChain.prototype.getASTForDecl = function (decl) { + var document = this.getDocument(decl.fileName()); + if (document) { + return document._getASTForDecl(decl); + } + + return null; + }; + + SemanticInfoChain.prototype.setASTForDecl = function (decl, ast) { + this.getDocument(decl.fileName())._setASTForDecl(decl, ast); + }; + + SemanticInfoChain.prototype.topLevelDecl = function (fileName) { + var document = this.getDocument(fileName); + if (document) { + return document.topLevelDecl(); + } + + return null; + }; + + SemanticInfoChain.prototype.topLevelDecls = function () { + if (!this._topLevelDecls) { + this._topLevelDecls = TypeScript.ArrayUtilities.select(this.documents, function (u) { + return u.topLevelDecl(); + }); + } + + return this._topLevelDecls; + }; + + SemanticInfoChain.prototype.addDiagnosticFromAST = function (ast, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + this.addDiagnostic(this.diagnosticFromAST(ast, diagnosticKey, arguments)); + }; + + SemanticInfoChain.prototype.diagnosticFromAST = function (ast, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + return new TypeScript.Diagnostic(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width(), diagnosticKey, arguments); + }; + return SemanticInfoChain; + })(); + TypeScript.SemanticInfoChain = SemanticInfoChain; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var DeclCollectionContext = (function () { + function DeclCollectionContext(document, semanticInfoChain, propagateEnumConstants) { + this.document = document; + this.semanticInfoChain = semanticInfoChain; + this.propagateEnumConstants = propagateEnumConstants; + this.isDeclareFile = false; + this.parentChain = []; + } + DeclCollectionContext.prototype.getParent = function () { + return this.parentChain ? this.parentChain[this.parentChain.length - 1] : null; + }; + + DeclCollectionContext.prototype.pushParent = function (parentDecl) { + if (parentDecl) { + this.parentChain[this.parentChain.length] = parentDecl; + } + }; + + DeclCollectionContext.prototype.popParent = function () { + this.parentChain.length--; + }; + return DeclCollectionContext; + })(); + + function containingModuleHasExportAssignment(ast) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + var moduleDecl = ast; + return moduleDecl.moduleElements.any(function (m) { + return m.kind() === 134 /* ExportAssignment */; + }); + } else if (ast.kind() === 120 /* SourceUnit */) { + var sourceUnit = ast; + return sourceUnit.moduleElements.any(function (m) { + return m.kind() === 134 /* ExportAssignment */; + }); + } + + ast = ast.parent; + } + + return false; + } + + function isParsingAmbientModule(ast, context) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + if (TypeScript.hasModifier(ast.modifiers, 8 /* Ambient */)) { + return true; + } + } + + ast = ast.parent; + } + + return false; + } + + function preCollectImportDecls(ast, context) { + var importDecl = ast; + var declFlags = 0 /* None */; + var span = TypeScript.TextSpan.fromBounds(importDecl.start(), importDecl.end()); + + var parent = context.getParent(); + + if (TypeScript.hasModifier(importDecl.modifiers, 1 /* Exported */) && !containingModuleHasExportAssignment(ast)) { + declFlags |= 1 /* Exported */; + } + + var decl = new TypeScript.NormalPullDecl(importDecl.identifier.valueText(), importDecl.identifier.text(), 128 /* TypeAlias */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + } + + function preCollectScriptDecls(sourceUnit, context) { + var span = TypeScript.TextSpan.fromBounds(sourceUnit.start(), sourceUnit.end()); + + var fileName = sourceUnit.fileName(); + + var isExternalModule = context.document.isExternalModule(); + + var decl = new TypeScript.RootPullDecl(fileName, fileName, 1 /* Script */, 0 /* None */, span, context.semanticInfoChain, isExternalModule); + context.semanticInfoChain.setDeclForAST(sourceUnit, decl); + context.semanticInfoChain.setASTForDecl(decl, sourceUnit); + + context.isDeclareFile = context.document.isDeclareFile(); + + context.pushParent(decl); + + if (isExternalModule) { + var declFlags = 1 /* Exported */; + if (TypeScript.isDTSFile(fileName)) { + declFlags |= 8 /* Ambient */; + } + + var moduleContainsExecutableCode = containsExecutableCode(sourceUnit.moduleElements); + var kind = 32 /* DynamicModule */; + var span = TypeScript.TextSpan.fromBounds(sourceUnit.start(), sourceUnit.end()); + var valueText = TypeScript.quoteStr(fileName); + + var decl = new TypeScript.NormalPullDecl(valueText, fileName, kind, declFlags, context.getParent(), span); + + context.semanticInfoChain.setASTForDecl(decl, sourceUnit); + + context.semanticInfoChain.setDeclForAST(sourceUnit, decl); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, sourceUnit, context); + } + + context.pushParent(decl); + } + } + + function preCollectEnumDecls(enumDecl, context) { + var declFlags = 0 /* None */; + var enumName = enumDecl.identifier.valueText(); + var kind = 4 /* Container */; + + if ((TypeScript.hasModifier(enumDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(enumDecl, context)) && !containingModuleHasExportAssignment(enumDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(enumDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(enumDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + declFlags |= 4096 /* Enum */; + kind = 64 /* Enum */; + + var span = TypeScript.TextSpan.fromBounds(enumDecl.start(), enumDecl.end()); + + var enumDeclaration = new TypeScript.NormalPullDecl(enumName, enumDecl.identifier.text(), kind, declFlags, context.getParent(), span); + context.semanticInfoChain.setDeclForAST(enumDecl, enumDeclaration); + context.semanticInfoChain.setASTForDecl(enumDeclaration, enumDecl); + + var enumIndexerDecl = new TypeScript.NormalPullDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, enumDeclaration, span); + var enumIndexerParameter = new TypeScript.NormalPullDecl("x", "x", 2048 /* Parameter */, 0 /* None */, enumIndexerDecl, span); + + var valueDecl = new TypeScript.NormalPullDecl(enumDeclaration.name, enumDeclaration.getDisplayName(), 512 /* Variable */, enumDeclaration.flags, context.getParent(), enumDeclaration.getSpan()); + enumDeclaration.setValueDecl(valueDecl); + context.semanticInfoChain.setASTForDecl(valueDecl, enumDecl); + + context.pushParent(enumDeclaration); + } + + function createEnumElementDecls(propertyDecl, context) { + var parent = context.getParent(); + + var span = TypeScript.TextSpan.fromBounds(propertyDecl.start(), propertyDecl.end()); + + var decl = new TypeScript.PullEnumElementDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), parent, span); + context.semanticInfoChain.setDeclForAST(propertyDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyDecl); + } + + function preCollectModuleDecls(moduleDecl, context) { + var declFlags = 0 /* None */; + + var moduleContainsExecutableCode = containsExecutableCode(moduleDecl.moduleElements); + + var isDynamic = moduleDecl.stringLiteral !== null; + + if ((TypeScript.hasModifier(moduleDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(moduleDecl, context)) && !containingModuleHasExportAssignment(moduleDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(moduleDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(moduleDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var kind = isDynamic ? 32 /* DynamicModule */ : 4 /* Container */; + + var span = TypeScript.TextSpan.fromBounds(moduleDecl.start(), moduleDecl.end()); + + if (moduleDecl.stringLiteral) { + var valueText = TypeScript.quoteStr(moduleDecl.stringLiteral.valueText()); + var text = moduleDecl.stringLiteral.text(); + + var decl = new TypeScript.NormalPullDecl(valueText, text, kind, declFlags, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(moduleDecl, decl); + context.semanticInfoChain.setDeclForAST(moduleDecl.stringLiteral, decl); + context.semanticInfoChain.setASTForDecl(decl, moduleDecl.stringLiteral); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, moduleDecl.stringLiteral, context); + } + + context.pushParent(decl); + } else { + var moduleNames = getModuleNames(moduleDecl.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + var moduleName = moduleNames[i]; + + var specificFlags = declFlags; + if (i > 0) { + specificFlags |= 1 /* Exported */; + } + + var decl = new TypeScript.NormalPullDecl(moduleName.valueText(), moduleName.text(), kind, specificFlags, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(moduleDecl, decl); + context.semanticInfoChain.setDeclForAST(moduleName, decl); + context.semanticInfoChain.setASTForDecl(decl, moduleName); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, moduleName, context); + } + + context.pushParent(decl); + } + } + } + + function getModuleNames(name, result) { + result = result || []; + + if (name.kind() === 121 /* QualifiedName */) { + getModuleNames(name.left, result); + result.push(name.right); + } else { + result.push(name); + } + + return result; + } + TypeScript.getModuleNames = getModuleNames; + + function createModuleVariableDecl(decl, moduleNameAST, context) { + decl.setFlags(decl.flags | getInitializationFlag(decl)); + + var valueDecl = new TypeScript.NormalPullDecl(decl.name, decl.getDisplayName(), 512 /* Variable */, decl.flags, context.getParent(), decl.getSpan()); + decl.setValueDecl(valueDecl); + context.semanticInfoChain.setASTForDecl(valueDecl, moduleNameAST); + } + + function containsExecutableCode(members) { + for (var i = 0, n = members.childCount(); i < n; i++) { + var member = members.childAt(i); + + if (member.kind() === 130 /* ModuleDeclaration */) { + var moduleDecl = member; + + if (containsExecutableCode(moduleDecl.moduleElements)) { + return true; + } + } else if (member.kind() !== 128 /* InterfaceDeclaration */ && member.kind() !== 133 /* ImportDeclaration */) { + return true; + } + } + + return false; + } + + function preCollectClassDecls(classDecl, context) { + var declFlags = 0 /* None */; + var constructorDeclKind = 512 /* Variable */; + + if ((TypeScript.hasModifier(classDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(classDecl, context)) && !containingModuleHasExportAssignment(classDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(classDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(classDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var span = TypeScript.TextSpan.fromBounds(classDecl.start(), classDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 8 /* Class */, declFlags, parent, span); + + var constructorDecl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), constructorDeclKind, declFlags | 16384 /* ClassConstructorVariable */, parent, span); + + decl.setValueDecl(constructorDecl); + + context.semanticInfoChain.setDeclForAST(classDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, classDecl); + context.semanticInfoChain.setASTForDecl(constructorDecl, classDecl); + + context.pushParent(decl); + } + + function preCollectObjectTypeDecls(objectType, context) { + if (objectType.parent.kind() === 128 /* InterfaceDeclaration */) { + return; + } + + var declFlags = 0 /* None */; + + var span = TypeScript.TextSpan.fromBounds(objectType.start(), objectType.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", 8388608 /* ObjectType */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(objectType, decl); + context.semanticInfoChain.setASTForDecl(decl, objectType); + + context.pushParent(decl); + } + + function preCollectInterfaceDecls(interfaceDecl, context) { + var declFlags = 0 /* None */; + + if ((TypeScript.hasModifier(interfaceDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(interfaceDecl, context)) && !containingModuleHasExportAssignment(interfaceDecl)) { + declFlags |= 1 /* Exported */; + } + + var span = TypeScript.TextSpan.fromBounds(interfaceDecl.start(), interfaceDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(interfaceDecl.identifier.valueText(), interfaceDecl.identifier.text(), 16 /* Interface */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(interfaceDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, interfaceDecl); + + context.pushParent(decl); + } + + function preCollectParameterDecl(argDecl, context) { + var declFlags = 0 /* None */; + + if (TypeScript.hasModifier(argDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (argDecl.questionToken !== null || argDecl.equalsValueClause !== null || argDecl.dotDotDotToken !== null) { + declFlags |= 128 /* Optional */; + } + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var span = TypeScript.TextSpan.fromBounds(argDecl.start(), argDecl.end()); + + var decl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 2048 /* Parameter */, declFlags, parent, span); + + if (argDecl.equalsValueClause) { + parent.flags |= 33554432 /* HasDefaultArgs */; + } + + if (parent.kind == 32768 /* ConstructorMethod */) { + decl.setFlag(67108864 /* ConstructorParameter */); + } + + var isPublicOrPrivate = TypeScript.hasModifier(argDecl.modifiers, 4 /* Public */ | 2 /* Private */); + var isInConstructor = parent.kind === 32768 /* ConstructorMethod */; + if (isPublicOrPrivate && isInConstructor) { + var parentsParent = context.parentChain[context.parentChain.length - 2]; + var propDecl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 4096 /* Property */, declFlags, parentsParent, span); + propDecl.setValueDecl(decl); + decl.setFlag(8388608 /* PropertyParameter */); + propDecl.setFlag(8388608 /* PropertyParameter */); + + if (parent.kind == 32768 /* ConstructorMethod */) { + propDecl.setFlag(67108864 /* ConstructorParameter */); + } + + context.semanticInfoChain.setASTForDecl(decl, argDecl); + context.semanticInfoChain.setASTForDecl(propDecl, argDecl); + context.semanticInfoChain.setDeclForAST(argDecl, propDecl); + } else { + context.semanticInfoChain.setASTForDecl(decl, argDecl); + context.semanticInfoChain.setDeclForAST(argDecl, decl); + } + + parent.addVariableDeclToGroup(decl); + } + + function preCollectTypeParameterDecl(typeParameterDecl, context) { + var declFlags = 0 /* None */; + + var span = TypeScript.TextSpan.fromBounds(typeParameterDecl.start(), typeParameterDecl.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(typeParameterDecl.identifier.valueText(), typeParameterDecl.identifier.text(), 8192 /* TypeParameter */, declFlags, parent, span); + context.semanticInfoChain.setASTForDecl(decl, typeParameterDecl); + context.semanticInfoChain.setDeclForAST(typeParameterDecl, decl); + } + + function createPropertySignature(propertyDecl, context) { + var declFlags = 4 /* Public */; + var parent = context.getParent(); + var declType = 4096 /* Property */; + + if (propertyDecl.questionToken !== null) { + declFlags |= 128 /* Optional */; + } + + var span = TypeScript.TextSpan.fromBounds(propertyDecl.start(), propertyDecl.end()); + + var decl = new TypeScript.NormalPullDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(propertyDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyDecl); + } + + function createMemberVariableDeclaration(memberDecl, context) { + var declFlags = 0 /* None */; + var declType = 4096 /* Property */; + + if (TypeScript.hasModifier(memberDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (TypeScript.hasModifier(memberDecl.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + var span = TypeScript.TextSpan.fromBounds(memberDecl.start(), memberDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(memberDecl.variableDeclarator.propertyName.valueText(), memberDecl.variableDeclarator.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(memberDecl, decl); + context.semanticInfoChain.setDeclForAST(memberDecl.variableDeclarator, decl); + context.semanticInfoChain.setASTForDecl(decl, memberDecl); + } + + function createVariableDeclaration(varDecl, context) { + var declFlags = 0 /* None */; + var declType = 512 /* Variable */; + + var modifiers = TypeScript.getVariableDeclaratorModifiers(varDecl); + if ((TypeScript.hasModifier(modifiers, 1 /* Exported */) || isParsingAmbientModule(varDecl, context)) && !containingModuleHasExportAssignment(varDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(modifiers, 8 /* Ambient */) || isParsingAmbientModule(varDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var span = TypeScript.TextSpan.fromBounds(varDecl.start(), varDecl.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(varDecl.propertyName.valueText(), varDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(varDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, varDecl); + + if (parent) { + parent.addVariableDeclToGroup(decl); + } + } + + function preCollectVarDecls(ast, context) { + if (ast.parent.kind() === 136 /* MemberVariableDeclaration */) { + return; + } + + var varDecl = ast; + createVariableDeclaration(varDecl, context); + } + + function createFunctionTypeDeclaration(functionTypeDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 16777216 /* FunctionType */; + + var span = TypeScript.TextSpan.fromBounds(functionTypeDeclAST.start(), functionTypeDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(functionTypeDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, functionTypeDeclAST); + + context.pushParent(decl); + } + + function createConstructorTypeDeclaration(constructorTypeDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 33554432 /* ConstructorType */; + + var span = TypeScript.TextSpan.fromBounds(constructorTypeDeclAST.start(), constructorTypeDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructorTypeDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructorTypeDeclAST); + + context.pushParent(decl); + } + + function createFunctionDeclaration(funcDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 16384 /* Function */; + + if ((TypeScript.hasModifier(funcDeclAST.modifiers, 1 /* Exported */) || isParsingAmbientModule(funcDeclAST, context)) && !containingModuleHasExportAssignment(funcDeclAST)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(funcDeclAST.modifiers, 8 /* Ambient */) || isParsingAmbientModule(funcDeclAST, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + if (!funcDeclAST.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(funcDeclAST.start(), funcDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(funcDeclAST.identifier.valueText(), funcDeclAST.identifier.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(funcDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, funcDeclAST); + + context.pushParent(decl); + } + + function createAnyFunctionExpressionDeclaration(functionExpressionDeclAST, id, context, displayName) { + if (typeof displayName === "undefined") { displayName = null; } + var declFlags = 0 /* None */; + + if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */ || functionExpressionDeclAST.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + declFlags |= 8192 /* ArrowFunction */; + } + + var span = TypeScript.TextSpan.fromBounds(functionExpressionDeclAST.start(), functionExpressionDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var name = id ? id.text() : ""; + var displayNameText = displayName ? displayName.text() : ""; + var decl = new TypeScript.PullFunctionExpressionDecl(name, declFlags, parent, span, displayNameText); + context.semanticInfoChain.setDeclForAST(functionExpressionDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, functionExpressionDeclAST); + + context.pushParent(decl); + + if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */) { + var simpleArrow = functionExpressionDeclAST; + var declFlags = 4 /* Public */; + + var parent = context.getParent(); + + if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var span = TypeScript.TextSpan.fromBounds(simpleArrow.identifier.start(), simpleArrow.identifier.end()); + + var decl = new TypeScript.NormalPullDecl(simpleArrow.identifier.valueText(), simpleArrow.identifier.text(), 2048 /* Parameter */, declFlags, parent, span); + + context.semanticInfoChain.setASTForDecl(decl, simpleArrow.identifier); + context.semanticInfoChain.setDeclForAST(simpleArrow.identifier, decl); + + parent.addVariableDeclToGroup(decl); + } + } + + function createMemberFunctionDeclaration(funcDecl, context) { + var declFlags = 0 /* None */; + var declType = 65536 /* Method */; + + if (TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (!funcDecl.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(funcDecl.start(), funcDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(funcDecl.propertyName.valueText(), funcDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(funcDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, funcDecl); + + context.pushParent(decl); + } + + function createIndexSignatureDeclaration(indexSignatureDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 4194304 /* IndexSignature */; + + var span = TypeScript.TextSpan.fromBounds(indexSignatureDeclAST.start(), indexSignatureDeclAST.end()); + + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(indexSignatureDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, indexSignatureDeclAST); + + context.pushParent(decl); + } + + function createCallSignatureDeclaration(callSignature, context) { + var isChildOfObjectType = callSignature.parent && callSignature.parent.parent && callSignature.parent.kind() === 2 /* SeparatedList */ && callSignature.parent.parent.kind() === 122 /* ObjectType */; + + if (!isChildOfObjectType) { + return; + } + + var declFlags = 2048 /* Signature */; + var declType = 1048576 /* CallSignature */; + + var span = TypeScript.TextSpan.fromBounds(callSignature.start(), callSignature.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(callSignature, decl); + context.semanticInfoChain.setASTForDecl(decl, callSignature); + + context.pushParent(decl); + } + + function createMethodSignatureDeclaration(method, context) { + var declFlags = 0 /* None */; + var declType = 65536 /* Method */; + + declFlags |= 4 /* Public */; + declFlags |= 2048 /* Signature */; + + if (method.questionToken !== null) { + declFlags |= 128 /* Optional */; + } + + var span = TypeScript.TextSpan.fromBounds(method.start(), method.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(method.propertyName.valueText(), method.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(method, decl); + context.semanticInfoChain.setASTForDecl(decl, method); + + context.pushParent(decl); + } + + function createConstructSignatureDeclaration(constructSignatureDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 2097152 /* ConstructSignature */; + + var span = TypeScript.TextSpan.fromBounds(constructSignatureDeclAST.start(), constructSignatureDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructSignatureDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructSignatureDeclAST); + + context.pushParent(decl); + } + + function createClassConstructorDeclaration(constructorDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 32768 /* ConstructorMethod */; + + if (!constructorDeclAST.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(constructorDeclAST.start(), constructorDeclAST.end()); + + var parent = context.getParent(); + + if (parent) { + var parentFlags = parent.flags; + + if (parentFlags & 1 /* Exported */) { + declFlags |= 1 /* Exported */; + } + } + + var decl = new TypeScript.NormalPullDecl(parent.name, parent.getDisplayName(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructorDeclAST); + + context.pushParent(decl); + } + + function createGetAccessorDeclaration(getAccessorDeclAST, context) { + var declFlags = 4 /* Public */; + var declType = 262144 /* GetAccessor */; + + if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + var span = TypeScript.TextSpan.fromBounds(getAccessorDeclAST.start(), getAccessorDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(getAccessorDeclAST.propertyName.valueText(), getAccessorDeclAST.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(getAccessorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, getAccessorDeclAST); + + context.pushParent(decl); + } + + function createFunctionExpressionDeclaration(expression, context) { + createAnyFunctionExpressionDeclaration(expression, expression.identifier, context); + } + + function createSetAccessorDeclaration(setAccessorDeclAST, context) { + var declFlags = 4 /* Public */; + var declType = 524288 /* SetAccessor */; + + if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + var span = TypeScript.TextSpan.fromBounds(setAccessorDeclAST.start(), setAccessorDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(setAccessorDeclAST.propertyName.valueText(), setAccessorDeclAST.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(setAccessorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, setAccessorDeclAST); + + context.pushParent(decl); + } + + function preCollectCatchDecls(ast, context) { + var declFlags = 0 /* None */; + var declType = 268435456 /* CatchBlock */; + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + + var declFlags = 0 /* None */; + var declType = 1024 /* CatchVariable */; + + var span = TypeScript.TextSpan.fromBounds(ast.identifier.start(), ast.identifier.end()); + + var parent = context.getParent(); + + if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(ast.identifier.valueText(), ast.identifier.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast.identifier, decl); + context.semanticInfoChain.setASTForDecl(decl, ast.identifier); + + if (parent) { + parent.addVariableDeclToGroup(decl); + } + } + + function preCollectWithDecls(ast, context) { + var declFlags = 0 /* None */; + var declType = 134217728 /* WithBlock */; + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + } + + function preCollectObjectLiteralDecls(ast, context) { + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + var decl = new TypeScript.NormalPullDecl("", "", 256 /* ObjectLiteral */, 0 /* None */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + } + + function preCollectSimplePropertyAssignmentDecls(propertyAssignment, context) { + var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName); + var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end()); + + var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(propertyAssignment, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyAssignment); + } + + function preCollectFunctionPropertyAssignmentDecls(propertyAssignment, context) { + var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName); + var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end()); + + var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(propertyAssignment, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyAssignment); + + createAnyFunctionExpressionDeclaration(propertyAssignment, propertyAssignment.propertyName, context, propertyAssignment.propertyName); + } + + function preCollectDecls(ast, context) { + switch (ast.kind()) { + case 120 /* SourceUnit */: + preCollectScriptDecls(ast, context); + break; + case 132 /* EnumDeclaration */: + preCollectEnumDecls(ast, context); + break; + case 243 /* EnumElement */: + createEnumElementDecls(ast, context); + break; + case 130 /* ModuleDeclaration */: + preCollectModuleDecls(ast, context); + break; + case 131 /* ClassDeclaration */: + preCollectClassDecls(ast, context); + break; + case 128 /* InterfaceDeclaration */: + preCollectInterfaceDecls(ast, context); + break; + case 122 /* ObjectType */: + preCollectObjectTypeDecls(ast, context); + break; + case 242 /* Parameter */: + preCollectParameterDecl(ast, context); + break; + case 136 /* MemberVariableDeclaration */: + createMemberVariableDeclaration(ast, context); + break; + case 141 /* PropertySignature */: + createPropertySignature(ast, context); + break; + case 225 /* VariableDeclarator */: + preCollectVarDecls(ast, context); + break; + case 137 /* ConstructorDeclaration */: + createClassConstructorDeclaration(ast, context); + break; + case 139 /* GetAccessor */: + createGetAccessorDeclaration(ast, context); + break; + case 140 /* SetAccessor */: + createSetAccessorDeclaration(ast, context); + break; + case 222 /* FunctionExpression */: + createFunctionExpressionDeclaration(ast, context); + break; + case 135 /* MemberFunctionDeclaration */: + createMemberFunctionDeclaration(ast, context); + break; + case 144 /* IndexSignature */: + createIndexSignatureDeclaration(ast, context); + break; + case 123 /* FunctionType */: + createFunctionTypeDeclaration(ast, context); + break; + case 125 /* ConstructorType */: + createConstructorTypeDeclaration(ast, context); + break; + case 142 /* CallSignature */: + createCallSignatureDeclaration(ast, context); + break; + case 143 /* ConstructSignature */: + createConstructSignatureDeclaration(ast, context); + break; + case 145 /* MethodSignature */: + createMethodSignatureDeclaration(ast, context); + break; + case 129 /* FunctionDeclaration */: + createFunctionDeclaration(ast, context); + break; + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + createAnyFunctionExpressionDeclaration(ast, null, context); + break; + case 133 /* ImportDeclaration */: + preCollectImportDecls(ast, context); + break; + case 238 /* TypeParameter */: + preCollectTypeParameterDecl(ast, context); + break; + case 236 /* CatchClause */: + preCollectCatchDecls(ast, context); + break; + case 163 /* WithStatement */: + preCollectWithDecls(ast, context); + break; + case 215 /* ObjectLiteralExpression */: + preCollectObjectLiteralDecls(ast, context); + break; + case 240 /* SimplePropertyAssignment */: + preCollectSimplePropertyAssignmentDecls(ast, context); + break; + case 241 /* FunctionPropertyAssignment */: + preCollectFunctionPropertyAssignmentDecls(ast, context); + break; + } + } + + function isContainer(decl) { + return decl.kind === 4 /* Container */ || decl.kind === 32 /* DynamicModule */ || decl.kind === 64 /* Enum */; + } + + function getInitializationFlag(decl) { + if (decl.kind & 4 /* Container */) { + return 32768 /* InitializedModule */; + } else if (decl.kind & 32 /* DynamicModule */) { + return 65536 /* InitializedDynamicModule */; + } + + return 0 /* None */; + } + + function hasInitializationFlag(decl) { + var kind = decl.kind; + + if (kind & 4 /* Container */) { + return (decl.flags & 32768 /* InitializedModule */) !== 0; + } else if (kind & 32 /* DynamicModule */) { + return (decl.flags & 65536 /* InitializedDynamicModule */) !== 0; + } + + return false; + } + + function postCollectDecls(ast, context) { + var currentDecl = context.getParent(); + + if (ast.kind() === 11 /* IdentifierName */ || ast.kind() === 14 /* StringLiteral */) { + if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) { + return; + } + } + + if (ast.kind() === 130 /* ModuleDeclaration */) { + var moduleDeclaration = ast; + if (moduleDeclaration.stringLiteral) { + TypeScript.Debug.assert(currentDecl.ast() === moduleDeclaration.stringLiteral); + context.popParent(); + } else { + var moduleNames = getModuleNames(moduleDeclaration.name); + for (var i = moduleNames.length - 1; i >= 0; i--) { + var moduleName = moduleNames[i]; + TypeScript.Debug.assert(currentDecl.ast() === moduleName); + context.popParent(); + currentDecl = context.getParent(); + } + } + } + + if (ast.kind() === 132 /* EnumDeclaration */) { + computeEnumElementConstantValues(ast, currentDecl, context); + } + + while (currentDecl.getParentDecl() && currentDecl.ast() === ast) { + context.popParent(); + currentDecl = context.getParent(); + } + } + + function computeEnumElementConstantValues(ast, enumDecl, context) { + TypeScript.Debug.assert(enumDecl.kind === 64 /* Enum */); + + var isAmbientEnum = TypeScript.hasFlag(enumDecl.flags, 8 /* Ambient */); + var inConstantSection = !isAmbientEnum; + var currentConstantValue = 0; + var enumMemberDecls = enumDecl.getChildDecls(); + + for (var i = 0, n = ast.enumElements.nonSeparatorCount(); i < n; i++) { + var enumElement = ast.enumElements.nonSeparatorAt(i); + var enumElementDecl = TypeScript.ArrayUtilities.first(enumMemberDecls, function (d) { + return context.semanticInfoChain.getASTForDecl(d) === enumElement; + }); + + TypeScript.Debug.assert(enumElementDecl.kind === 67108864 /* EnumMember */); + + if (enumElement.equalsValueClause === null) { + if (inConstantSection) { + enumElementDecl.constantValue = currentConstantValue; + currentConstantValue++; + } + } else { + enumElementDecl.constantValue = computeEnumElementConstantValue(enumElement.equalsValueClause.value, enumMemberDecls, context); + if (enumElementDecl.constantValue !== null && !isAmbientEnum) { + inConstantSection = true; + currentConstantValue = enumElementDecl.constantValue + 1; + } else { + inConstantSection = false; + } + } + + TypeScript.Debug.assert(enumElementDecl.constantValue !== undefined); + } + } + + function computeEnumElementConstantValue(expression, enumMemberDecls, context) { + TypeScript.Debug.assert(expression); + + if (TypeScript.isIntegerLiteralAST(expression)) { + var token; + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + token = expression.operand; + break; + default: + token = expression; + } + + var value = token.value(); + return value && expression.kind() === 165 /* NegateExpression */ ? -value : value; + } else if (context.propagateEnumConstants) { + switch (expression.kind()) { + case 11 /* IdentifierName */: + var name = expression; + var matchingEnumElement = TypeScript.ArrayUtilities.firstOrDefault(enumMemberDecls, function (d) { + return d.name === name.valueText(); + }); + + return matchingEnumElement ? matchingEnumElement.constantValue : null; + + case 202 /* LeftShiftExpression */: + var binaryExpression = expression; + var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context); + var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context); + if (left === null || right === null) { + return null; + } + + return left << right; + + case 189 /* BitwiseOrExpression */: + var binaryExpression = expression; + var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context); + var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context); + if (left === null || right === null) { + return null; + } + + return left | right; + } + + return null; + } else { + return null; + } + } + + (function (DeclarationCreator) { + function create(document, semanticInfoChain, compilationSettings) { + var declCollectionContext = new DeclCollectionContext(document, semanticInfoChain, compilationSettings.propagateEnumConstants()); + + TypeScript.getAstWalkerFactory().simpleWalk(document.sourceUnit(), preCollectDecls, postCollectDecls, declCollectionContext); + + return declCollectionContext.getParent(); + } + DeclarationCreator.create = create; + })(TypeScript.DeclarationCreator || (TypeScript.DeclarationCreator = {})); + var DeclarationCreator = TypeScript.DeclarationCreator; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PullSymbolBinder = (function () { + function PullSymbolBinder(semanticInfoChain) { + this.semanticInfoChain = semanticInfoChain; + this.declsBeingBound = []; + } + PullSymbolBinder.prototype.getParent = function (decl, returnInstanceType) { + if (typeof returnInstanceType === "undefined") { returnInstanceType = false; } + var parentDecl = decl.getParentDecl(); + + if (parentDecl.kind == 1 /* Script */) { + return null; + } + + var parent = parentDecl.getSymbol(); + + if (!parent && parentDecl && !parentDecl.hasBeenBound()) { + this.bindDeclToPullSymbol(parentDecl); + } + + parent = parentDecl.getSymbol(); + if (parent) { + var parentDeclKind = parentDecl.kind; + if (parentDeclKind == 262144 /* GetAccessor */) { + parent = parent.getGetter(); + } else if (parentDeclKind == 524288 /* SetAccessor */) { + parent = parent.getSetter(); + } + } + + if (parent) { + if (returnInstanceType && parent.isType() && parent.isContainer()) { + var instanceSymbol = parent.getInstanceSymbol(); + + if (instanceSymbol) { + return instanceSymbol.type; + } + } + + return parent.type; + } + + return null; + }; + + PullSymbolBinder.prototype.findDeclsInContext = function (startingDecl, declKind, searchGlobally) { + if (!searchGlobally) { + var parentDecl = startingDecl.getParentDecl(); + return parentDecl.searchChildDecls(startingDecl.name, declKind); + } + + var contextSymbolPath = startingDecl.getParentPath(); + + if (contextSymbolPath.length) { + var copyOfContextSymbolPath = []; + + for (var i = 0; i < contextSymbolPath.length; i++) { + if (contextSymbolPath[i].kind & 1 /* Script */) { + continue; + } + copyOfContextSymbolPath[copyOfContextSymbolPath.length] = contextSymbolPath[i].name; + } + + return this.semanticInfoChain.findDecls(copyOfContextSymbolPath, declKind); + } + }; + + PullSymbolBinder.prototype.getExistingSymbol = function (decl, searchKind, parent) { + var lookingForValue = (searchKind & 68147712 /* SomeValue */) !== 0; + var lookingForType = (searchKind & 58728539 /* SomeType */) !== 0; + var lookingForContainer = (searchKind & 164 /* SomeContainer */) !== 0; + var name = decl.name; + if (parent) { + var isExported = (decl.flags & 1 /* Exported */) !== 0; + + var prevSymbol = null; + if (lookingForValue) { + prevSymbol = parent.findContainedNonMember(name); + } else if (lookingForType) { + prevSymbol = parent.findContainedNonMemberType(name, searchKind); + } else if (lookingForContainer) { + prevSymbol = parent.findContainedNonMemberContainer(name, searchKind); + } + var prevIsExported = !prevSymbol; + if (!prevSymbol) { + if (lookingForValue) { + prevSymbol = parent.findMember(name, false); + } else if (lookingForType) { + prevSymbol = parent.findNestedType(name, searchKind); + } else if (lookingForContainer) { + prevSymbol = parent.findNestedContainer(name, searchKind); + } + } + + if (isExported && prevIsExported) { + return prevSymbol; + } + if (prevSymbol) { + var prevDecls = prevSymbol.getDeclarations(); + var lastPrevDecl = prevDecls[prevDecls.length - 1]; + var parentDecl = decl.getParentDecl(); + var prevParentDecl = lastPrevDecl && lastPrevDecl.getParentDecl(); + if (parentDecl !== prevParentDecl) { + return null; + } + + return prevSymbol; + } + } else { + var parentDecl = decl.getParentDecl(); + if (parentDecl && parentDecl.kind === 1 /* Script */) { + return this.semanticInfoChain.findTopLevelSymbol(name, searchKind, decl); + } else { + var prevDecls = parentDecl && parentDecl.searchChildDecls(name, searchKind); + return prevDecls[0] && prevDecls[0].getSymbol(); + } + } + + return null; + }; + + PullSymbolBinder.prototype.checkThatExportsMatch = function (decl, prevSymbol, reportError) { + if (typeof reportError === "undefined") { reportError = true; } + var isExported = (decl.flags & 1 /* Exported */) !== 0; + var prevDecls = prevSymbol.getDeclarations(); + var prevIsExported = (prevDecls[prevDecls.length - 1].flags & 1 /* Exported */) !== 0; + if ((isExported !== prevIsExported) && !prevSymbol.isSignature() && (decl.kind & 7340032 /* SomeSignature */) == 0) { + if (reportError) { + var ast = this.semanticInfoChain.getASTForDecl(decl); + this.semanticInfoChain.addDiagnosticFromAST(ast, TypeScript.DiagnosticCode.All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported, [decl.getDisplayName()]); + } + return false; + } + + return true; + }; + + PullSymbolBinder.prototype.bindEnumDeclarationToPullSymbol = function (enumContainerDecl) { + var enumName = enumContainerDecl.name; + + var enumContainerSymbol = null; + var enumInstanceSymbol = null; + var moduleInstanceTypeSymbol = null; + + var enumInstanceDecl = enumContainerDecl.getValueDecl(); + + var enumDeclKind = enumContainerDecl.kind; + + var parent = this.getParent(enumContainerDecl); + var parentInstanceSymbol = this.getParent(enumContainerDecl, true); + var parentDecl = enumContainerDecl.getParentDecl(); + var enumAST = this.semanticInfoChain.getASTForDecl(enumContainerDecl); + + var isExported = enumContainerDecl.flags & 1 /* Exported */; + var isInitializedModule = (enumContainerDecl.flags & 102400 /* SomeInitializedModule */) != 0; + + var createdNewSymbol = false; + + enumContainerSymbol = this.getExistingSymbol(enumContainerDecl, 64 /* Enum */, parent); + + if (enumContainerSymbol) { + if (enumContainerSymbol.kind !== enumDeclKind) { + if (isInitializedModule) { + this.semanticInfoChain.addDiagnosticFromAST(enumAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [enumContainerDecl.getDisplayName()]); + } + enumContainerSymbol = null; + } else if (!this.checkThatExportsMatch(enumContainerDecl, enumContainerSymbol)) { + enumContainerSymbol = null; + } + } + + if (enumContainerSymbol) { + enumInstanceSymbol = enumContainerSymbol.getInstanceSymbol(); + } else { + enumContainerSymbol = new TypeScript.PullContainerSymbol(enumName, enumDeclKind); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(enumContainerSymbol, 64 /* Enum */); + } + } + + enumContainerSymbol.addDeclaration(enumContainerDecl); + enumContainerDecl.setSymbol(enumContainerSymbol); + + this.semanticInfoChain.setSymbolForAST(enumAST.identifier, enumContainerSymbol); + this.semanticInfoChain.setSymbolForAST(enumAST, enumContainerSymbol); + + if (!enumInstanceSymbol && isInitializedModule) { + var variableSymbol = null; + if (parentInstanceSymbol) { + if (isExported) { + variableSymbol = parentInstanceSymbol.findMember(enumName, false); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName); + } + } else { + variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findMember(enumName, false); + } + } + + if (variableSymbol) { + var declarations = variableSymbol.getDeclarations(); + + if (declarations.length) { + var variableSymbolParentDecl = declarations[0].getParentDecl(); + + if (parentDecl !== variableSymbolParentDecl) { + variableSymbol = null; + } + } + } + } else if (!(enumContainerDecl.flags & 1 /* Exported */)) { + var siblingDecls = parentDecl.getChildDecls(); + var augmentedDecl = null; + + for (var i = 0; i < siblingDecls.length; i++) { + if (siblingDecls[i] == enumContainerDecl) { + break; + } + + if ((siblingDecls[i].name == enumName) && (siblingDecls[i].kind & 68147712 /* SomeValue */)) { + augmentedDecl = siblingDecls[i]; + break; + } + } + + if (augmentedDecl) { + variableSymbol = augmentedDecl.getSymbol(); + + if (variableSymbol) { + if (variableSymbol.isContainer()) { + variableSymbol = variableSymbol.getInstanceSymbol(); + } else if (variableSymbol && variableSymbol.isType()) { + variableSymbol = variableSymbol.getConstructorMethod(); + } + } + } + } + + if (variableSymbol) { + enumInstanceSymbol = variableSymbol; + moduleInstanceTypeSymbol = variableSymbol.type; + } else { + enumInstanceSymbol = new TypeScript.PullSymbol(enumName, 512 /* Variable */); + } + + enumContainerSymbol.setInstanceSymbol(enumInstanceSymbol); + + if (!moduleInstanceTypeSymbol) { + moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + enumInstanceSymbol.type = moduleInstanceTypeSymbol; + } + + moduleInstanceTypeSymbol.addDeclaration(enumContainerDecl); + + if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) { + moduleInstanceTypeSymbol.setAssociatedContainerType(enumContainerSymbol); + } + } + + var moduleDeclarations = enumContainerSymbol.getDeclarations(); + + if (moduleDeclarations.length > 1 && enumAST.enumElements.nonSeparatorCount() > 0) { + var multipleEnums = TypeScript.ArrayUtilities.where(moduleDeclarations, function (d) { + return d.kind === 64 /* Enum */; + }).length > 1; + if (multipleEnums) { + var firstVariable = enumAST.enumElements.nonSeparatorAt(0); + if (!firstVariable.equalsValueClause) { + this.semanticInfoChain.addDiagnosticFromAST(firstVariable, TypeScript.DiagnosticCode.Enums_with_multiple_declarations_must_provide_an_initializer_for_the_first_enum_element, null); + } + } + } + + if (createdNewSymbol && parent) { + if (enumContainerDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(enumContainerSymbol); + } else { + parent.addEnclosedNonMemberType(enumContainerSymbol); + } + } + + this.bindEnumIndexerDeclsToPullSymbols(enumContainerDecl, enumContainerSymbol); + + var valueDecl = enumContainerDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + + var otherDecls = this.findDeclsInContext(enumContainerDecl, enumContainerDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindEnumIndexerDeclsToPullSymbols = function (enumContainerDecl, enumContainerSymbol) { + var indexSigDecl = enumContainerDecl.getChildDecls().filter(function (decl) { + return decl.kind == 4194304 /* IndexSignature */; + })[0]; + var indexParamDecl = indexSigDecl.getChildDecls()[0]; + + var syntheticIndexerParameterSymbol = new TypeScript.PullSymbol(indexParamDecl.name, 2048 /* Parameter */); + + syntheticIndexerParameterSymbol.type = this.semanticInfoChain.numberTypeSymbol; + syntheticIndexerParameterSymbol.setResolved(); + + var syntheticIndexerSignatureSymbol = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + syntheticIndexerSignatureSymbol.addParameter(syntheticIndexerParameterSymbol); + syntheticIndexerSignatureSymbol.returnType = this.semanticInfoChain.stringTypeSymbol; + syntheticIndexerSignatureSymbol.setResolved(); + + var enumContainerInstanceTypeSymbol = enumContainerSymbol.getInstanceSymbol().type; + enumContainerInstanceTypeSymbol.addIndexSignature(syntheticIndexerSignatureSymbol); + + indexSigDecl.setSignatureSymbol(syntheticIndexerSignatureSymbol); + indexParamDecl.setSymbol(syntheticIndexerParameterSymbol); + + syntheticIndexerSignatureSymbol.addDeclaration(indexSigDecl); + syntheticIndexerParameterSymbol.addDeclaration(indexParamDecl); + }; + + PullSymbolBinder.prototype.bindModuleDeclarationToPullSymbol = function (moduleContainerDecl) { + var modName = moduleContainerDecl.name; + + var moduleContainerTypeSymbol = null; + var moduleInstanceSymbol = null; + var moduleInstanceTypeSymbol = null; + + var moduleKind = moduleContainerDecl.kind; + + var parent = this.getParent(moduleContainerDecl); + var parentInstanceSymbol = this.getParent(moduleContainerDecl, true); + var parentDecl = moduleContainerDecl.getParentDecl(); + var moduleNameAST = this.semanticInfoChain.getASTForDecl(moduleContainerDecl); + var moduleDeclAST = TypeScript.getEnclosingModuleDeclaration(moduleNameAST); + if (!moduleDeclAST) { + TypeScript.Debug.assert(moduleContainerDecl.kind === 32 /* DynamicModule */); + TypeScript.Debug.assert(moduleNameAST.kind() === 120 /* SourceUnit */); + + moduleDeclAST = moduleNameAST; + } + + var isExported = TypeScript.hasFlag(moduleContainerDecl.flags, 1 /* Exported */); + var searchKind = 164 /* SomeContainer */; + var isInitializedModule = (moduleContainerDecl.flags & 102400 /* SomeInitializedModule */) != 0; + + if (parent && moduleKind == 32 /* DynamicModule */) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_must_be_defined_in_global_context, null); + } + + var createdNewSymbol = false; + + moduleContainerTypeSymbol = this.getExistingSymbol(moduleContainerDecl, searchKind, parent); + + if (moduleContainerTypeSymbol) { + if (moduleContainerTypeSymbol.kind !== moduleKind) { + if (isInitializedModule) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [moduleContainerDecl.getDisplayName()]); + } + + moduleContainerTypeSymbol = null; + } else if (moduleKind == 32 /* DynamicModule */) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_be_reopened); + } else if (!this.checkThatExportsMatch(moduleContainerDecl, moduleContainerTypeSymbol)) { + moduleContainerTypeSymbol = null; + } + } + + if (moduleContainerTypeSymbol) { + moduleInstanceSymbol = moduleContainerTypeSymbol.getInstanceSymbol(); + } else { + moduleContainerTypeSymbol = new TypeScript.PullContainerSymbol(modName, moduleKind); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(moduleContainerTypeSymbol, searchKind); + } + } + + moduleContainerTypeSymbol.addDeclaration(moduleContainerDecl); + moduleContainerDecl.setSymbol(moduleContainerTypeSymbol); + + this.semanticInfoChain.setSymbolForAST(moduleNameAST, moduleContainerTypeSymbol); + this.semanticInfoChain.setSymbolForAST(moduleDeclAST, moduleContainerTypeSymbol); + + if (!moduleInstanceSymbol && isInitializedModule) { + var variableSymbol = null; + if (parentInstanceSymbol) { + if (isExported) { + variableSymbol = parentInstanceSymbol.findMember(modName, false); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findContainedNonMember(modName); + } + } else { + variableSymbol = parentInstanceSymbol.findContainedNonMember(modName); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findMember(modName, false); + } + } + + if (variableSymbol) { + var declarations = variableSymbol.getDeclarations(); + + if (declarations.length) { + var variableSymbolParentDecl = declarations[0].getParentDecl(); + + if (parentDecl !== variableSymbolParentDecl) { + variableSymbol = null; + } + } + } + } else if (!isExported) { + var siblingDecls = parentDecl.getChildDecls(); + + for (var i = 0; i < siblingDecls.length; i++) { + var sibling = siblingDecls[i]; + if (sibling !== moduleContainerDecl && sibling.name === modName && TypeScript.hasFlag(sibling.kind, 68147712 /* SomeValue */)) { + if (sibling.hasSymbol()) { + variableSymbol = sibling.getSymbol(); + if (variableSymbol.isContainer()) { + variableSymbol = variableSymbol.getInstanceSymbol(); + } else if (variableSymbol && variableSymbol.isType()) { + variableSymbol = variableSymbol.getConstructorMethod(); + } + + break; + } + } + } + } + + if (variableSymbol) { + moduleInstanceSymbol = variableSymbol; + moduleInstanceTypeSymbol = variableSymbol.type; + } else { + moduleInstanceSymbol = new TypeScript.PullSymbol(modName, 512 /* Variable */); + } + + moduleContainerTypeSymbol.setInstanceSymbol(moduleInstanceSymbol); + + if (!moduleInstanceTypeSymbol) { + moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + moduleInstanceSymbol.type = moduleInstanceTypeSymbol; + } + + moduleInstanceTypeSymbol.addDeclaration(moduleContainerDecl); + + if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) { + moduleInstanceTypeSymbol.setAssociatedContainerType(moduleContainerTypeSymbol); + } + } + + var moduleDeclarations = moduleContainerTypeSymbol.getDeclarations(); + + if (createdNewSymbol) { + if (parent) { + if (moduleContainerDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberContainer(moduleContainerTypeSymbol); + } else { + parent.addEnclosedNonMemberContainer(moduleContainerTypeSymbol); + } + } + } + + var valueDecl = moduleContainerDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + + if (!valueDecl.hasSymbol()) { + valueDecl.setSymbol(moduleInstanceSymbol); + if (!moduleInstanceSymbol.hasDeclaration(valueDecl)) { + moduleInstanceSymbol.addDeclaration(valueDecl); + } + } + } + + var otherDecls = this.findDeclsInContext(moduleContainerDecl, moduleContainerDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindImportDeclaration = function (importDeclaration) { + var declFlags = importDeclaration.flags; + var declKind = importDeclaration.kind; + var importDeclAST = this.semanticInfoChain.getASTForDecl(importDeclaration); + + var isExported = false; + var importSymbol = null; + var declName = importDeclaration.name; + var parentHadSymbol = false; + var parent = this.getParent(importDeclaration); + + importSymbol = this.getExistingSymbol(importDeclaration, 164 /* SomeContainer */, parent); + + if (importSymbol) { + parentHadSymbol = true; + } + + if (importSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(importDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [importDeclaration.getDisplayName()]); + importSymbol = null; + } + + if (!importSymbol) { + importSymbol = new TypeScript.PullTypeAliasSymbol(declName); + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(importSymbol, 164 /* SomeContainer */); + } + } + + importSymbol.addDeclaration(importDeclaration); + importDeclaration.setSymbol(importSymbol); + + this.semanticInfoChain.setSymbolForAST(importDeclAST, importSymbol); + + if (parent && !parentHadSymbol) { + if (declFlags & 1 /* Exported */) { + parent.addEnclosedMemberContainer(importSymbol); + } else { + parent.addEnclosedNonMemberContainer(importSymbol); + } + } + }; + + PullSymbolBinder.prototype.bindClassDeclarationToPullSymbol = function (classDecl) { + var className = classDecl.name; + var classSymbol = null; + + var constructorSymbol = null; + var constructorTypeSymbol = null; + + var classAST = this.semanticInfoChain.getASTForDecl(classDecl); + + var parent = this.getParent(classDecl); + var parentDecl = classDecl.getParentDecl(); + var isExported = classDecl.flags & 1 /* Exported */; + var isGeneric = false; + + classSymbol = this.getExistingSymbol(classDecl, 58728539 /* SomeType */, parent); + + if (classSymbol && classSymbol.kind === 16 /* Interface */) { + this.semanticInfoChain.addDiagnosticFromAST(classAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [classDecl.getDisplayName()]); + classSymbol = null; + } + + var decls; + + classSymbol = new TypeScript.PullTypeSymbol(className, 8 /* Class */); + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(classSymbol, 8 /* Class */); + } + + classSymbol.addDeclaration(classDecl); + + classDecl.setSymbol(classSymbol); + + this.semanticInfoChain.setSymbolForAST(classAST.identifier, classSymbol); + this.semanticInfoChain.setSymbolForAST(classAST, classSymbol); + + if (parent) { + if (classDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(classSymbol); + } else { + parent.addEnclosedNonMemberType(classSymbol); + } + } + + constructorSymbol = classSymbol.getConstructorMethod(); + constructorTypeSymbol = constructorSymbol ? constructorSymbol.type : null; + + if (!constructorSymbol) { + var siblingValueDecls = null; + if (parentDecl) { + siblingValueDecls = parentDecl.searchChildDecls(className, 68147712 /* SomeValue */); + + if (siblingValueDecls && siblingValueDecls[0] && siblingValueDecls[0].hasSymbol()) { + constructorSymbol = siblingValueDecls[0].getSymbol(); + } + } + + if (constructorSymbol) { + constructorTypeSymbol = constructorSymbol.type; + } else { + constructorSymbol = new TypeScript.PullSymbol(className, 32768 /* ConstructorMethod */); + constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + constructorSymbol.setIsSynthesized(); + constructorSymbol.type = constructorTypeSymbol; + } + + classSymbol.setConstructorMethod(constructorSymbol); + classSymbol.setHasDefaultConstructor(); + } + + if (constructorSymbol.getIsSynthesized()) { + constructorSymbol.addDeclaration(classDecl.getValueDecl()); + constructorTypeSymbol.addDeclaration(classDecl); + } else { + classSymbol.setHasDefaultConstructor(false); + } + + constructorTypeSymbol.setAssociatedContainerType(classSymbol); + + var typeParameters = classDecl.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = classSymbol.findTypeParameter(typeParameters[i].name); + + if (typeParameter != null) { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + classSymbol.addTypeParameter(typeParameter); + constructorTypeSymbol.addConstructorTypeParameter(typeParameter); + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + var valueDecl = classDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + + this.bindStaticPrototypePropertyOfClass(classSymbol, constructorTypeSymbol); + }; + + PullSymbolBinder.prototype.bindInterfaceDeclarationToPullSymbol = function (interfaceDecl) { + var interfaceName = interfaceDecl.name; + var interfaceSymbol = null; + + var interfaceAST = this.semanticInfoChain.getASTForDecl(interfaceDecl); + var createdNewSymbol = false; + var parent = this.getParent(interfaceDecl); + + var acceptableSharedKind = 16 /* Interface */; + + interfaceSymbol = this.getExistingSymbol(interfaceDecl, 58728539 /* SomeType */, parent); + + if (interfaceSymbol) { + if (!(interfaceSymbol.kind & acceptableSharedKind)) { + this.semanticInfoChain.addDiagnosticFromAST(interfaceAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [interfaceDecl.getDisplayName()]); + interfaceSymbol = null; + } else if (!this.checkThatExportsMatch(interfaceDecl, interfaceSymbol)) { + interfaceSymbol = null; + } + } + + if (!interfaceSymbol) { + interfaceSymbol = new TypeScript.PullTypeSymbol(interfaceName, 16 /* Interface */); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(interfaceSymbol, acceptableSharedKind); + } + } + + interfaceSymbol.addDeclaration(interfaceDecl); + interfaceDecl.setSymbol(interfaceSymbol); + + if (createdNewSymbol) { + if (parent) { + if (interfaceDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(interfaceSymbol); + } else { + parent.addEnclosedNonMemberType(interfaceSymbol); + } + } + } + + var typeParameters = interfaceDecl.getTypeParameters(); + var typeParameter; + var typeParameterDecls = null; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = interfaceSymbol.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + interfaceSymbol.addTypeParameter(typeParameter); + } else { + typeParameterDecls = typeParameter.getDeclarations(); + + for (var j = 0; j < typeParameterDecls.length; j++) { + var typeParameterDeclParent = typeParameterDecls[j].getParentDecl(); + + if (typeParameterDeclParent && typeParameterDeclParent === interfaceDecl) { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecls[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + + break; + } + } + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + var otherDecls = this.findDeclsInContext(interfaceDecl, interfaceDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindObjectTypeDeclarationToPullSymbol = function (objectDecl) { + var objectSymbolAST = this.semanticInfoChain.getASTForDecl(objectDecl); + + var objectSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + + objectSymbol.addDeclaration(objectDecl); + objectDecl.setSymbol(objectSymbol); + + this.semanticInfoChain.setSymbolForAST(objectSymbolAST, objectSymbol); + + var childDecls = objectDecl.getChildDecls(); + + for (var i = 0; i < childDecls.length; i++) { + this.bindDeclToPullSymbol(childDecls[i]); + } + }; + + PullSymbolBinder.prototype.bindConstructorTypeDeclarationToPullSymbol = function (constructorTypeDeclaration) { + var declKind = constructorTypeDeclaration.kind; + var declFlags = constructorTypeDeclaration.flags; + var constructorTypeAST = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration); + + var constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + + constructorTypeDeclaration.setSymbol(constructorTypeSymbol); + constructorTypeSymbol.addDeclaration(constructorTypeDeclaration); + this.semanticInfoChain.setSymbolForAST(constructorTypeAST, constructorTypeSymbol); + + var signature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + + var funcDecl = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration); + if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) { + signature.hasVarArgs = true; + } + + signature.addDeclaration(constructorTypeDeclaration); + constructorTypeDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.parameterList), constructorTypeSymbol, signature); + + constructorTypeSymbol.addConstructSignature(signature); + + var typeParameters = constructorTypeDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = constructorTypeSymbol.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + constructorTypeSymbol.addConstructorTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + }; + + PullSymbolBinder.prototype.bindVariableDeclarationToPullSymbol = function (variableDeclaration) { + var declFlags = variableDeclaration.flags; + var declKind = variableDeclaration.kind; + var varDeclAST = this.semanticInfoChain.getASTForDecl(variableDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var variableSymbol = null; + + var declName = variableDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(variableDeclaration, true); + + var parentDecl = variableDeclaration.getParentDecl(); + + var isImplicit = (declFlags & 118784 /* ImplicitVariable */) !== 0; + var isModuleValue = (declFlags & (32768 /* InitializedModule */)) != 0; + var isEnumValue = (declFlags & 4096 /* Enum */) != 0; + var isClassConstructorVariable = (declFlags & 16384 /* ClassConstructorVariable */) != 0; + + variableSymbol = this.getExistingSymbol(variableDeclaration, 68147712 /* SomeValue */, parent); + + if (variableSymbol && !variableSymbol.isType()) { + parentHadSymbol = true; + } + + var decl; + var decls; + var ast; + var members; + + if (variableSymbol) { + var prevKind = variableSymbol.kind; + var prevIsEnum = variableSymbol.anyDeclHasFlag(4096 /* Enum */); + var prevIsClassConstructorVariable = variableSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */); + var prevIsModuleValue = variableSymbol.allDeclsHaveFlag(32768 /* InitializedModule */); + var prevIsImplicit = variableSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */); + var prevIsFunction = prevKind == 16384 /* Function */; + var prevIsAmbient = variableSymbol.allDeclsHaveFlag(8 /* Ambient */); + var isAmbientOrPrevIsAmbient = prevIsAmbient || (variableDeclaration.flags & 8 /* Ambient */) != 0; + var prevDecl = variableSymbol.getDeclarations()[0]; + var prevParentDecl = prevDecl.getParentDecl(); + var bothAreGlobal = parentDecl && (parentDecl.kind == 1 /* Script */) && (prevParentDecl.kind == 1 /* Script */); + var shareParent = bothAreGlobal || prevDecl.getParentDecl() == variableDeclaration.getParentDecl(); + var prevIsParam = shareParent && prevKind == 2048 /* Parameter */ && declKind == 512 /* Variable */; + + var acceptableRedeclaration = prevIsParam || (isImplicit && ((!isEnumValue && !isClassConstructorVariable && prevIsFunction) || ((isModuleValue || isEnumValue) && (prevIsModuleValue || prevIsEnum)) || (isClassConstructorVariable && prevIsModuleValue && isAmbientOrPrevIsAmbient) || (isModuleValue && prevIsClassConstructorVariable))); + + if (acceptableRedeclaration && (prevIsClassConstructorVariable || prevIsFunction) && !isAmbientOrPrevIsAmbient) { + if (prevDecl.fileName() != variableDeclaration.fileName()) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2, [declName, declName, prevDecl.fileName()])); + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } + } + + if (!acceptableRedeclaration || prevIsParam) { + if (!prevIsParam && (isImplicit || prevIsImplicit || (prevKind & 1032192 /* SomeFunction */) !== 0) || !shareParent) { + var diagnostic = TypeScript.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [variableDeclaration.getDisplayName()]); + this.semanticInfoChain.addDiagnostic(diagnostic); + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } else { + this.checkThatExportsMatch(variableDeclaration, variableSymbol); + variableSymbol = null; + parentHadSymbol = false; + } + } + + if (variableSymbol && !(variableSymbol.type && variableSymbol.type.isError()) && !this.checkThatExportsMatch(variableDeclaration, variableSymbol, !(isModuleValue && prevIsModuleValue))) { + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } + } + + if ((declFlags & 118784 /* ImplicitVariable */) === 0) { + if (!variableSymbol) { + variableSymbol = new TypeScript.PullSymbol(declName, declKind); + if (!parent && parentDecl.kind === 1 /* Script */) { + this.semanticInfoChain.cacheGlobalSymbol(variableSymbol, declKind); + } + } + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + this.semanticInfoChain.setSymbolForAST(varDeclAST.propertyName, variableSymbol); + this.semanticInfoChain.setSymbolForAST(varDeclAST, variableSymbol); + } else if (!parentHadSymbol) { + if (isClassConstructorVariable) { + var classTypeSymbol = variableSymbol; + + if (parent) { + members = parent.getMembers(); + + for (var i = 0; i < members.length; i++) { + if ((members[i].name === declName) && (members[i].kind === 8 /* Class */)) { + classTypeSymbol = members[i]; + break; + } + } + } + + if (!classTypeSymbol) { + var parentDecl = variableDeclaration.getParentDecl(); + + if (parentDecl) { + var childDecls = parentDecl.searchChildDecls(declName, 58728539 /* SomeType */); + + if (childDecls.length) { + for (var i = 0; i < childDecls.length; i++) { + if (childDecls[i].getValueDecl() === variableDeclaration) { + classTypeSymbol = childDecls[i].getSymbol(); + } + } + } + } + + if (!classTypeSymbol) { + classTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 58728539 /* SomeType */, variableDeclaration); + } + } + + if (classTypeSymbol && (classTypeSymbol.kind !== 8 /* Class */)) { + classTypeSymbol = null; + } + + if (classTypeSymbol && classTypeSymbol.isClass()) { + variableSymbol = classTypeSymbol.getConstructorMethod(); + variableDeclaration.setSymbol(variableSymbol); + + decls = classTypeSymbol.getDeclarations(); + + if (decls.length) { + decl = decls[decls.length - 1]; + ast = this.semanticInfoChain.getASTForDecl(decl); + } + } else { + if (!variableSymbol) { + variableSymbol = new TypeScript.PullSymbol(declName, declKind); + } + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + variableSymbol.type = this.semanticInfoChain.anyTypeSymbol; + } + } else if (declFlags & 102400 /* SomeInitializedModule */) { + var moduleContainerTypeSymbol = null; + var moduleParent = this.getParent(variableDeclaration); + + if (moduleParent) { + members = moduleParent.getMembers(); + + for (var i = 0; i < members.length; i++) { + if ((members[i].name === declName) && (members[i].isContainer())) { + moduleContainerTypeSymbol = members[i]; + break; + } + } + } + + if (!moduleContainerTypeSymbol) { + var parentDecl = variableDeclaration.getParentDecl(); + + if (parentDecl) { + var searchKind = (declFlags & (32768 /* InitializedModule */ | 65536 /* InitializedDynamicModule */)) ? 164 /* SomeContainer */ : 64 /* Enum */; + var childDecls = parentDecl.searchChildDecls(declName, searchKind); + + if (childDecls.length) { + for (var i = 0; i < childDecls.length; i++) { + if (childDecls[i].getValueDecl() === variableDeclaration) { + moduleContainerTypeSymbol = childDecls[i].getSymbol(); + } + } + } + } + if (!moduleContainerTypeSymbol) { + moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 164 /* SomeContainer */, variableDeclaration); + + if (!moduleContainerTypeSymbol) { + moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 64 /* Enum */, variableDeclaration); + } + } + } + + if (moduleContainerTypeSymbol && (!moduleContainerTypeSymbol.isContainer())) { + moduleContainerTypeSymbol = null; + } + + if (moduleContainerTypeSymbol) { + variableSymbol = moduleContainerTypeSymbol.getInstanceSymbol(); + + if (!variableSymbol.hasDeclaration(variableDeclaration)) { + variableSymbol.addDeclaration(variableDeclaration); + } + variableDeclaration.setSymbol(variableSymbol); + } else { + TypeScript.Debug.assert(false, "Attempted to bind invalid implicit variable symbol"); + } + } + } else { + if (!variableSymbol.hasDeclaration(variableDeclaration)) { + variableSymbol.addDeclaration(variableDeclaration); + } + variableDeclaration.setSymbol(variableSymbol); + } + + if (parent && !parentHadSymbol) { + if (declFlags & 1 /* Exported */) { + parent.addMember(variableSymbol); + } else { + parent.addEnclosedNonMember(variableSymbol); + } + } + + var otherDecls = this.findDeclsInContext(variableDeclaration, variableDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindCatchVariableToPullSymbol = function (variableDeclaration) { + var declFlags = variableDeclaration.flags; + var declKind = variableDeclaration.kind; + var identifier = this.semanticInfoChain.getASTForDecl(variableDeclaration); + + var declName = variableDeclaration.name; + + var variableSymbol = new TypeScript.PullSymbol(declName, declKind); + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + variableSymbol.type = this.semanticInfoChain.anyTypeSymbol; + + this.semanticInfoChain.setSymbolForAST(identifier, variableSymbol); + }; + + PullSymbolBinder.prototype.bindEnumMemberDeclarationToPullSymbol = function (propertyDeclaration) { + var declFlags = propertyDeclaration.flags; + var declKind = propertyDeclaration.kind; + var propDeclAST = this.semanticInfoChain.getASTForDecl(propertyDeclaration); + + var declName = propertyDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(propertyDeclaration, true); + + var propertySymbol = parent.findMember(declName, false); + + if (propertySymbol) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(propertyDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [propertyDeclaration.getDisplayName()])); + } + + if (propertySymbol) { + parentHadSymbol = true; + } + + if (!parentHadSymbol) { + propertySymbol = new TypeScript.PullSymbol(declName, declKind); + } + + propertySymbol.addDeclaration(propertyDeclaration); + propertyDeclaration.setSymbol(propertySymbol); + + this.semanticInfoChain.setSymbolForAST(propDeclAST.propertyName, propertySymbol); + this.semanticInfoChain.setSymbolForAST(propDeclAST, propertySymbol); + + if (parent && !parentHadSymbol) { + parent.addMember(propertySymbol); + } + }; + + PullSymbolBinder.prototype.bindPropertyDeclarationToPullSymbol = function (propertyDeclaration) { + var declFlags = propertyDeclaration.flags; + var declKind = propertyDeclaration.kind; + + var ast = this.semanticInfoChain.getASTForDecl(propertyDeclaration); + var astName = ast.kind() === 136 /* MemberVariableDeclaration */ ? ast.variableDeclarator.propertyName : ast.kind() === 141 /* PropertySignature */ ? ast.propertyName : ast.kind() === 242 /* Parameter */ ? ast.identifier : ast.propertyName; + + var isStatic = false; + var isOptional = false; + + var propertySymbol = null; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + if (TypeScript.hasFlag(declFlags, 128 /* Optional */)) { + isOptional = true; + } + + var declName = propertyDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(propertyDeclaration, true); + + if (parent.isClass() && isStatic) { + parent = parent.getConstructorMethod().type; + } + + propertySymbol = parent.findMember(declName, false); + + if (propertySymbol) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(propertyDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [propertyDeclaration.getDisplayName()])); + } + + if (propertySymbol) { + parentHadSymbol = true; + } + + var classTypeSymbol; + + if (!parentHadSymbol) { + propertySymbol = new TypeScript.PullSymbol(declName, declKind); + } + + propertySymbol.addDeclaration(propertyDeclaration); + propertyDeclaration.setSymbol(propertySymbol); + + this.semanticInfoChain.setSymbolForAST(astName, propertySymbol); + this.semanticInfoChain.setSymbolForAST(ast, propertySymbol); + + if (isOptional) { + propertySymbol.isOptional = true; + } + + if (parent && !parentHadSymbol) { + parent.addMember(propertySymbol); + } + }; + + PullSymbolBinder.prototype.bindParameterSymbols = function (functionDeclaration, parameterList, funcType, signatureSymbol) { + var parameters = []; + var params = TypeScript.createIntrinsicsObject(); + var funcDecl = this.semanticInfoChain.getDeclForAST(functionDeclaration); + + if (parameterList) { + for (var i = 0, n = parameterList.length; i < n; i++) { + var argDecl = parameterList.astAt(i); + var id = parameterList.identifierAt(i); + var decl = this.semanticInfoChain.getDeclForAST(argDecl); + var isProperty = TypeScript.hasFlag(decl.flags, 8388608 /* PropertyParameter */); + var parameterSymbol = new TypeScript.PullSymbol(id.valueText(), 2048 /* Parameter */); + + if ((i === (n - 1)) && parameterList.lastParameterIsRest()) { + parameterSymbol.isVarArg = true; + } + + if (decl.flags & 128 /* Optional */) { + parameterSymbol.isOptional = true; + } + + if (params[id.valueText()]) { + this.semanticInfoChain.addDiagnosticFromAST(argDecl, TypeScript.DiagnosticCode.Duplicate_identifier_0, [id.text()]); + } else { + params[id.valueText()] = true; + } + if (decl) { + if (isProperty) { + decl.ensureSymbolIsBound(); + var valDecl = decl.getValueDecl(); + + if (valDecl) { + valDecl.setSymbol(parameterSymbol); + parameterSymbol.addDeclaration(valDecl); + } + } else { + parameterSymbol.addDeclaration(decl); + decl.setSymbol(parameterSymbol); + } + } + + signatureSymbol.addParameter(parameterSymbol, parameterSymbol.isOptional); + + if (signatureSymbol.isDefinition()) { + funcType.addEnclosedNonMember(parameterSymbol); + } + } + } + }; + + PullSymbolBinder.prototype.bindFunctionDeclarationToPullSymbol = function (functionDeclaration) { + var declKind = functionDeclaration.kind; + var declFlags = functionDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(functionDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = functionDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(functionDeclaration, true); + var parentDecl = functionDeclaration.getParentDecl(); + var parentHadSymbol = false; + + var functionSymbol = null; + var functionTypeSymbol = null; + + functionSymbol = this.getExistingSymbol(functionDeclaration, 68147712 /* SomeValue */, parent); + + if (functionSymbol) { + var previousIsAmbient = functionSymbol.allDeclsHaveFlag(8 /* Ambient */); + var isAmbientOrPreviousIsAmbient = previousIsAmbient || functionDeclaration.flags & 8 /* Ambient */; + var acceptableRedeclaration = functionSymbol.kind === 16384 /* Function */ && (isSignature || functionSymbol.allDeclsHaveFlag(2048 /* Signature */)) || functionSymbol.allDeclsHaveFlag(32768 /* InitializedModule */) && isAmbientOrPreviousIsAmbient; + if (!acceptableRedeclaration) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [functionDeclaration.getDisplayName()]); + functionSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(funcName); + } + } + + if (functionSymbol) { + functionTypeSymbol = functionSymbol.type; + parentHadSymbol = true; + } + + if (!functionSymbol) { + functionSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + } + + if (!functionTypeSymbol) { + functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + functionSymbol.type = functionTypeSymbol; + functionTypeSymbol.setFunctionSymbol(functionSymbol); + } + + functionDeclaration.setSymbol(functionSymbol); + functionSymbol.addDeclaration(functionDeclaration); + functionTypeSymbol.addDeclaration(functionDeclaration); + + this.semanticInfoChain.setSymbolForAST(funcDeclAST.identifier, functionSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, functionSymbol); + + if (parent && !parentHadSymbol) { + if (isExported) { + parent.addMember(functionSymbol); + } else { + parent.addEnclosedNonMember(functionSymbol); + } + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(functionDeclaration); + functionDeclaration.setSignatureSymbol(signature); + + if (TypeScript.lastParameterIsRest(funcDeclAST.callSignature.parameterList)) { + signature.hasVarArgs = true; + } + + var funcDecl = this.semanticInfoChain.getASTForDecl(functionDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), functionTypeSymbol, signature); + + var typeParameters = functionDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + functionTypeSymbol.addCallSignature(signature); + + var otherDecls = this.findDeclsInContext(functionDeclaration, functionDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindFunctionExpressionToPullSymbol = function (functionExpressionDeclaration) { + var declKind = functionExpressionDeclaration.kind; + var declFlags = functionExpressionDeclaration.flags; + var ast = this.semanticInfoChain.getASTForDecl(functionExpressionDeclaration); + + var parameters = ast.kind() === 219 /* SimpleArrowFunctionExpression */ ? TypeScript.Parameters.fromIdentifier(ast.identifier) : TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(ast)); + var funcExpAST = ast; + + var functionName = declKind == 131072 /* FunctionExpression */ ? functionExpressionDeclaration.getFunctionExpressionName() : functionExpressionDeclaration.name; + var functionSymbol = new TypeScript.PullSymbol(functionName, declKind); + var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + functionTypeSymbol.setFunctionSymbol(functionSymbol); + + functionSymbol.type = functionTypeSymbol; + + functionExpressionDeclaration.setSymbol(functionSymbol); + functionSymbol.addDeclaration(functionExpressionDeclaration); + functionTypeSymbol.addDeclaration(functionExpressionDeclaration); + + var name = funcExpAST.kind() === 222 /* FunctionExpression */ ? funcExpAST.identifier : funcExpAST.kind() === 241 /* FunctionPropertyAssignment */ ? funcExpAST.propertyName : null; + if (name) { + this.semanticInfoChain.setSymbolForAST(name, functionSymbol); + } + + this.semanticInfoChain.setSymbolForAST(funcExpAST, functionSymbol); + + var signature = new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + if (parameters.lastParameterIsRest()) { + signature.hasVarArgs = true; + } + + var typeParameters = functionExpressionDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(functionExpressionDeclaration); + functionExpressionDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcExpAST, parameters, functionTypeSymbol, signature); + + functionTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindFunctionTypeDeclarationToPullSymbol = function (functionTypeDeclaration) { + var declKind = functionTypeDeclaration.kind; + var declFlags = functionTypeDeclaration.flags; + var funcTypeAST = this.semanticInfoChain.getASTForDecl(functionTypeDeclaration); + + var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + + functionTypeDeclaration.setSymbol(functionTypeSymbol); + functionTypeSymbol.addDeclaration(functionTypeDeclaration); + this.semanticInfoChain.setSymbolForAST(funcTypeAST, functionTypeSymbol); + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + if (TypeScript.lastParameterIsRest(funcTypeAST.parameterList)) { + signature.hasVarArgs = true; + } + + var typeParameters = functionTypeDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(functionTypeDeclaration); + functionTypeDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcTypeAST, TypeScript.Parameters.fromParameterList(funcTypeAST.parameterList), functionTypeSymbol, signature); + + functionTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindMethodDeclarationToPullSymbol = function (methodDeclaration) { + var declKind = methodDeclaration.kind; + var declFlags = methodDeclaration.flags; + var methodAST = this.semanticInfoChain.getASTForDecl(methodDeclaration); + + var isPrivate = (declFlags & 2 /* Private */) !== 0; + var isStatic = (declFlags & 16 /* Static */) !== 0; + var isOptional = (declFlags & 128 /* Optional */) !== 0; + + var methodName = methodDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(methodDeclaration, true); + var parentHadSymbol = false; + + var methodSymbol = null; + var methodTypeSymbol = null; + + if (parent.isClass() && isStatic) { + parent = parent.getConstructorMethod().type; + } + + methodSymbol = parent.findMember(methodName, false); + + if (methodSymbol && (methodSymbol.kind !== 65536 /* Method */ || (!isSignature && !methodSymbol.allDeclsHaveFlag(2048 /* Signature */)))) { + this.semanticInfoChain.addDiagnosticFromAST(methodAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [methodDeclaration.getDisplayName()]); + methodSymbol = null; + } + + if (methodSymbol) { + methodTypeSymbol = methodSymbol.type; + parentHadSymbol = true; + } + + if (!methodSymbol) { + methodSymbol = new TypeScript.PullSymbol(methodName, 65536 /* Method */); + } + + if (!methodTypeSymbol) { + methodTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + methodSymbol.type = methodTypeSymbol; + methodTypeSymbol.setFunctionSymbol(methodSymbol); + } + + methodDeclaration.setSymbol(methodSymbol); + methodSymbol.addDeclaration(methodDeclaration); + methodTypeSymbol.addDeclaration(methodDeclaration); + + var nameAST = methodAST.kind() === 135 /* MemberFunctionDeclaration */ ? methodAST.propertyName : methodAST.propertyName; + + TypeScript.Debug.assert(nameAST); + + this.semanticInfoChain.setSymbolForAST(nameAST, methodSymbol); + this.semanticInfoChain.setSymbolForAST(methodAST, methodSymbol); + + if (isOptional) { + methodSymbol.isOptional = true; + } + + if (!parentHadSymbol) { + parent.addMember(methodSymbol); + } + + var sigKind = 1048576 /* CallSignature */; + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(sigKind) : new TypeScript.PullDefinitionSignatureSymbol(sigKind); + + var parameterList = TypeScript.getParameterList(methodAST); + if (TypeScript.lastParameterIsRest(parameterList)) { + signature.hasVarArgs = true; + } + + var typeParameters = methodDeclaration.getTypeParameters(); + var typeParameter; + var typeParameterName; + var typeParameterAST; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterName = typeParameters[i].name; + typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameters[i]); + + typeParameter = signature.findTypeParameter(typeParameterName); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameterName, true); + signature.addTypeParameter(typeParameter); + } else { + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(methodDeclaration); + methodDeclaration.setSignatureSymbol(signature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(methodDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(funcDecl)), methodTypeSymbol, signature); + + methodTypeSymbol.addCallSignature(signature); + + var otherDecls = this.findDeclsInContext(methodDeclaration, methodDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindStaticPrototypePropertyOfClass = function (classTypeSymbol, constructorTypeSymbol) { + var prototypeStr = "prototype"; + + var prototypeSymbol = constructorTypeSymbol.findMember(prototypeStr, false); + if (prototypeSymbol && !prototypeSymbol.getIsSynthesized()) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(prototypeSymbol.getDeclarations()[0], TypeScript.DiagnosticCode.Duplicate_identifier_0, [prototypeSymbol.getDisplayName()])); + } + + if (!prototypeSymbol || !prototypeSymbol.getIsSynthesized()) { + var prototypeDecl = new TypeScript.PullSynthesizedDecl(prototypeStr, prototypeStr, 4096 /* Property */, 4 /* Public */ | 16 /* Static */, constructorTypeSymbol.getDeclarations()[0], classTypeSymbol.getDeclarations()[0].getSpan(), this.semanticInfoChain); + + prototypeSymbol = new TypeScript.PullSymbol(prototypeStr, 4096 /* Property */); + prototypeSymbol.setIsSynthesized(); + prototypeSymbol.addDeclaration(prototypeDecl); + prototypeSymbol.type = classTypeSymbol; + constructorTypeSymbol.addMember(prototypeSymbol); + + if (prototypeSymbol.type && prototypeSymbol.type.isGeneric()) { + var resolver = this.semanticInfoChain.getResolver(); + prototypeSymbol.type = resolver.instantiateTypeToAny(prototypeSymbol.type, new TypeScript.PullTypeResolutionContext(resolver)); + } + prototypeSymbol.setResolved(); + } + }; + + PullSymbolBinder.prototype.bindConstructorDeclarationToPullSymbol = function (constructorDeclaration) { + var declKind = constructorDeclaration.kind; + var declFlags = constructorDeclaration.flags; + var constructorAST = this.semanticInfoChain.getASTForDecl(constructorDeclaration); + + var constructorName = constructorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(constructorDeclaration, true); + + var parentHadSymbol = false; + + var constructorSymbol = parent.getConstructorMethod(); + var constructorTypeSymbol = null; + + if (constructorSymbol && (constructorSymbol.kind !== 32768 /* ConstructorMethod */ || (!isSignature && constructorSymbol.type && constructorSymbol.type.hasOwnConstructSignatures()))) { + var hasDefinitionSignature = false; + var constructorSigs = constructorSymbol.type.getConstructSignatures(); + + for (var i = 0; i < constructorSigs.length; i++) { + if (!constructorSigs[i].anyDeclHasFlag(2048 /* Signature */)) { + hasDefinitionSignature = true; + break; + } + } + + if (hasDefinitionSignature) { + this.semanticInfoChain.addDiagnosticFromAST(constructorAST, TypeScript.DiagnosticCode.Multiple_constructor_implementations_are_not_allowed); + + constructorSymbol = null; + } + } + + if (constructorSymbol) { + constructorTypeSymbol = constructorSymbol.type; + } else { + constructorSymbol = new TypeScript.PullSymbol(constructorName, 32768 /* ConstructorMethod */); + constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + } + + parent.setConstructorMethod(constructorSymbol); + constructorSymbol.type = constructorTypeSymbol; + + constructorDeclaration.setSymbol(constructorSymbol); + constructorSymbol.addDeclaration(constructorDeclaration); + constructorTypeSymbol.addDeclaration(constructorDeclaration); + constructorSymbol.setIsSynthesized(false); + this.semanticInfoChain.setSymbolForAST(constructorAST, constructorSymbol); + + var constructSignature = isSignature ? new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */) : new TypeScript.PullDefinitionSignatureSymbol(2097152 /* ConstructSignature */); + + constructSignature.returnType = parent; + + constructSignature.addDeclaration(constructorDeclaration); + constructorDeclaration.setSignatureSymbol(constructSignature); + + this.bindParameterSymbols(constructorAST, TypeScript.Parameters.fromParameterList(constructorAST.parameterList), constructorTypeSymbol, constructSignature); + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var i = 0; i < typeParameters.length; i++) { + constructSignature.addTypeParameter(typeParameters[i]); + } + + if (TypeScript.lastParameterIsRest(constructorAST.parameterList)) { + constructSignature.hasVarArgs = true; + } + + constructorTypeSymbol.addConstructSignature(constructSignature); + + var otherDecls = this.findDeclsInContext(constructorDeclaration, constructorDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + + this.bindStaticPrototypePropertyOfClass(parent, constructorTypeSymbol); + }; + + PullSymbolBinder.prototype.bindConstructSignatureDeclarationToPullSymbol = function (constructSignatureDeclaration) { + var parent = this.getParent(constructSignatureDeclaration, true); + var constructorAST = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration); + + var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + + if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) { + constructSignature.hasVarArgs = true; + } + + var typeParameters = constructSignatureDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = constructSignature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + constructSignature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + constructSignature.addDeclaration(constructSignatureDeclaration); + constructSignatureDeclaration.setSignatureSymbol(constructSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(funcDecl)), null, constructSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration), constructSignature); + + parent.addConstructSignature(constructSignature); + }; + + PullSymbolBinder.prototype.bindCallSignatureDeclarationToPullSymbol = function (callSignatureDeclaration) { + var parent = this.getParent(callSignatureDeclaration, true); + var callSignatureAST = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration); + + var callSignature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */); + + if (TypeScript.lastParameterIsRest(callSignatureAST.parameterList)) { + callSignature.hasVarArgs = true; + } + + var typeParameters = callSignatureDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = callSignature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + callSignature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + callSignature.addDeclaration(callSignatureDeclaration); + callSignatureDeclaration.setSignatureSymbol(callSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.parameterList), null, callSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(callSignatureDeclaration), callSignature); + + parent.addCallSignature(callSignature); + }; + + PullSymbolBinder.prototype.bindIndexSignatureDeclarationToPullSymbol = function (indexSignatureDeclaration) { + var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + + indexSignature.addDeclaration(indexSignatureDeclaration); + indexSignatureDeclaration.setSignatureSymbol(indexSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameter(funcDecl.parameter), null, indexSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration), indexSignature); + + var parent = this.getParent(indexSignatureDeclaration); + parent.addIndexSignature(indexSignature); + indexSignature.setContainer(parent); + }; + + PullSymbolBinder.prototype.bindGetAccessorDeclarationToPullSymbol = function (getAccessorDeclaration) { + var declKind = getAccessorDeclaration.kind; + var declFlags = getAccessorDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(getAccessorDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = getAccessorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var isStatic = false; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + var parent = this.getParent(getAccessorDeclaration, true); + var parentHadSymbol = false; + + var accessorSymbol = null; + var getterSymbol = null; + var getterTypeSymbol = null; + + if (isStatic) { + parent = parent.getConstructorMethod().type; + } + + accessorSymbol = parent.findMember(funcName, false); + + if (accessorSymbol) { + if (!accessorSymbol.isAccessor()) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [getAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + } else { + getterSymbol = accessorSymbol.getGetter(); + + if (getterSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Getter_0_already_declared, [getAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + getterSymbol = null; + } + } + } + + if (accessorSymbol) { + parentHadSymbol = true; + } + + if (accessorSymbol && getterSymbol) { + getterTypeSymbol = getterSymbol.type; + } + + if (!accessorSymbol) { + accessorSymbol = new TypeScript.PullAccessorSymbol(funcName); + } + + if (!getterSymbol) { + getterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + getterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + getterTypeSymbol.setFunctionSymbol(getterSymbol); + + getterSymbol.type = getterTypeSymbol; + + accessorSymbol.setGetter(getterSymbol); + } + + getAccessorDeclaration.setSymbol(accessorSymbol); + accessorSymbol.addDeclaration(getAccessorDeclaration); + getterSymbol.addDeclaration(getAccessorDeclaration); + + var nameAST = funcDeclAST.propertyName; + this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, getterSymbol); + + if (!parentHadSymbol) { + parent.addMember(accessorSymbol); + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(getAccessorDeclaration); + getAccessorDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDeclAST, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), getterTypeSymbol, signature); + + getterTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindSetAccessorDeclarationToPullSymbol = function (setAccessorDeclaration) { + var declKind = setAccessorDeclaration.kind; + var declFlags = setAccessorDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(setAccessorDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = setAccessorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var isStatic = false; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + var parent = this.getParent(setAccessorDeclaration, true); + var parentHadSymbol = false; + + var accessorSymbol = null; + var setterSymbol = null; + var setterTypeSymbol = null; + + if (isStatic) { + parent = parent.getConstructorMethod().type; + } + + accessorSymbol = parent.findMember(funcName, false); + + if (accessorSymbol) { + if (!accessorSymbol.isAccessor()) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [setAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + } else { + setterSymbol = accessorSymbol.getSetter(); + + if (setterSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Setter_0_already_declared, [setAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + setterSymbol = null; + } + } + } + + if (accessorSymbol) { + parentHadSymbol = true; + + if (setterSymbol) { + setterTypeSymbol = setterSymbol.type; + } + } + + if (!accessorSymbol) { + accessorSymbol = new TypeScript.PullAccessorSymbol(funcName); + } + + if (!setterSymbol) { + setterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + setterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + setterTypeSymbol.setFunctionSymbol(setterSymbol); + + setterSymbol.type = setterTypeSymbol; + + accessorSymbol.setSetter(setterSymbol); + } + + setAccessorDeclaration.setSymbol(accessorSymbol); + accessorSymbol.addDeclaration(setAccessorDeclaration); + setterSymbol.addDeclaration(setAccessorDeclaration); + + var nameAST = funcDeclAST.propertyName; + this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, setterSymbol); + + if (!parentHadSymbol) { + parent.addMember(accessorSymbol); + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(setAccessorDeclaration); + setAccessorDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDeclAST, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), setterTypeSymbol, signature); + + setterTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindDeclToPullSymbol = function (decl) { + if (decl.hasBeenBound()) { + return; + } + + if (this.declsBeingBound.indexOf(decl.declID) >= 0) { + return; + } + + this.declsBeingBound.push(decl.declID); + + switch (decl.kind) { + case 1 /* Script */: + var childDecls = decl.getChildDecls(); + for (var i = 0; i < childDecls.length; i++) { + this.bindDeclToPullSymbol(childDecls[i]); + } + break; + + case 64 /* Enum */: + this.bindEnumDeclarationToPullSymbol(decl); + break; + + case 32 /* DynamicModule */: + case 4 /* Container */: + this.bindModuleDeclarationToPullSymbol(decl); + break; + + case 16 /* Interface */: + this.bindInterfaceDeclarationToPullSymbol(decl); + break; + + case 8 /* Class */: + this.bindClassDeclarationToPullSymbol(decl); + break; + + case 16384 /* Function */: + this.bindFunctionDeclarationToPullSymbol(decl); + break; + + case 512 /* Variable */: + this.bindVariableDeclarationToPullSymbol(decl); + break; + + case 1024 /* CatchVariable */: + this.bindCatchVariableToPullSymbol(decl); + break; + + case 67108864 /* EnumMember */: + this.bindEnumMemberDeclarationToPullSymbol(decl); + break; + + case 4096 /* Property */: + this.bindPropertyDeclarationToPullSymbol(decl); + break; + + case 65536 /* Method */: + this.bindMethodDeclarationToPullSymbol(decl); + break; + + case 32768 /* ConstructorMethod */: + this.bindConstructorDeclarationToPullSymbol(decl); + break; + + case 1048576 /* CallSignature */: + this.bindCallSignatureDeclarationToPullSymbol(decl); + break; + + case 2097152 /* ConstructSignature */: + this.bindConstructSignatureDeclarationToPullSymbol(decl); + break; + + case 4194304 /* IndexSignature */: + this.bindIndexSignatureDeclarationToPullSymbol(decl); + break; + + case 262144 /* GetAccessor */: + this.bindGetAccessorDeclarationToPullSymbol(decl); + break; + + case 524288 /* SetAccessor */: + this.bindSetAccessorDeclarationToPullSymbol(decl); + break; + + case 8388608 /* ObjectType */: + this.bindObjectTypeDeclarationToPullSymbol(decl); + break; + + case 16777216 /* FunctionType */: + this.bindFunctionTypeDeclarationToPullSymbol(decl); + break; + + case 33554432 /* ConstructorType */: + this.bindConstructorTypeDeclarationToPullSymbol(decl); + break; + + case 131072 /* FunctionExpression */: + this.bindFunctionExpressionToPullSymbol(decl); + break; + + case 128 /* TypeAlias */: + this.bindImportDeclaration(decl); + break; + + case 2048 /* Parameter */: + case 8192 /* TypeParameter */: + decl.getParentDecl().getSymbol(); + break; + + case 268435456 /* CatchBlock */: + case 134217728 /* WithBlock */: + break; + + default: + TypeScript.CompilerDiagnostics.assert(false, "Unrecognized type declaration"); + } + + TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(this.declsBeingBound) === decl.declID); + this.declsBeingBound.pop(); + }; + return PullSymbolBinder; + })(); + TypeScript.PullSymbolBinder = PullSymbolBinder; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (PullHelpers) { + function getSignatureForFuncDecl(functionDecl) { + var funcDecl = functionDecl.ast(); + var funcSymbol = functionDecl.getSymbol(); + + if (!funcSymbol) { + funcSymbol = functionDecl.getSignatureSymbol(); + } + + var functionSignature = null; + var typeSymbolWithAllSignatures = null; + if (funcSymbol.isSignature()) { + functionSignature = funcSymbol; + var parent = functionDecl.getParentDecl(); + typeSymbolWithAllSignatures = parent.getSymbol().type; + } else { + functionSignature = functionDecl.getSignatureSymbol(); + typeSymbolWithAllSignatures = funcSymbol.type; + } + var signatures; + + if (funcDecl.kind() === 137 /* ConstructorDeclaration */ || functionDecl.kind === 2097152 /* ConstructSignature */) { + signatures = typeSymbolWithAllSignatures.getConstructSignatures(); + } else if (functionDecl.kind === 4194304 /* IndexSignature */) { + signatures = typeSymbolWithAllSignatures.getIndexSignatures(); + } else { + signatures = typeSymbolWithAllSignatures.getCallSignatures(); + } + + return { + signature: functionSignature, + allSignatures: signatures + }; + } + PullHelpers.getSignatureForFuncDecl = getSignatureForFuncDecl; + + function getAccessorSymbol(getterOrSetter, semanticInfoChain) { + var functionDecl = semanticInfoChain.getDeclForAST(getterOrSetter); + var getterOrSetterSymbol = functionDecl.getSymbol(); + + return getterOrSetterSymbol; + } + PullHelpers.getAccessorSymbol = getAccessorSymbol; + + function getGetterAndSetterFunction(funcDecl, semanticInfoChain) { + var accessorSymbol = PullHelpers.getAccessorSymbol(funcDecl, semanticInfoChain); + var result = { + getter: null, + setter: null + }; + var getter = accessorSymbol.getGetter(); + if (getter) { + var getterDecl = getter.getDeclarations()[0]; + result.getter = semanticInfoChain.getASTForDecl(getterDecl); + } + var setter = accessorSymbol.getSetter(); + if (setter) { + var setterDecl = setter.getDeclarations()[0]; + result.setter = semanticInfoChain.getASTForDecl(setterDecl); + } + + return result; + } + PullHelpers.getGetterAndSetterFunction = getGetterAndSetterFunction; + + function symbolIsEnum(source) { + return source && (source.kind & (64 /* Enum */ | 67108864 /* EnumMember */)) !== 0; + } + PullHelpers.symbolIsEnum = symbolIsEnum; + + function symbolIsModule(symbol) { + return symbol && (symbol.kind == 4 /* Container */ || isOneDeclarationOfKind(symbol, 4 /* Container */)); + } + PullHelpers.symbolIsModule = symbolIsModule; + + function isOneDeclarationOfKind(symbol, kind) { + var decls = symbol.getDeclarations(); + for (var i = 0; i < decls.length; i++) { + if (decls[i].kind === kind) { + return true; + } + } + + return false; + } + + function isNameNumeric(name) { + return isFinite(+name); + } + PullHelpers.isNameNumeric = isNameNumeric; + + function typeSymbolsAreIdentical(a, b) { + if (a.isTypeReference() && !a.getIsSpecialized()) { + a = a.referencedTypeSymbol; + } + + if (b.isTypeReference() && !b.getIsSpecialized()) { + b = b.referencedTypeSymbol; + } + + return a == b; + } + PullHelpers.typeSymbolsAreIdentical = typeSymbolsAreIdentical; + + function getRootType(type) { + var rootType = type.getRootSymbol(); + + while (true) { + if (type == rootType) { + return type; + } + + type = rootType; + rootType = type.getRootSymbol(); + } + } + PullHelpers.getRootType = getRootType; + + function isSymbolLocal(symbol) { + var container = symbol.getContainer(); + if (container) { + var containerKind = container.kind; + if (containerKind & (1032192 /* SomeFunction */ | 16777216 /* FunctionType */)) { + return true; + } + + if (containerKind == 33554432 /* ConstructorType */ && !symbol.anyDeclHasFlag(16 /* Static */)) { + return true; + } + } + + return false; + } + PullHelpers.isSymbolLocal = isSymbolLocal; + })(TypeScript.PullHelpers || (TypeScript.PullHelpers = {})); + var PullHelpers = TypeScript.PullHelpers; +})(TypeScript || (TypeScript = {})); +if (Error) + Error.stackTraceLimit = 1000; + +var TypeScript; +(function (TypeScript) { + TypeScript.fileResolutionTime = 0; + TypeScript.fileResolutionIOTime = 0; + TypeScript.fileResolutionScanImportsTime = 0; + TypeScript.fileResolutionImportFileSearchTime = 0; + TypeScript.fileResolutionGetDefaultLibraryTime = 0; + TypeScript.sourceCharactersCompiled = 0; + TypeScript.syntaxTreeParseTime = 0; + TypeScript.syntaxDiagnosticsTime = 0; + TypeScript.astTranslationTime = 0; + TypeScript.typeCheckTime = 0; + + TypeScript.compilerResolvePathTime = 0; + TypeScript.compilerDirectoryNameTime = 0; + TypeScript.compilerDirectoryExistsTime = 0; + TypeScript.compilerFileExistsTime = 0; + + TypeScript.emitTime = 0; + TypeScript.emitWriteFileTime = 0; + + TypeScript.declarationEmitTime = 0; + TypeScript.declarationEmitIsExternallyVisibleTime = 0; + TypeScript.declarationEmitTypeSignatureTime = 0; + TypeScript.declarationEmitGetBoundDeclTypeTime = 0; + TypeScript.declarationEmitIsOverloadedCallSignatureTime = 0; + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime = 0; + TypeScript.declarationEmitGetBaseTypeTime = 0; + TypeScript.declarationEmitGetAccessorFunctionTime = 0; + TypeScript.declarationEmitGetTypeParameterSymbolTime = 0; + TypeScript.declarationEmitGetImportDeclarationSymbolTime = 0; + + TypeScript.ioHostResolvePathTime = 0; + TypeScript.ioHostDirectoryNameTime = 0; + TypeScript.ioHostCreateDirectoryStructureTime = 0; + TypeScript.ioHostWriteFileTime = 0; + + var EmitOutput = (function () { + function EmitOutput() { + this.outputFiles = []; + this.diagnostics = []; + } + return EmitOutput; + })(); + TypeScript.EmitOutput = EmitOutput; + + (function (OutputFileType) { + OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript"; + OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap"; + OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration"; + })(TypeScript.OutputFileType || (TypeScript.OutputFileType = {})); + var OutputFileType = TypeScript.OutputFileType; + + var OutputFile = (function () { + function OutputFile(name, writeByteOrderMark, text, fileType, sourceMapEntries) { + if (typeof sourceMapEntries === "undefined") { sourceMapEntries = []; } + this.name = name; + this.writeByteOrderMark = writeByteOrderMark; + this.text = text; + this.fileType = fileType; + this.sourceMapEntries = sourceMapEntries; + } + return OutputFile; + })(); + TypeScript.OutputFile = OutputFile; + + var CompileResult = (function () { + function CompileResult() { + this.diagnostics = []; + this.outputFiles = []; + } + CompileResult.fromDiagnostics = function (diagnostics) { + var result = new CompileResult(); + result.diagnostics = diagnostics; + return result; + }; + + CompileResult.fromOutputFiles = function (outputFiles) { + var result = new CompileResult(); + result.outputFiles = outputFiles; + return result; + }; + return CompileResult; + })(); + TypeScript.CompileResult = CompileResult; + + var TypeScriptCompiler = (function () { + function TypeScriptCompiler(logger, _settings) { + if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); } + if (typeof _settings === "undefined") { _settings = TypeScript.ImmutableCompilationSettings.defaultSettings(); } + this.logger = logger; + this._settings = _settings; + this.semanticInfoChain = null; + this.semanticInfoChain = new TypeScript.SemanticInfoChain(this, logger); + } + TypeScriptCompiler.prototype.compilationSettings = function () { + return this._settings; + }; + + TypeScriptCompiler.prototype.setCompilationSettings = function (newSettings) { + var oldSettings = this._settings; + this._settings = newSettings; + + if (!compareDataObjects(oldSettings, newSettings)) { + this.semanticInfoChain.invalidate(oldSettings, newSettings); + } + }; + + TypeScriptCompiler.prototype.getDocument = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + return this.semanticInfoChain.getDocument(fileName); + }; + + TypeScriptCompiler.prototype.cleanupSemanticCache = function () { + this.semanticInfoChain.invalidate(); + }; + + TypeScriptCompiler.prototype.addFile = function (fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) { + if (typeof referencedFiles === "undefined") { referencedFiles = []; } + fileName = TypeScript.switchToForwardSlashes(fileName); + + TypeScript.sourceCharactersCompiled += scriptSnapshot.getLength(); + + var document = TypeScript.Document.create(this, this.semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles); + + this.semanticInfoChain.addDocument(document); + }; + + TypeScriptCompiler.prototype.updateFile = function (fileName, scriptSnapshot, version, isOpen, textChangeRange) { + fileName = TypeScript.switchToForwardSlashes(fileName); + + var document = this.getDocument(fileName); + var updatedDocument = document.update(scriptSnapshot, version, isOpen, textChangeRange); + + this.semanticInfoChain.addDocument(updatedDocument); + }; + + TypeScriptCompiler.prototype.removeFile = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + this.semanticInfoChain.removeDocument(fileName); + }; + + TypeScriptCompiler.prototype._isDynamicModuleCompilation = function () { + var fileNames = this.fileNames(); + for (var i = 0, n = fileNames.length; i < n; i++) { + var document = this.getDocument(fileNames[i]); + if (!document.isDeclareFile() && document.isExternalModule()) { + return true; + } + } + return false; + }; + + TypeScriptCompiler.prototype.mapOutputFileName = function (document, emitOptions, extensionChanger) { + if (document.emitToOwnOutputFile()) { + var updatedFileName = document.fileName; + if (emitOptions.outputDirectory() !== "") { + updatedFileName = document.fileName.replace(emitOptions.commonDirectoryPath(), ""); + updatedFileName = emitOptions.outputDirectory() + updatedFileName; + } + return extensionChanger(updatedFileName, false); + } else { + return extensionChanger(emitOptions.sharedOutputFile(), true); + } + }; + + TypeScriptCompiler.prototype.writeByteOrderMarkForDocument = function (document) { + var printReason = false; + + if (document.emitToOwnOutputFile()) { + var result = document.byteOrderMark !== 0 /* None */; + if (printReason) { + TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName); + } + return result; + } else { + var fileNames = this.fileNames(); + + var result = false; + for (var i = 0, n = fileNames.length; i < n; i++) { + var document = this.getDocument(fileNames[i]); + + if (document.isExternalModule()) { + continue; + } + + if (document.byteOrderMark !== 0 /* None */) { + if (printReason) { + TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName); + result = true; + } else { + return true; + } + } + } + + return result; + } + }; + + TypeScriptCompiler.mapToDTSFileName = function (fileName, wholeFileNameReplaced) { + return TypeScript.getDeclareFilePath(fileName); + }; + + TypeScriptCompiler.prototype._shouldEmit = function (document) { + return !document.isDeclareFile(); + }; + + TypeScriptCompiler.prototype._shouldEmitDeclarations = function (document) { + if (!this.compilationSettings().generateDeclarationFiles()) { + return false; + } + + return this._shouldEmit(document); + }; + + TypeScriptCompiler.prototype.emitDocumentDeclarationsWorker = function (document, emitOptions, declarationEmitter) { + var sourceUnit = document.sourceUnit(); + TypeScript.Debug.assert(this._shouldEmitDeclarations(document)); + + if (declarationEmitter) { + declarationEmitter.document = document; + } else { + var declareFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToDTSFileName); + declarationEmitter = new TypeScript.DeclarationEmitter(declareFileName, document, this, emitOptions, this.semanticInfoChain); + } + + declarationEmitter.emitDeclarations(sourceUnit); + return declarationEmitter; + }; + + TypeScriptCompiler.prototype._emitDocumentDeclarations = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) { + if (this._shouldEmitDeclarations(document)) { + if (document.emitToOwnOutputFile()) { + var singleEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions); + if (singleEmitter) { + onSingleFileEmitComplete(singleEmitter.getOutputFile()); + } + } else { + sharedEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions, sharedEmitter); + } + } + + return sharedEmitter; + }; + + TypeScriptCompiler.prototype.emitAllDeclarations = function (resolvePath) { + var start = new Date().getTime(); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var sharedEmitter = null; + var fileNames = this.fileNames(); + + for (var i = 0, n = fileNames.length; i < n; i++) { + var fileName = fileNames[i]; + + var document = this.getDocument(fileNames[i]); + + sharedEmitter = this._emitDocumentDeclarations(document, emitOptions, function (file) { + return emitOutput.outputFiles.push(file); + }, sharedEmitter); + } + + if (sharedEmitter) { + emitOutput.outputFiles.push(sharedEmitter.getOutputFile()); + } + + TypeScript.declarationEmitTime += new Date().getTime() - start; + + return emitOutput; + }; + + TypeScriptCompiler.prototype.emitDeclarations = function (fileName, resolvePath) { + fileName = TypeScript.switchToForwardSlashes(fileName); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var document = this.getDocument(fileName); + + if (document.emitToOwnOutputFile()) { + this._emitDocumentDeclarations(document, emitOptions, function (file) { + return emitOutput.outputFiles.push(file); + }, null); + return emitOutput; + } else { + return this.emitAllDeclarations(resolvePath); + } + }; + + TypeScriptCompiler.mapToFileNameExtension = function (extension, fileName, wholeFileNameReplaced) { + if (wholeFileNameReplaced) { + return fileName; + } else { + var splitFname = fileName.split("."); + splitFname.pop(); + return splitFname.join(".") + extension; + } + }; + + TypeScriptCompiler.mapToJSFileName = function (fileName, wholeFileNameReplaced) { + return TypeScriptCompiler.mapToFileNameExtension(".js", fileName, wholeFileNameReplaced); + }; + + TypeScriptCompiler.prototype.emitDocumentWorker = function (document, emitOptions, emitter) { + var sourceUnit = document.sourceUnit(); + TypeScript.Debug.assert(this._shouldEmit(document)); + + var typeScriptFileName = document.fileName; + if (!emitter) { + var javaScriptFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToJSFileName); + var outFile = new TypeScript.TextWriter(javaScriptFileName, this.writeByteOrderMarkForDocument(document), 0 /* JavaScript */); + + emitter = new TypeScript.Emitter(javaScriptFileName, outFile, emitOptions, this.semanticInfoChain); + + if (this.compilationSettings().mapSourceFiles()) { + var sourceMapFile = new TypeScript.TextWriter(javaScriptFileName + TypeScript.SourceMapper.MapFileExtension, false, 1 /* SourceMap */); + emitter.createSourceMapper(document, javaScriptFileName, outFile, sourceMapFile, emitOptions.resolvePath); + } + } else if (this.compilationSettings().mapSourceFiles()) { + emitter.setSourceMapperNewSourceFile(document); + } + + emitter.setDocument(document); + emitter.emitJavascript(sourceUnit, false); + + return emitter; + }; + + TypeScriptCompiler.prototype._emitDocument = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) { + if (this._shouldEmit(document)) { + if (document.emitToOwnOutputFile()) { + var singleEmitter = this.emitDocumentWorker(document, emitOptions); + if (singleEmitter) { + onSingleFileEmitComplete(singleEmitter.getOutputFiles()); + } + } else { + sharedEmitter = this.emitDocumentWorker(document, emitOptions, sharedEmitter); + } + } + + return sharedEmitter; + }; + + TypeScriptCompiler.prototype.emitAll = function (resolvePath) { + var start = new Date().getTime(); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var fileNames = this.fileNames(); + var sharedEmitter = null; + + for (var i = 0, n = fileNames.length; i < n; i++) { + var fileName = fileNames[i]; + + var document = this.getDocument(fileName); + + sharedEmitter = this._emitDocument(document, emitOptions, function (files) { + return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files); + }, sharedEmitter); + } + + if (sharedEmitter) { + emitOutput.outputFiles.push.apply(emitOutput.outputFiles, sharedEmitter.getOutputFiles()); + } + + TypeScript.emitTime += new Date().getTime() - start; + return emitOutput; + }; + + TypeScriptCompiler.prototype.emit = function (fileName, resolvePath) { + fileName = TypeScript.switchToForwardSlashes(fileName); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var document = this.getDocument(fileName); + + if (document.emitToOwnOutputFile()) { + this._emitDocument(document, emitOptions, function (files) { + return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files); + }, null); + return emitOutput; + } else { + return this.emitAll(resolvePath); + } + }; + + TypeScriptCompiler.prototype.compile = function (resolvePath, continueOnDiagnostics) { + if (typeof continueOnDiagnostics === "undefined") { continueOnDiagnostics = false; } + return new CompilerIterator(this, resolvePath, continueOnDiagnostics); + }; + + TypeScriptCompiler.prototype.getSyntacticDiagnostics = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + return this.getDocument(fileName).diagnostics(); + }; + + TypeScriptCompiler.prototype.getSyntaxTree = function (fileName) { + return this.getDocument(fileName).syntaxTree(); + }; + + TypeScriptCompiler.prototype.getSourceUnit = function (fileName) { + return this.getDocument(fileName).sourceUnit(); + }; + + TypeScriptCompiler.prototype.getSemanticDiagnostics = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + + var document = this.getDocument(fileName); + + var startTime = (new Date()).getTime(); + TypeScript.PullTypeResolver.typeCheck(this.compilationSettings(), this.semanticInfoChain, document); + var endTime = (new Date()).getTime(); + + TypeScript.typeCheckTime += endTime - startTime; + + var errors = this.semanticInfoChain.getDiagnostics(fileName); + + errors = TypeScript.ArrayUtilities.distinct(errors, TypeScript.Diagnostic.equals); + errors.sort(function (d1, d2) { + if (d1.fileName() < d2.fileName()) { + return -1; + } else if (d1.fileName() > d2.fileName()) { + return 1; + } + + if (d1.start() < d2.start()) { + return -1; + } else if (d1.start() > d2.start()) { + return 1; + } + + var code1 = TypeScript.diagnosticInformationMap[d1.diagnosticKey()].code; + var code2 = TypeScript.diagnosticInformationMap[d2.diagnosticKey()].code; + if (code1 < code2) { + return -1; + } else if (code1 > code2) { + return 1; + } + + return 0; + }); + + return errors; + }; + + TypeScriptCompiler.prototype.resolveAllFiles = function () { + var fileNames = this.fileNames(); + for (var i = 0, n = fileNames.length; i < n; i++) { + this.getSemanticDiagnostics(fileNames[i]); + } + }; + + TypeScriptCompiler.prototype.getSymbolOfDeclaration = function (decl) { + if (!decl) { + return null; + } + + var resolver = this.semanticInfoChain.getResolver(); + var ast = this.semanticInfoChain.getASTForDecl(decl); + if (!ast) { + return null; + } + + var enclosingDecl = resolver.getEnclosingDecl(decl); + if (ast.kind() === 139 /* GetAccessor */ || ast.kind() === 140 /* SetAccessor */) { + return this.getSymbolOfDeclaration(enclosingDecl); + } + + return resolver.resolveAST(ast, false, new TypeScript.PullTypeResolutionContext(resolver)); + }; + + TypeScriptCompiler.prototype.extractResolutionContextFromAST = function (resolver, ast, document, propagateContextualTypes) { + var scriptName = document.fileName; + + var enclosingDecl = null; + var enclosingDeclAST = null; + var inContextuallyTypedAssignment = false; + var inWithBlock = false; + + var resolutionContext = new TypeScript.PullTypeResolutionContext(resolver); + + if (!ast) { + return null; + } + + var path = this.getASTPath(ast); + + for (var i = 0, n = path.length; i < n; i++) { + var current = path[i]; + + switch (current.kind()) { + case 222 /* FunctionExpression */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + if (propagateContextualTypes) { + resolver.resolveAST(current, true, resolutionContext); + } + break; + + case 136 /* MemberVariableDeclaration */: + var memberVariable = current; + inContextuallyTypedAssignment = memberVariable.variableDeclarator.typeAnnotation !== null; + + this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, memberVariable, memberVariable.variableDeclarator.equalsValueClause); + break; + + case 225 /* VariableDeclarator */: + var variableDeclarator = current; + inContextuallyTypedAssignment = variableDeclarator.typeAnnotation !== null; + + this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, variableDeclarator, variableDeclarator.equalsValueClause); + break; + + case 213 /* InvocationExpression */: + case 216 /* ObjectCreationExpression */: + if (propagateContextualTypes) { + var isNew = current.kind() === 216 /* ObjectCreationExpression */; + var callExpression = current; + var contextualType = null; + + if ((i + 2 < n) && callExpression.argumentList === path[i + 1] && callExpression.argumentList.arguments === path[i + 2]) { + var arguments = callExpression.argumentList.arguments; + + var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData(); + if (isNew) { + resolver.resolveObjectCreationExpression(callExpression, resolutionContext, callResolutionResults); + } else { + resolver.resolveInvocationExpression(callExpression, resolutionContext, callResolutionResults); + } + + if (callResolutionResults.actualParametersContextTypeSymbols) { + var argExpression = path[i + 3]; + if (argExpression) { + for (var j = 0, m = callExpression.argumentList.arguments.nonSeparatorCount(); j < m; j++) { + if (callExpression.argumentList.arguments.nonSeparatorAt(j) === argExpression) { + var callContextualType = callResolutionResults.actualParametersContextTypeSymbols[j]; + if (callContextualType) { + contextualType = callContextualType; + break; + } + } + } + } + } + } else { + if (isNew) { + resolver.resolveObjectCreationExpression(callExpression, resolutionContext); + } else { + resolver.resolveInvocationExpression(callExpression, resolutionContext); + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 214 /* ArrayLiteralExpression */: + if (propagateContextualTypes) { + var contextualType = null; + var currentContextualType = resolutionContext.getContextualType(); + if (currentContextualType && currentContextualType.isArrayNamedTypeReference()) { + contextualType = currentContextualType.getElementType(); + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 215 /* ObjectLiteralExpression */: + if (propagateContextualTypes) { + var objectLiteralExpression = current; + var objectLiteralResolutionContext = new TypeScript.PullAdditionalObjectLiteralResolutionData(); + resolver.resolveObjectLiteralExpression(objectLiteralExpression, inContextuallyTypedAssignment, resolutionContext, objectLiteralResolutionContext); + + var memeberAST = (path[i + 1] && path[i + 1].kind() === 2 /* SeparatedList */) ? path[i + 2] : path[i + 1]; + if (memeberAST) { + var contextualType = null; + var memberDecls = objectLiteralExpression.propertyAssignments; + if (memberDecls && objectLiteralResolutionContext.membersContextTypeSymbols) { + for (var j = 0, m = memberDecls.nonSeparatorCount(); j < m; j++) { + if (memberDecls.nonSeparatorAt(j) === memeberAST) { + var memberContextualType = objectLiteralResolutionContext.membersContextTypeSymbols[j]; + if (memberContextualType) { + contextualType = memberContextualType; + break; + } + } + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + } + + break; + + case 174 /* AssignmentExpression */: + if (propagateContextualTypes) { + var assignmentExpression = current; + var contextualType = null; + + if (path[i + 1] && path[i + 1] === assignmentExpression.right) { + var leftType = resolver.resolveAST(assignmentExpression.left, inContextuallyTypedAssignment, resolutionContext).type; + if (leftType) { + inContextuallyTypedAssignment = true; + contextualType = leftType; + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 150 /* ReturnStatement */: + if (propagateContextualTypes) { + var returnStatement = current; + var contextualType = null; + + if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */)) { + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation) { + var returnTypeSymbol = resolver.resolveTypeReference(typeAnnotation, resolutionContext); + if (returnTypeSymbol) { + inContextuallyTypedAssignment = true; + contextualType = returnTypeSymbol; + } + } else { + var currentContextualType = resolutionContext.getContextualType(); + if (currentContextualType && currentContextualType.isFunction()) { + var currentContextualTypeSignatureSymbol = currentContextualType.getDeclarations()[0].getSignatureSymbol(); + var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType; + if (currentContextualTypeReturnTypeSymbol) { + inContextuallyTypedAssignment = true; + contextualType = currentContextualTypeReturnTypeSymbol; + } + } + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 122 /* ObjectType */: + if (propagateContextualTypes && TypeScript.isTypesOnlyLocation(current)) { + resolver.resolveAST(current, false, resolutionContext); + } + + break; + + case 163 /* WithStatement */: + inWithBlock = true; + break; + } + + var decl = this.semanticInfoChain.getDeclForAST(current); + if (decl) { + enclosingDecl = decl; + enclosingDeclAST = current; + } + } + + if (ast && ast.parent && ast.kind() === 11 /* IdentifierName */) { + if (ast.parent.kind() === 212 /* MemberAccessExpression */) { + if (ast.parent.name === ast) { + ast = ast.parent; + } + } else if (ast.parent.kind() === 121 /* QualifiedName */) { + if (ast.parent.right === ast) { + ast = ast.parent; + } + } + } + + return { + ast: ast, + enclosingDecl: enclosingDecl, + resolutionContext: resolutionContext, + inContextuallyTypedAssignment: inContextuallyTypedAssignment, + inWithBlock: inWithBlock + }; + }; + + TypeScriptCompiler.prototype.extractResolutionContextForVariable = function (inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, assigningAST, init) { + if (inContextuallyTypedAssignment) { + if (propagateContextualTypes) { + resolver.resolveAST(assigningAST, false, resolutionContext); + var varSymbol = this.semanticInfoChain.getSymbolForAST(assigningAST); + + var contextualType = null; + if (varSymbol && inContextuallyTypedAssignment) { + contextualType = varSymbol.type; + } + + resolutionContext.pushContextualType(contextualType, false, null); + + if (init) { + resolver.resolveAST(init, inContextuallyTypedAssignment, resolutionContext); + } + } + } + }; + + TypeScriptCompiler.prototype.getASTPath = function (ast) { + var result = []; + + while (ast) { + result.unshift(ast); + ast = ast.parent; + } + + return result; + }; + + TypeScriptCompiler.prototype.pullGetSymbolInformationFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + ast = context.ast; + var symbol = resolver.resolveAST(ast, context.inContextuallyTypedAssignment, context.resolutionContext); + + if (!symbol) { + TypeScript.Debug.assert(ast.kind() == 120 /* SourceUnit */, "No symbol was found for ast and ast was not source unit. Ast Kind: " + TypeScript.SyntaxKind[ast.kind()]); + return null; + } + + if (symbol.isTypeReference()) { + symbol = symbol.getReferencedTypeSymbol(); + } + + var aliasSymbol = this.semanticInfoChain.getAliasSymbolForAST(ast); + + return { + symbol: symbol, + aliasSymbol: aliasSymbol, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetCallInformationFromAST = function (ast, document) { + if (ast.kind() !== 213 /* InvocationExpression */ && ast.kind() !== 216 /* ObjectCreationExpression */) { + return null; + } + + var isNew = ast.kind() === 216 /* ObjectCreationExpression */; + + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData(); + + if (isNew) { + resolver.resolveObjectCreationExpression(ast, context.resolutionContext, callResolutionResults); + } else { + resolver.resolveInvocationExpression(ast, context.resolutionContext, callResolutionResults); + } + + return { + targetSymbol: callResolutionResults.targetSymbol, + resolvedSignatures: callResolutionResults.resolvedSignatures, + candidateSignature: callResolutionResults.candidateSignature, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl), + isConstructorCall: isNew + }; + }; + + TypeScriptCompiler.prototype.pullGetVisibleMemberSymbolsFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var symbols = resolver.getVisibleMembersFromExpression(ast, context.enclosingDecl, context.resolutionContext); + if (!symbols) { + return null; + } + + return { + symbols: symbols, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetVisibleDeclsFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, false); + if (!context || context.inWithBlock) { + return null; + } + + return resolver.getVisibleDecls(context.enclosingDecl); + }; + + TypeScriptCompiler.prototype.pullGetContextualMembersFromAST = function (ast, document) { + if (ast.kind() !== 215 /* ObjectLiteralExpression */) { + return null; + } + + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var members = resolver.getVisibleContextSymbols(context.enclosingDecl, context.resolutionContext); + + return { + symbols: members, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetDeclInformation = function (decl, ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var astForDecl = decl.ast(); + if (!astForDecl) { + return null; + } + + var astForDeclContext = this.extractResolutionContextFromAST(resolver, astForDecl, this.getDocument(astForDecl.fileName()), true); + if (!astForDeclContext) { + return null; + } + + var symbol = decl.getSymbol(); + resolver.resolveDeclaredSymbol(symbol, context.resolutionContext); + symbol.setUnresolved(); + + return { + symbol: symbol, + aliasSymbol: null, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.topLevelDeclaration = function (fileName) { + return this.semanticInfoChain.topLevelDecl(fileName); + }; + + TypeScriptCompiler.prototype.getDeclForAST = function (ast) { + return this.semanticInfoChain.getDeclForAST(ast); + }; + + TypeScriptCompiler.prototype.fileNames = function () { + return this.semanticInfoChain.fileNames(); + }; + + TypeScriptCompiler.prototype.topLevelDecl = function (fileName) { + return this.semanticInfoChain.topLevelDecl(fileName); + }; + return TypeScriptCompiler; + })(); + TypeScript.TypeScriptCompiler = TypeScriptCompiler; + + var CompilerPhase; + (function (CompilerPhase) { + CompilerPhase[CompilerPhase["Syntax"] = 0] = "Syntax"; + CompilerPhase[CompilerPhase["Semantics"] = 1] = "Semantics"; + CompilerPhase[CompilerPhase["EmitOptionsValidation"] = 2] = "EmitOptionsValidation"; + CompilerPhase[CompilerPhase["Emit"] = 3] = "Emit"; + CompilerPhase[CompilerPhase["DeclarationEmit"] = 4] = "DeclarationEmit"; + })(CompilerPhase || (CompilerPhase = {})); + + var CompilerIterator = (function () { + function CompilerIterator(compiler, resolvePath, continueOnDiagnostics, startingPhase) { + if (typeof startingPhase === "undefined") { startingPhase = 0 /* Syntax */; } + this.compiler = compiler; + this.resolvePath = resolvePath; + this.continueOnDiagnostics = continueOnDiagnostics; + this.index = -1; + this.fileNames = null; + this._current = null; + this._emitOptions = null; + this._sharedEmitter = null; + this._sharedDeclarationEmitter = null; + this.hadSyntacticDiagnostics = false; + this.hadSemanticDiagnostics = false; + this.hadEmitDiagnostics = false; + this.fileNames = compiler.fileNames(); + this.compilerPhase = startingPhase; + } + CompilerIterator.prototype.current = function () { + return this._current; + }; + + CompilerIterator.prototype.moveNext = function () { + this._current = null; + + while (this.moveNextInternal()) { + if (this._current) { + return true; + } + } + + return false; + }; + + CompilerIterator.prototype.moveNextInternal = function () { + this.index++; + + while (this.shouldMoveToNextPhase()) { + this.index = 0; + this.compilerPhase++; + } + + if (this.compilerPhase > 4 /* DeclarationEmit */) { + return false; + } + + switch (this.compilerPhase) { + case 0 /* Syntax */: + return this.moveNextSyntaxPhase(); + case 1 /* Semantics */: + return this.moveNextSemanticsPhase(); + case 2 /* EmitOptionsValidation */: + return this.moveNextEmitOptionsValidationPhase(); + case 3 /* Emit */: + return this.moveNextEmitPhase(); + case 4 /* DeclarationEmit */: + return this.moveNextDeclarationEmitPhase(); + } + }; + + CompilerIterator.prototype.shouldMoveToNextPhase = function () { + switch (this.compilerPhase) { + case 2 /* EmitOptionsValidation */: + return this.index === 1; + + case 0 /* Syntax */: + case 1 /* Semantics */: + return this.index == this.fileNames.length; + + case 3 /* Emit */: + case 4 /* DeclarationEmit */: + return this.index == (this.fileNames.length + 1); + } + + return false; + }; + + CompilerIterator.prototype.moveNextSyntaxPhase = function () { + TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length); + var fileName = this.fileNames[this.index]; + + var diagnostics = this.compiler.getSyntacticDiagnostics(fileName); + if (diagnostics.length) { + if (!this.continueOnDiagnostics) { + this.hadSyntacticDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics(diagnostics); + } + + return true; + }; + + CompilerIterator.prototype.moveNextSemanticsPhase = function () { + if (this.hadSyntacticDiagnostics) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length); + var fileName = this.fileNames[this.index]; + var diagnostics = this.compiler.getSemanticDiagnostics(fileName); + if (diagnostics.length) { + if (!this.continueOnDiagnostics) { + this.hadSemanticDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics(diagnostics); + } + + return true; + }; + + CompilerIterator.prototype.moveNextEmitOptionsValidationPhase = function () { + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + + if (!this._emitOptions) { + this._emitOptions = new TypeScript.EmitOptions(this.compiler, this.resolvePath); + } + + if (this._emitOptions.diagnostic()) { + if (!this.continueOnDiagnostics) { + this.hadEmitDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics([this._emitOptions.diagnostic()]); + } + + return true; + }; + + CompilerIterator.prototype.moveNextEmitPhase = function () { + var _this = this; + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + TypeScript.Debug.assert(this._emitOptions); + + if (this.hadEmitDiagnostics) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length); + if (this.index < this.fileNames.length) { + var fileName = this.fileNames[this.index]; + var document = this.compiler.getDocument(fileName); + + this._sharedEmitter = this.compiler._emitDocument(document, this._emitOptions, function (outputFiles) { + _this._current = CompileResult.fromOutputFiles(outputFiles); + }, this._sharedEmitter); + return true; + } + + if (this.index === this.fileNames.length && this._sharedEmitter) { + this._current = CompileResult.fromOutputFiles(this._sharedEmitter.getOutputFiles()); + } + + return true; + }; + + CompilerIterator.prototype.moveNextDeclarationEmitPhase = function () { + var _this = this; + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + TypeScript.Debug.assert(!this.hadEmitDiagnostics); + if (this.hadSemanticDiagnostics) { + return false; + } + + if (!this.compiler.compilationSettings().generateDeclarationFiles()) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length); + if (this.index < this.fileNames.length) { + var fileName = this.fileNames[this.index]; + var document = this.compiler.getDocument(fileName); + + this._sharedDeclarationEmitter = this.compiler._emitDocumentDeclarations(document, this._emitOptions, function (file) { + _this._current = CompileResult.fromOutputFiles([file]); + }, this._sharedDeclarationEmitter); + return true; + } + + if (this.index === this.fileNames.length && this._sharedDeclarationEmitter) { + this._current = CompileResult.fromOutputFiles([this._sharedDeclarationEmitter.getOutputFile()]); + } + + return true; + }; + return CompilerIterator; + })(); + + function compareDataObjects(dst, src) { + for (var e in dst) { + if (typeof dst[e] == "object") { + if (!compareDataObjects(dst[e], src[e])) + return false; + } else if (typeof dst[e] != "function") { + if (dst[e] !== src[e]) + return false; + } + } + return true; + } + TypeScript.compareDataObjects = compareDataObjects; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (GenerativeTypeClassification) { + GenerativeTypeClassification[GenerativeTypeClassification["Unknown"] = 0] = "Unknown"; + GenerativeTypeClassification[GenerativeTypeClassification["Open"] = 1] = "Open"; + GenerativeTypeClassification[GenerativeTypeClassification["Closed"] = 2] = "Closed"; + GenerativeTypeClassification[GenerativeTypeClassification["InfinitelyExpanding"] = 3] = "InfinitelyExpanding"; + })(TypeScript.GenerativeTypeClassification || (TypeScript.GenerativeTypeClassification = {})); + var GenerativeTypeClassification = TypeScript.GenerativeTypeClassification; + + var PullTypeReferenceSymbol = (function (_super) { + __extends(PullTypeReferenceSymbol, _super); + function PullTypeReferenceSymbol(referencedTypeSymbol) { + _super.call(this, referencedTypeSymbol.name, referencedTypeSymbol.kind); + this.referencedTypeSymbol = referencedTypeSymbol; + this.isResolved = true; + + TypeScript.Debug.assert(referencedTypeSymbol != null, "Type root symbol may not be null"); + + this.setRootSymbol(referencedTypeSymbol); + + this.typeReference = this; + } + PullTypeReferenceSymbol.createTypeReference = function (type) { + if (type.isTypeReference()) { + return type; + } + + var typeReference = type.typeReference; + + if (!typeReference) { + typeReference = new PullTypeReferenceSymbol(type); + type.typeReference = typeReference; + } + + return typeReference; + }; + + PullTypeReferenceSymbol.prototype.isTypeReference = function () { + return true; + }; + + PullTypeReferenceSymbol.prototype.setResolved = function () { + }; + + PullTypeReferenceSymbol.prototype.setUnresolved = function () { + }; + PullTypeReferenceSymbol.prototype.invalidate = function () { + }; + + PullTypeReferenceSymbol.prototype.ensureReferencedTypeIsResolved = function () { + this._getResolver().resolveDeclaredSymbol(this.referencedTypeSymbol); + }; + + PullTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol; + }; + + PullTypeReferenceSymbol.prototype._getResolver = function () { + return this.referencedTypeSymbol._getResolver(); + }; + + PullTypeReferenceSymbol.prototype.hasMembers = function () { + return this.referencedTypeSymbol.hasMembers(); + }; + + PullTypeReferenceSymbol.prototype.setAssociatedContainerType = function (type) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setAssociatedContainerType"); + }; + + PullTypeReferenceSymbol.prototype.getAssociatedContainerType = function () { + return this.referencedTypeSymbol.getAssociatedContainerType(); + }; + + PullTypeReferenceSymbol.prototype.getFunctionSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getFunctionSymbol(); + }; + PullTypeReferenceSymbol.prototype.setFunctionSymbol = function (symbol) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setFunctionSymbol"); + }; + + PullTypeReferenceSymbol.prototype.addContainedNonMember = function (nonMember) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addContainedNonMember"); + }; + PullTypeReferenceSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.findContainedNonMemberContainer(containerName, kind); + }; + + PullTypeReferenceSymbol.prototype.addMember = function (memberSymbol) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addMember"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedMemberType = function (enclosedType) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberType"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberContainer"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMember"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberType"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberContainer"); + }; + PullTypeReferenceSymbol.prototype.addTypeParameter = function (typeParameter) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addTypeParameter"); + }; + PullTypeReferenceSymbol.prototype.addConstructorTypeParameter = function (typeParameter) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructorTypeParameter"); + }; + + PullTypeReferenceSymbol.prototype.findContainedNonMember = function (name) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findContainedNonMember(name); + }; + + PullTypeReferenceSymbol.prototype.findContainedNonMemberType = function (typeName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findContainedNonMemberType(typeName, kind); + }; + + PullTypeReferenceSymbol.prototype.getMembers = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getMembers(); + }; + + PullTypeReferenceSymbol.prototype.setHasDefaultConstructor = function (hasOne) { + if (typeof hasOne === "undefined") { hasOne = true; } + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ":setHasDefaultConstructor"); + }; + PullTypeReferenceSymbol.prototype.getHasDefaultConstructor = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getHasDefaultConstructor(); + }; + PullTypeReferenceSymbol.prototype.getConstructorMethod = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getConstructorMethod(); + }; + PullTypeReferenceSymbol.prototype.setConstructorMethod = function (constructorMethod) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setConstructorMethod"); + }; + PullTypeReferenceSymbol.prototype.getTypeParameters = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeParameters(); + }; + + PullTypeReferenceSymbol.prototype.isGeneric = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.isGeneric(); + }; + + PullTypeReferenceSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.addSpecialization(specializedVersionOfThisType, substitutingTypes); + }; + PullTypeReferenceSymbol.prototype.getSpecialization = function (substitutingTypes) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getSpecialization(substitutingTypes); + }; + PullTypeReferenceSymbol.prototype.getKnownSpecializations = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getKnownSpecializations(); + }; + PullTypeReferenceSymbol.prototype.getTypeArguments = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeArguments(); + }; + PullTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeArgumentsOrTypeParameters(); + }; + + PullTypeReferenceSymbol.prototype.addCallSignature = function (callSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addCallSignature"); + }; + PullTypeReferenceSymbol.prototype.addConstructSignature = function (constructSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructSignature"); + }; + PullTypeReferenceSymbol.prototype.addIndexSignature = function (indexSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addIndexSignature"); + }; + + PullTypeReferenceSymbol.prototype.hasOwnCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnCallSignatures(); + }; + PullTypeReferenceSymbol.prototype.getCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getCallSignatures(); + }; + PullTypeReferenceSymbol.prototype.hasOwnConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnConstructSignatures(); + }; + PullTypeReferenceSymbol.prototype.getConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getConstructSignatures(); + }; + PullTypeReferenceSymbol.prototype.hasOwnIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnIndexSignatures(); + }; + PullTypeReferenceSymbol.prototype.getIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getIndexSignatures(); + }; + + PullTypeReferenceSymbol.prototype.addImplementedType = function (implementedType) { + this.referencedTypeSymbol.addImplementedType(implementedType); + }; + PullTypeReferenceSymbol.prototype.getImplementedTypes = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getImplementedTypes(); + }; + PullTypeReferenceSymbol.prototype.addExtendedType = function (extendedType) { + this.referencedTypeSymbol.addExtendedType(extendedType); + }; + PullTypeReferenceSymbol.prototype.getExtendedTypes = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getExtendedTypes(); + }; + PullTypeReferenceSymbol.prototype.addTypeThatExtendsThisType = function (type) { + this.referencedTypeSymbol.addTypeThatExtendsThisType(type); + }; + PullTypeReferenceSymbol.prototype.getTypesThatExtendThisType = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypesThatExtendThisType(); + }; + PullTypeReferenceSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) { + this.referencedTypeSymbol.addTypeThatExplicitlyImplementsThisType(type); + }; + PullTypeReferenceSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypesThatExplicitlyImplementThisType(); + }; + + PullTypeReferenceSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasBase(potentialBase, visited); + }; + PullTypeReferenceSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.isValidBaseKind(baseType, isExtendedType); + }; + + PullTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) { + if (typeof lookInParent === "undefined") { lookInParent = true; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findMember(name, lookInParent); + }; + PullTypeReferenceSymbol.prototype.findNestedType = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findNestedType(name, kind); + }; + PullTypeReferenceSymbol.prototype.findNestedContainer = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findNestedContainer(name, kind); + }; + PullTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + }; + + PullTypeReferenceSymbol.prototype.findTypeParameter = function (name) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findTypeParameter(name); + }; + + PullTypeReferenceSymbol.prototype.hasOnlyOverloadCallSignatures = function () { + return this.referencedTypeSymbol.hasOnlyOverloadCallSignatures(); + }; + return PullTypeReferenceSymbol; + })(TypeScript.PullTypeSymbol); + TypeScript.PullTypeReferenceSymbol = PullTypeReferenceSymbol; + + TypeScript.nSpecializationsCreated = 0; + TypeScript.nSpecializedSignaturesCreated = 0; + + var PullInstantiatedTypeReferenceSymbol = (function (_super) { + __extends(PullInstantiatedTypeReferenceSymbol, _super); + function PullInstantiatedTypeReferenceSymbol(referencedTypeSymbol, _typeParameterArgumentMap) { + _super.call(this, referencedTypeSymbol); + this.referencedTypeSymbol = referencedTypeSymbol; + this._typeParameterArgumentMap = _typeParameterArgumentMap; + this._instantiatedMembers = null; + this._allInstantiatedMemberNameCache = null; + this._instantiatedMemberNameCache = TypeScript.createIntrinsicsObject(); + this._instantiatedCallSignatures = null; + this._instantiatedConstructSignatures = null; + this._instantiatedIndexSignatures = null; + this._typeArgumentReferences = null; + this._instantiatedConstructorMethod = null; + this._instantiatedAssociatedContainerType = null; + this._isArray = undefined; + this.isInstanceReferenceType = false; + this._generativeTypeClassification = 0 /* Unknown */; + + TypeScript.nSpecializationsCreated++; + } + PullInstantiatedTypeReferenceSymbol.prototype.getIsSpecialized = function () { + return !this.isInstanceReferenceType; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) { + if (this._generativeTypeClassification == 0 /* Unknown */) { + var typeParameters = enclosingType.getTypeParameters(); + var typeReferenceTypeArguments = this.getRootSymbol().getTypeArguments(); + var referenceTypeArgument = null; + + if (!typeReferenceTypeArguments) { + var typeParametersMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParametersMap[typeParameters[i].pullSymbolID] = typeParameters[i]; + } + + var rootThis = TypeScript.PullHelpers.getRootType(this); + var wrapsSomeTypeParameters = rootThis.wrapsSomeTypeParameter(typeParametersMap); + + if (wrapsSomeTypeParameters && this.wrapsSomeNestedTypeIntoInfiniteExpansion(enclosingType)) { + this._generativeTypeClassification = 3 /* InfinitelyExpanding */; + } else if (wrapsSomeTypeParameters) { + this._generativeTypeClassification = 1 /* Open */; + } else { + this._generativeTypeClassification = 2 /* Closed */; + } + } else { + var i = 0; + + while (i < typeReferenceTypeArguments.length) { + referenceTypeArgument = typeReferenceTypeArguments[i].getRootSymbol(); + + if (referenceTypeArgument.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + break; + } + + i++; + } + + if (i == typeParameters.length) { + this._generativeTypeClassification = 2 /* Closed */; + } + + if (this._generativeTypeClassification == 0 /* Unknown */) { + var i = 0; + + while ((this._generativeTypeClassification == 0 /* Unknown */) && (i < typeReferenceTypeArguments.length)) { + for (var j = 0; j < typeParameters.length; j++) { + if (typeParameters[j] == typeReferenceTypeArguments[i]) { + this._generativeTypeClassification = 1 /* Open */; + break; + } + } + + i++; + } + + if (this._generativeTypeClassification != 1 /* Open */) { + this._generativeTypeClassification = 3 /* InfinitelyExpanding */; + } + } + } + } + + return this._generativeTypeClassification; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.isArrayNamedTypeReference = function () { + if (this._isArray === undefined) { + this._isArray = this.getRootSymbol().isArrayNamedTypeReference() || (this.getRootSymbol() == this._getResolver().getArrayNamedType()); + } + return this._isArray; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getElementType = function () { + if (!this.isArrayNamedTypeReference()) { + return null; + } + + var typeArguments = this.getTypeArguments(); + + if (typeArguments != null) { + return typeArguments[0]; + } + + return null; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.getIsSpecialized()) { + return this; + } + + return this.referencedTypeSymbol; + }; + + PullInstantiatedTypeReferenceSymbol.create = function (resolver, type, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + TypeScript.Debug.assert(resolver); + + var rootType = type.getRootSymbol(); + + var reconstructedTypeArgumentList = []; + var typeArguments = type.getTypeArguments(); + var typeParameters = rootType.getTypeParameters(); + + if (type.getIsSpecialized() && typeArguments && typeArguments.length) { + for (var i = 0; i < typeArguments.length; i++) { + reconstructedTypeArgumentList[reconstructedTypeArgumentList.length] = resolver.instantiateType(typeArguments[i], typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + for (var i = 0; i < typeArguments.length; i++) { + typeParameterArgumentMap[typeArguments[i].pullSymbolID] = reconstructedTypeArgumentList[i]; + } + } else { + var tyArg = null; + + for (var typeParameterID in typeParameterArgumentMap) { + if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) { + tyArg = typeParameterArgumentMap[typeParameterID]; + + if (tyArg) { + reconstructedTypeArgumentList[reconstructedTypeArgumentList.length] = tyArg; + } + } + } + } + + if (!instantiateFunctionTypeParameters) { + var instantiation = rootType.getSpecialization(reconstructedTypeArgumentList); + + if (instantiation) { + return instantiation; + } + } + + var isReferencedType = (type.kind & 8216 /* SomeInstantiatableType */) != 0; + + if (isReferencedType) { + if (typeParameters && reconstructedTypeArgumentList) { + if (typeParameters.length == reconstructedTypeArgumentList.length) { + for (var i = 0; i < typeParameters.length; i++) { + if (!TypeScript.PullHelpers.typeSymbolsAreIdentical(typeParameters[i], reconstructedTypeArgumentList[i])) { + isReferencedType = false; + break; + } + } + + if (isReferencedType) { + typeParameterArgumentMap = []; + } + } else { + isReferencedType = false; + } + } + } + + var instantiateRoot = isReferencedType; + + if (type.isTypeReference() && type.isGeneric()) { + var initializationMap = []; + + for (var typeParameterID in typeParameterArgumentMap) { + if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) { + initializationMap[typeParameterID] = typeParameterArgumentMap[typeParameterID]; + } + } + + var oldMap = typeParameterArgumentMap; + + var outerTypeMap = type._typeParameterArgumentMap; + var innerSubstitution = null; + var outerSubstitution = null; + var canRelatePreInstantiatedTypeParametersToRootTypeParameters = true; + + for (var typeParameterID in outerTypeMap) { + if (outerTypeMap.hasOwnProperty(typeParameterID)) { + outerSubstitution = outerTypeMap[typeParameterID]; + innerSubstitution = typeParameterArgumentMap[outerSubstitution.pullSymbolID]; + + if (innerSubstitution && (!outerSubstitution.isTypeParameter() || !outerTypeMap[innerSubstitution.pullSymbolID] || !outerTypeMap[outerTypeMap[typeParameterID].pullSymbolID] || (outerTypeMap[outerTypeMap[typeParameterID].pullSymbolID] == outerSubstitution))) { + initializationMap[typeParameterID] = typeParameterArgumentMap[outerTypeMap[typeParameterID].pullSymbolID]; + + if (!outerSubstitution.isTypeParameter()) { + canRelatePreInstantiatedTypeParametersToRootTypeParameters = false; + } + } else { + canRelatePreInstantiatedTypeParametersToRootTypeParameters = false; + } + } + } + + if (canRelatePreInstantiatedTypeParametersToRootTypeParameters && typeParameters.length) { + typeParameterArgumentMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterArgumentMap[typeParameters[i].pullSymbolID] = initializationMap[typeParameters[i].pullSymbolID]; + } + + instantiateRoot = true; + } else { + typeParameterArgumentMap = initializationMap; + } + } + + instantiation = new PullInstantiatedTypeReferenceSymbol(instantiateRoot ? rootType : type, typeParameterArgumentMap); + + if (!instantiateFunctionTypeParameters) { + rootType.addSpecialization(instantiation, reconstructedTypeArgumentList); + } + + if (isReferencedType) { + instantiation.isInstanceReferenceType = true; + } + + return instantiation; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.isGeneric = function () { + return !!this.referencedTypeSymbol.getTypeParameters().length; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeParameterArgumentMap = function () { + return this._typeParameterArgumentMap; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeArguments = function () { + if (this.isInstanceReferenceType) { + return this.getTypeParameters(); + } + + if (!this._typeArgumentReferences) { + var typeParameters = this.referencedTypeSymbol.getTypeParameters(); + + if (typeParameters.length) { + var typeArgument = null; + var typeArguments = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeArgument = this._typeParameterArgumentMap[typeParameters[i].pullSymbolID]; + + if (!typeArgument) { + TypeScript.Debug.fail("type argument count mismatch"); + } + + if (typeArgument) { + typeArguments[typeArguments.length] = typeArgument; + } + } + + this._typeArgumentReferences = typeArguments; + } + } + + return this._typeArgumentReferences; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + return this.getTypeArguments(); + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getMembers = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getMembers(); + } + + if (!this._instantiatedMembers) { + var referencedMembers = this.referencedTypeSymbol.getMembers(); + var referencedMember = null; + var instantiatedMember = null; + + this._instantiatedMembers = []; + + for (var i = 0; i < referencedMembers.length; i++) { + referencedMember = referencedMembers[i]; + + this._getResolver().resolveDeclaredSymbol(referencedMember); + + if (!this._instantiatedMemberNameCache[referencedMember.name]) { + if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + instantiatedMember = referencedMember; + } else { + instantiatedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind); + instantiatedMember.setRootSymbol(referencedMember); + instantiatedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap); + instantiatedMember.isOptional = referencedMember.isOptional; + } + + this._instantiatedMemberNameCache[instantiatedMember.name] = instantiatedMember; + } else { + instantiatedMember = this._instantiatedMemberNameCache[referencedMember.name]; + } + + this._instantiatedMembers[this._instantiatedMembers.length] = instantiatedMember; + } + } + + return this._instantiatedMembers; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) { + if (typeof lookInParent === "undefined") { lookInParent = true; } + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.findMember(name, lookInParent); + } + + var memberSymbol = this._instantiatedMemberNameCache[name]; + + if (!memberSymbol) { + var referencedMemberSymbol = this.referencedTypeSymbol.findMember(name, lookInParent); + + if (referencedMemberSymbol) { + memberSymbol = new TypeScript.PullSymbol(referencedMemberSymbol.name, referencedMemberSymbol.kind); + memberSymbol.setRootSymbol(referencedMemberSymbol); + + this._getResolver().resolveDeclaredSymbol(referencedMemberSymbol); + + memberSymbol.type = this._getResolver().instantiateType(referencedMemberSymbol.type, this._typeParameterArgumentMap); + + memberSymbol.isOptional = referencedMemberSymbol.isOptional; + + this._instantiatedMemberNameCache[memberSymbol.name] = memberSymbol; + } else { + memberSymbol = null; + } + } + + return memberSymbol; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + } + + var requestedMembers = []; + var allReferencedMembers = this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + + if (!this._allInstantiatedMemberNameCache) { + this._allInstantiatedMemberNameCache = TypeScript.createIntrinsicsObject(); + + var members = this.getMembers(); + + for (var i = 0; i < members.length; i++) { + this._allInstantiatedMemberNameCache[members[i].name] = members[i]; + } + } + + var referencedMember = null; + var requestedMember = null; + + for (var i = 0; i < allReferencedMembers.length; i++) { + referencedMember = allReferencedMembers[i]; + + this._getResolver().resolveDeclaredSymbol(referencedMember); + + if (this._allInstantiatedMemberNameCache[referencedMember.name]) { + requestedMembers[requestedMembers.length] = this._allInstantiatedMemberNameCache[referencedMember.name]; + } else { + if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._allInstantiatedMemberNameCache[referencedMember.name] = referencedMember; + requestedMembers[requestedMembers.length] = referencedMember; + } else { + requestedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind); + requestedMember.setRootSymbol(referencedMember); + + requestedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap); + requestedMember.isOptional = referencedMember.isOptional; + + this._allInstantiatedMemberNameCache[requestedMember.name] = requestedMember; + requestedMembers[requestedMembers.length] = requestedMember; + } + } + } + + return requestedMembers; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getConstructorMethod = function () { + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getConstructorMethod(); + } + + if (!this._instantiatedConstructorMethod) { + var referencedConstructorMethod = this.referencedTypeSymbol.getConstructorMethod(); + this._instantiatedConstructorMethod = new TypeScript.PullSymbol(referencedConstructorMethod.name, referencedConstructorMethod.kind); + this._instantiatedConstructorMethod.type = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedConstructorMethod.type, this._typeParameterArgumentMap); + } + + return this._instantiatedConstructorMethod; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getAssociatedContainerType = function () { + if (!this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getAssociatedContainerType(); + } + + if (!this._instantiatedAssociatedContainerType) { + var referencedAssociatedContainerType = this.referencedTypeSymbol.getAssociatedContainerType(); + + if (referencedAssociatedContainerType) { + this._instantiatedAssociatedContainerType = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedAssociatedContainerType, this._typeParameterArgumentMap); + } + } + + return this._instantiatedAssociatedContainerType; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getCallSignatures(); + } + + if (this._instantiatedCallSignatures) { + return this._instantiatedCallSignatures; + } + + var referencedCallSignatures = this.referencedTypeSymbol.getCallSignatures(); + this._instantiatedCallSignatures = []; + + for (var i = 0; i < referencedCallSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedCallSignatures[i]); + + if (!referencedCallSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = referencedCallSignatures[i]; + } else { + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = this._getResolver().instantiateSignature(referencedCallSignatures[i], this._typeParameterArgumentMap); + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedCallSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getConstructSignatures(); + } + + if (this._instantiatedConstructSignatures) { + return this._instantiatedConstructSignatures; + } + + var referencedConstructSignatures = this.referencedTypeSymbol.getConstructSignatures(); + this._instantiatedConstructSignatures = []; + + for (var i = 0; i < referencedConstructSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedConstructSignatures[i]); + + if (!referencedConstructSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = referencedConstructSignatures[i]; + } else { + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = this._getResolver().instantiateSignature(referencedConstructSignatures[i], this._typeParameterArgumentMap); + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedConstructSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getIndexSignatures(); + } + + if (this._instantiatedIndexSignatures) { + return this._instantiatedIndexSignatures; + } + + var referencedIndexSignatures = this.referencedTypeSymbol.getIndexSignatures(); + this._instantiatedIndexSignatures = []; + + for (var i = 0; i < referencedIndexSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedIndexSignatures[i]); + + if (!referencedIndexSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = referencedIndexSignatures[i]; + } else { + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = this._getResolver().instantiateSignature(referencedIndexSignatures[i], this._typeParameterArgumentMap); + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedIndexSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + return this.referencedTypeSymbol.hasBase(potentialBase, visited); + }; + return PullInstantiatedTypeReferenceSymbol; + })(PullTypeReferenceSymbol); + TypeScript.PullInstantiatedTypeReferenceSymbol = PullInstantiatedTypeReferenceSymbol; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTreeToAstVisitor = (function () { + function SyntaxTreeToAstVisitor(fileName, lineMap, compilationSettings) { + this.fileName = fileName; + this.lineMap = lineMap; + this.compilationSettings = compilationSettings; + this.position = 0; + this.previousTokenTrailingComments = null; + } + SyntaxTreeToAstVisitor.visit = function (syntaxTree, fileName, compilationSettings, incrementalAST) { + var visitor = incrementalAST ? new SyntaxTreeToIncrementalAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings) : new SyntaxTreeToAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings); + return syntaxTree.sourceUnit().accept(visitor); + }; + + SyntaxTreeToAstVisitor.prototype.movePast = function (element) { + if (element !== null) { + this.position += element.fullWidth(); + } + }; + + SyntaxTreeToAstVisitor.prototype.moveTo = function (element1, element2) { + if (element2 !== null) { + this.position += TypeScript.Syntax.childOffset(element1, element2); + } + }; + + SyntaxTreeToAstVisitor.prototype.setCommentsAndSpan = function (ast, fullStart, node) { + var firstToken = node.firstToken(); + var lastToken = node.lastToken(); + + this.setSpan(ast, fullStart, node, firstToken, lastToken); + ast.setPreComments(this.convertTokenLeadingComments(firstToken, fullStart)); + ast.setPostComments(this.convertNodeTrailingComments(node, lastToken, fullStart)); + }; + + SyntaxTreeToAstVisitor.prototype.createTokenSpan = function (fullStart, element) { + if (element === null) { + return null; + } + + if (element.fullWidth() === 0) { + return new TypeScript.ASTSpan(-1, -1); + } + + var leadingTriviaWidth = element.leadingTriviaWidth(); + var trailingTriviaWidth = element.trailingTriviaWidth(); + + var start = fullStart + leadingTriviaWidth; + var end = fullStart + element.fullWidth() - trailingTriviaWidth; + + return new TypeScript.ASTSpan(start, end); + }; + + SyntaxTreeToAstVisitor.prototype.setSpan = function (span, fullStart, element, firstToken, lastToken) { + if (typeof firstToken === "undefined") { firstToken = element.firstToken(); } + if (typeof lastToken === "undefined") { lastToken = element.lastToken(); } + var leadingTriviaWidth = firstToken ? firstToken.leadingTriviaWidth() : 0; + var trailingTriviaWidth = lastToken ? lastToken.trailingTriviaWidth() : 0; + + var desiredMinChar = fullStart + leadingTriviaWidth; + var desiredLimChar = fullStart + element.fullWidth() - trailingTriviaWidth; + + this.setSpanExplicit(span, desiredMinChar, desiredLimChar); + + span._trailingTriviaWidth = trailingTriviaWidth; + }; + + SyntaxTreeToAstVisitor.prototype.setSpanExplicit = function (span, start, end) { + span._start = start; + span._end = end; + }; + + SyntaxTreeToAstVisitor.prototype.visitSyntaxList = function (node) { + var start = this.position; + var array = new Array(node.childCount()); + + for (var i = 0, n = node.childCount(); i < n; i++) { + array[i] = node.childAt(i).accept(this); + } + + var result = new TypeScript.ISyntaxList2(this.fileName, array); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSeparatedSyntaxList = function (list) { + var start = this.position; + var array = new Array(list.nonSeparatorCount()); + + for (var i = 0, n = list.childCount(); i < n; i++) { + if (i % 2 === 0) { + array[i / 2] = list.childAt(i).accept(this); + this.previousTokenTrailingComments = null; + } else { + var separatorToken = list.childAt(i); + this.previousTokenTrailingComments = this.convertTokenTrailingComments(separatorToken, this.position + separatorToken.leadingTriviaWidth() + separatorToken.width()); + this.movePast(separatorToken); + } + } + + var result = new TypeScript.ISeparatedSyntaxList2(this.fileName, array, list.separatorCount()); + this.setSpan(result, start, list); + + result.setPostComments(this.previousTokenTrailingComments); + this.previousTokenTrailingComments = null; + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.convertComment = function (trivia, commentStartPosition, hasTrailingNewLine) { + var comment = new TypeScript.Comment(trivia, hasTrailingNewLine, commentStartPosition, commentStartPosition + trivia.fullWidth()); + + return comment; + }; + + SyntaxTreeToAstVisitor.prototype.convertComments = function (triviaList, commentStartPosition) { + var result = []; + + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + if (trivia.isComment()) { + var hasTrailingNewLine = ((i + 1) < n) && triviaList.syntaxTriviaAt(i + 1).isNewLine(); + result.push(this.convertComment(trivia, commentStartPosition, hasTrailingNewLine)); + } + + commentStartPosition += trivia.fullWidth(); + } + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.mergeComments = function (comments1, comments2) { + if (comments1 === null) { + return comments2; + } + + if (comments2 === null) { + return comments1; + } + + return comments1.concat(comments2); + }; + + SyntaxTreeToAstVisitor.prototype.convertTokenLeadingComments = function (token, commentStartPosition) { + if (token === null) { + return null; + } + + var preComments = token.hasLeadingComment() ? this.convertComments(token.leadingTrivia(), commentStartPosition) : null; + + var previousTokenTrailingComments = this.previousTokenTrailingComments; + this.previousTokenTrailingComments = null; + + return this.mergeComments(previousTokenTrailingComments, preComments); + }; + + SyntaxTreeToAstVisitor.prototype.convertTokenTrailingComments = function (token, commentStartPosition) { + if (token === null || !token.hasTrailingComment() || token.hasTrailingNewLine()) { + return null; + } + + return this.convertComments(token.trailingTrivia(), commentStartPosition); + }; + + SyntaxTreeToAstVisitor.prototype.convertNodeTrailingComments = function (node, lastToken, nodeStart) { + if (lastToken === null || !lastToken.hasTrailingComment() || lastToken.hasTrailingNewLine()) { + return null; + } + + return this.convertComments(lastToken.trailingTrivia(), nodeStart + node.fullWidth() - lastToken.trailingTriviaWidth()); + }; + + SyntaxTreeToAstVisitor.prototype.visitIdentifier = function (token) { + return this.visitToken(token); + }; + + SyntaxTreeToAstVisitor.prototype.visitToken = function (token) { + var fullStart = this.position; + + var result = this.visitTokenWorker(token); + + this.movePast(token); + + var start = fullStart + token.leadingTriviaWidth(); + this.setSpanExplicit(result, start, start + token.width()); + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTokenWorker = function (token) { + switch (token.tokenKind) { + case 60 /* AnyKeyword */: + return new TypeScript.BuiltInType(60 /* AnyKeyword */, token.text(), token.valueText()); + case 61 /* BooleanKeyword */: + return new TypeScript.BuiltInType(61 /* BooleanKeyword */, token.text(), token.valueText()); + case 67 /* NumberKeyword */: + return new TypeScript.BuiltInType(67 /* NumberKeyword */, token.text(), token.valueText()); + case 69 /* StringKeyword */: + return new TypeScript.BuiltInType(69 /* StringKeyword */, token.text(), token.valueText()); + case 41 /* VoidKeyword */: + return new TypeScript.BuiltInType(41 /* VoidKeyword */, token.text(), token.valueText()); + case 35 /* ThisKeyword */: + return new TypeScript.ThisExpression(token.text(), token.valueText()); + case 50 /* SuperKeyword */: + return new TypeScript.SuperExpression(token.text(), token.valueText()); + case 37 /* TrueKeyword */: + return new TypeScript.LiteralExpression(37 /* TrueKeyword */, token.text(), token.valueText()); + case 24 /* FalseKeyword */: + return new TypeScript.LiteralExpression(24 /* FalseKeyword */, token.text(), token.valueText()); + case 32 /* NullKeyword */: + return new TypeScript.LiteralExpression(32 /* NullKeyword */, token.text(), token.valueText()); + case 14 /* StringLiteral */: + return new TypeScript.StringLiteral(token.text(), token.valueText()); + case 12 /* RegularExpressionLiteral */: + return new TypeScript.RegularExpressionLiteral(token.text(), token.valueText()); + case 13 /* NumericLiteral */: + var fullStart = this.position; + var preComments = this.convertTokenLeadingComments(token, fullStart); + + var result = new TypeScript.NumericLiteral(token.value(), token.text(), token.valueText()); + + result.setPreComments(preComments); + return result; + case 11 /* IdentifierName */: + return new TypeScript.Identifier(token.text()); + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SyntaxTreeToAstVisitor.prototype.visitSourceUnit = function (node) { + var start = this.position; + TypeScript.Debug.assert(start === 0); + + var bod = this.visitSyntaxList(node.moduleElements); + + var result = new TypeScript.SourceUnit(bod, this.fileName); + this.setSpanExplicit(result, start, start + node.fullWidth()); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExternalModuleReference = function (node) { + var start = this.position; + + this.moveTo(node, node.stringLiteral); + var stringLiteral = node.stringLiteral.accept(this); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ExternalModuleReference(stringLiteral); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModuleNameModuleReference = function (node) { + var start = this.position; + var moduleName = node.moduleName.accept(this); + + var result = new TypeScript.ModuleNameModuleReference(moduleName); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitClassDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null; + + this.movePast(node.openBraceToken); + var members = this.visitSyntaxList(node.classElements); + + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members, closeBraceToken); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModifiers = function (modifiers) { + var result = null; + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 47 /* ExportKeyword */)) { + result = result || []; + result.push(1 /* Exported */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) { + result = result || []; + result.push(8 /* Ambient */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 58 /* StaticKeyword */)) { + result = result || []; + result.push(16 /* Static */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 57 /* PublicKeyword */)) { + result = result || []; + result.push(4 /* Public */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 55 /* PrivateKeyword */)) { + result = result || []; + result.push(2 /* Private */); + } + + return result || TypeScript.sentinelEmptyArray; + }; + + SyntaxTreeToAstVisitor.prototype.visitInterfaceDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null; + + var body = this.visitObjectType(node.body); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, body); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitHeritageClause = function (node) { + var start = this.position; + + this.movePast(node.extendsOrImplementsKeyword); + var typeNames = this.visitSeparatedSyntaxList(node.typeNames); + + var result = new TypeScript.HeritageClause(node.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, typeNames); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModuleDeclaration = function (node) { + var start = this.position; + + var modifiers = this.visitModifiers(node.modifiers); + + this.moveTo(node, node.moduleKeyword); + this.movePast(node.moduleKeyword); + + var moduleName = node.name ? node.name.accept(this) : null; + var stringLiteral = node.stringLiteral ? node.stringLiteral.accept(this) : null; + + this.movePast(node.openBraceToken); + + var moduleElements = this.visitSyntaxList(node.moduleElements); + + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ModuleDeclaration(modifiers, moduleName, stringLiteral, moduleElements, closeBraceToken); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? this.visitBlock(node.block) : null; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.FunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEnumDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var identifier = this.visitIdentifier(node.identifier); + + this.movePast(node.openBraceToken); + + var enumElements = this.visitSeparatedSyntaxList(node.enumElements); + + this.movePast(node.closeBraceToken); + + var result = new TypeScript.EnumDeclaration(this.visitModifiers(node.modifiers), identifier, enumElements); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEnumElement = function (node) { + var start = this.position; + + var memberName = this.visitToken(node.propertyName); + + var value = node.equalsValueClause !== null ? this.visitEqualsValueClause(node.equalsValueClause) : null; + + var result = new TypeScript.EnumElement(memberName, value); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitImportDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + this.movePast(node.equalsToken); + var alias = node.moduleReference.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.ImportDeclaration(modifiers, name, alias); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExportAssignment = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ExportAssignment(name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclaration); + + var declaration = node.variableDeclaration.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + + var result = new TypeScript.VariableStatement(modifiers, declaration); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclarators); + var variableDecls = this.visitSeparatedSyntaxList(node.variableDeclarators); + + var result = new TypeScript.VariableDeclaration(variableDecls); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableDeclarator = function (node) { + var start = this.position; + var propertyName = this.visitToken(node.propertyName); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + var init = node.equalsValueClause ? this.visitEqualsValueClause(node.equalsValueClause) : null; + + var result = new TypeScript.VariableDeclarator(propertyName, typeExpr, init); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEqualsValueClause = function (node) { + var start = this.position; + var afterEqualsComments = this.convertTokenTrailingComments(node.equalsToken, this.position + node.equalsToken.leadingTriviaWidth() + node.equalsToken.width()); + + this.movePast(node.equalsToken); + var value = node.value.accept(this); + value.setPreComments(this.mergeComments(afterEqualsComments, value.preComments())); + + var result = new TypeScript.EqualsValueClause(value); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPrefixUnaryExpression = function (node) { + var start = this.position; + + this.movePast(node.operatorToken); + var operand = node.operand.accept(this); + + var result = new TypeScript.PrefixUnaryExpression(node.kind(), operand); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArrayLiteralExpression = function (node) { + var start = this.position; + var openStart = this.position + node.openBracketToken.leadingTriviaWidth(); + this.movePast(node.openBracketToken); + + var expressions = this.visitSeparatedSyntaxList(node.expressions); + + var closeStart = this.position + node.closeBracketToken.leadingTriviaWidth(); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ArrayLiteralExpression(expressions); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitOmittedExpression = function (node) { + var start = this.position; + + var result = new TypeScript.OmittedExpression(); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParenthesizedExpression = function (node) { + var start = this.position; + + var openParenToken = node.openParenToken; + var openParenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width()); + + this.movePast(openParenToken); + + var expr = node.expression.accept(this); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ParenthesizedExpression(openParenTrailingComments, expr); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + var start = this.position; + + var identifier = node.identifier.accept(this); + this.movePast(node.equalsGreaterThanToken); + + var block = node.block ? this.visitBlock(node.block) : null; + var expression = node.expression ? node.expression.accept(this) : null; + + var result = new TypeScript.SimpleArrowFunctionExpression(identifier, block, expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + var start = this.position; + + var callSignature = this.visitCallSignature(node.callSignature); + this.movePast(node.equalsGreaterThanToken); + + var block = node.block ? this.visitBlock(node.block) : null; + var expression = node.expression ? node.expression.accept(this) : null; + + var result = new TypeScript.ParenthesizedArrowFunctionExpression(callSignature, block, expression); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitType = function (type) { + return type ? type.accept(this) : null; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeQuery = function (node) { + var start = this.position; + this.movePast(node.typeOfKeyword); + var name = node.name.accept(this); + + var result = new TypeScript.TypeQuery(name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitQualifiedName = function (node) { + var start = this.position; + var left = this.visitType(node.left); + this.movePast(node.dotToken); + var right = this.visitIdentifier(node.right); + + var result = new TypeScript.QualifiedName(left, right); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeArgumentList = function (node) { + if (node === null) { + return null; + } + + var start = this.position; + this.movePast(node.lessThanToken); + var typeArguments = this.visitSeparatedSyntaxList(node.typeArguments); + this.movePast(node.greaterThanToken); + + var result = new TypeScript.TypeArgumentList(typeArguments); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructorType = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + this.movePast(node.equalsGreaterThanToken); + var returnType = this.visitType(node.type); + + var result = new TypeScript.ConstructorType(typeParameters, parameters, returnType); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionType = function (node) { + var start = this.position; + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + this.movePast(node.equalsGreaterThanToken); + var returnType = this.visitType(node.type); + + var result = new TypeScript.FunctionType(typeParameters, parameters, returnType); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectType = function (node) { + var start = this.position; + + this.movePast(node.openBraceToken); + var typeMembers = this.visitSeparatedSyntaxList(node.typeMembers); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ObjectType(typeMembers); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArrayType = function (node) { + var start = this.position; + + var underlying = this.visitType(node.type); + this.movePast(node.openBracketToken); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ArrayType(underlying); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitGenericType = function (node) { + var start = this.position; + + var underlying = this.visitType(node.name); + var typeArguments = this.visitTypeArgumentList(node.typeArgumentList); + + var result = new TypeScript.GenericType(underlying, typeArguments); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeAnnotation = function (node) { + if (!node) { + return null; + } + + var start = this.position; + this.movePast(node.colonToken); + var type = this.visitType(node.type); + + var result = new TypeScript.TypeAnnotation(type); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBlock = function (node) { + if (!node) { + return null; + } + + var start = this.position; + + this.movePast(node.openBraceToken); + var statements = this.visitSyntaxList(node.statements); + var closeBracePosition = this.position; + + var closeBraceLeadingComments = this.convertTokenLeadingComments(node.closeBraceToken, this.position); + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.Block(statements, closeBraceLeadingComments, closeBraceToken); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParameter = function (node) { + var start = this.position; + + var dotDotDotToken = this.createTokenSpan(this.position, node.dotDotDotToken); + + this.moveTo(node, node.identifier); + var identifier = this.visitIdentifier(node.identifier); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + var init = node.equalsValueClause ? node.equalsValueClause.accept(this) : null; + + var modifiers = this.visitModifiers(node.modifiers); + + var result = new TypeScript.Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeExpr, init); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberAccessExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + this.movePast(node.dotToken); + var name = this.visitIdentifier(node.name); + + var result = new TypeScript.MemberAccessExpression(expression, name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPostfixUnaryExpression = function (node) { + var start = this.position; + + var operand = node.operand.accept(this); + this.movePast(node.operatorToken); + + var result = new TypeScript.PostfixUnaryExpression(node.kind() === 210 /* PostIncrementExpression */ ? 210 /* PostIncrementExpression */ : 211 /* PostDecrementExpression */, operand); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitElementAccessExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + this.movePast(node.openBracketToken); + var argumentExpression = node.argumentExpression.accept(this); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ElementAccessExpression(expression, argumentExpression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitInvocationExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + var argumentList = this.visitArgumentList(node.argumentList); + + var result = new TypeScript.InvocationExpression(expression, argumentList); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArgumentList = function (node) { + if (node === null) { + return null; + } + + var start = this.position; + + var typeArguments = this.visitTypeArgumentList(node.typeArgumentList); + + this.movePast(node.openParenToken); + + var arguments = this.visitSeparatedSyntaxList(node.arguments); + + if (node.arguments.fullWidth() === 0 && node.closeParenToken.fullWidth() === 0) { + var openParenTokenEnd = start + node.openParenToken.leadingTriviaWidth() + node.openParenToken.width(); + this.setSpanExplicit(arguments, openParenTokenEnd, openParenTokenEnd + node.openParenToken.trailingTriviaWidth()); + } + + var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ArgumentList(typeArguments, arguments, closeParenToken); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBinaryExpression = function (node) { + var start = this.position; + + var left = node.left.accept(this); + this.movePast(node.operatorToken); + var right = node.right.accept(this); + + var result = new TypeScript.BinaryExpression(node.kind(), left, right); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConditionalExpression = function (node) { + var start = this.position; + + var condition = node.condition.accept(this); + this.movePast(node.questionToken); + var whenTrue = node.whenTrue.accept(this); + this.movePast(node.colonToken); + var whenFalse = node.whenFalse.accept(this); + + var result = new TypeScript.ConditionalExpression(condition, whenTrue, whenFalse); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructSignature = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var callSignature = this.visitCallSignature(node.callSignature); + + var result = new TypeScript.ConstructSignature(callSignature); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMethodSignature = function (node) { + var start = this.position; + + var name = this.visitToken(node.propertyName); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + + var callSignature = this.visitCallSignature(node.callSignature); + + var result = new TypeScript.MethodSignature(name, questionToken, callSignature); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIndexSignature = function (node) { + var start = this.position; + + this.movePast(node.openBracketToken); + + var parameter = node.parameter.accept(this); + + this.movePast(node.closeBracketToken); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.IndexSignature(parameter, returnType); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPropertySignature = function (node) { + var start = this.position; + + var name = this.visitToken(node.propertyName); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.PropertySignature(name, questionToken, typeExpr); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParameterList = function (node) { + if (!node) { + return null; + } + + var start = this.position; + + var openParenToken = node.openParenToken; + + this.previousTokenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width()); + var openParenTrailingComments = null; + if (node.parameters.childCount() === 0) { + openParenTrailingComments = this.previousTokenTrailingComments; + this.previousTokenTrailingComments = null; + } + + this.movePast(node.openParenToken); + var parameters = this.visitSeparatedSyntaxList(node.parameters); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ParameterList(openParenTrailingComments, parameters); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCallSignature = function (node) { + var start = this.position; + + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.CallSignature(typeParameters, parameters, returnType); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeParameterList = function (node) { + if (!node) { + return null; + } + + var start = this.position; + this.movePast(node.lessThanToken); + var typeParameters = this.visitSeparatedSyntaxList(node.typeParameters); + this.movePast(node.greaterThanToken); + + var result = new TypeScript.TypeParameterList(typeParameters); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeParameter = function (node) { + var start = this.position; + + var identifier = this.visitIdentifier(node.identifier); + var constraint = node.constraint ? node.constraint.accept(this) : null; + + var result = new TypeScript.TypeParameter(identifier, constraint); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstraint = function (node) { + var start = this.position; + this.movePast(node.extendsKeyword); + var type = this.visitType(node.type); + + var result = new TypeScript.Constraint(type); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIfStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var thenBod = node.statement.accept(this); + var elseBod = node.elseClause ? node.elseClause.accept(this) : null; + + var result = new TypeScript.IfStatement(condition, thenBod, elseBod); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitElseClause = function (node) { + var start = this.position; + + this.movePast(node.elseKeyword); + var statement = node.statement.accept(this); + + var result = new TypeScript.ElseClause(statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExpressionStatement = function (node) { + var start = this.position; + + var preComments = this.convertTokenLeadingComments(node.firstToken(), start); + var expression = node.expression.accept(this); + + var semicolonPosition = this.position; + + var postComments = this.convertComments(node.semicolonToken.trailingTrivia(), this.position + node.semicolonToken.leadingTriviaWidth() + node.semicolonToken.width()); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ExpressionStatement(expression); + this.setSpan(result, start, node); + + result.setPreComments(preComments); + result.setPostComments(postComments); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructorDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.parameterList); + var parameters = this.visitParameterList(node.parameterList); + + var block = node.block ? node.block.accept(this) : null; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.ConstructorDeclaration(parameters, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIndexMemberDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.indexSignature); + var indexSignature = node.indexSignature.accept(this); + + this.movePast(node.semicolonToken); + + var result = new TypeScript.IndexMemberDeclaration(indexSignature); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? this.visitBlock(node.block) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.MemberFunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitGetAccessor = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + var parameters = this.visitParameterList(node.parameterList); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var block = node.block ? node.block.accept(this) : null; + var result = new TypeScript.GetAccessor(this.visitModifiers(node.modifiers), name, parameters, returnType, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSetAccessor = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + var parameters = this.visitParameterList(node.parameterList); + var block = node.block ? node.block.accept(this) : null; + var result = new TypeScript.SetAccessor(this.visitModifiers(node.modifiers), name, parameters, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberVariableDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclarator); + var variableDeclarator = node.variableDeclarator.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.MemberVariableDeclaration(modifiers, variableDeclarator); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitThrowStatement = function (node) { + var start = this.position; + + this.movePast(node.throwKeyword); + var expression = node.expression.accept(this); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ThrowStatement(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitReturnStatement = function (node) { + var start = this.position; + + this.movePast(node.returnKeyword); + var expression = node.expression ? node.expression.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.ReturnStatement(expression); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectCreationExpression = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var expression = node.expression.accept(this); + var argumentList = this.visitArgumentList(node.argumentList); + + var result = new TypeScript.ObjectCreationExpression(expression, argumentList); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSwitchStatement = function (node) { + var start = this.position; + + this.movePast(node.switchKeyword); + this.movePast(node.openParenToken); + var expression = node.expression.accept(this); + + var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken); + this.movePast(node.closeParenToken); + this.movePast(node.openBraceToken); + var switchClauses = this.visitSyntaxList(node.switchClauses); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.SwitchStatement(expression, closeParenToken, switchClauses); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCaseSwitchClause = function (node) { + var start = this.position; + + this.movePast(node.caseKeyword); + var expression = node.expression.accept(this); + this.movePast(node.colonToken); + var statements = this.visitSyntaxList(node.statements); + + var result = new TypeScript.CaseSwitchClause(expression, statements); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDefaultSwitchClause = function (node) { + var start = this.position; + + this.movePast(node.defaultKeyword); + this.movePast(node.colonToken); + var statements = this.visitSyntaxList(node.statements); + + var result = new TypeScript.DefaultSwitchClause(statements); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBreakStatement = function (node) { + var start = this.position; + + this.movePast(node.breakKeyword); + var identifier = node.identifier ? node.identifier.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.BreakStatement(identifier); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitContinueStatement = function (node) { + var start = this.position; + + this.movePast(node.continueKeyword); + var identifier = node.identifier ? node.identifier.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.ContinueStatement(identifier); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitForStatement = function (node) { + var start = this.position; + + this.movePast(node.forKeyword); + this.movePast(node.openParenToken); + var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null; + var initializer = node.initializer ? node.initializer.accept(this) : null; + + this.movePast(node.firstSemicolonToken); + var cond = node.condition ? node.condition.accept(this) : null; + this.movePast(node.secondSemicolonToken); + var incr = node.incrementor ? node.incrementor.accept(this) : null; + this.movePast(node.closeParenToken); + var body = node.statement.accept(this); + + var result = new TypeScript.ForStatement(variableDeclaration, initializer, cond, incr, body); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitForInStatement = function (node) { + var start = this.position; + + this.movePast(node.forKeyword); + this.movePast(node.openParenToken); + var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null; + var left = node.left ? node.left.accept(this) : null; + + this.movePast(node.inKeyword); + var expression = node.expression.accept(this); + this.movePast(node.closeParenToken); + var body = node.statement.accept(this); + + var result = new TypeScript.ForInStatement(variableDeclaration, left, expression, body); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitWhileStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.WhileStatement(condition, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitWithStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.WithStatement(condition, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCastExpression = function (node) { + var start = this.position; + + this.movePast(node.lessThanToken); + var castTerm = this.visitType(node.type); + this.movePast(node.greaterThanToken); + var expression = node.expression.accept(this); + + var result = new TypeScript.CastExpression(castTerm, expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectLiteralExpression = function (node) { + var start = this.position; + + var openStart = this.position + node.openBraceToken.leadingTriviaWidth(); + this.movePast(node.openBraceToken); + + var propertyAssignments = this.visitSeparatedSyntaxList(node.propertyAssignments); + + var closeStart = this.position + node.closeBraceToken.leadingTriviaWidth(); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ObjectLiteralExpression(propertyAssignments); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSimplePropertyAssignment = function (node) { + var start = this.position; + + var preComments = this.convertTokenLeadingComments(node.firstToken(), start); + var postComments = this.convertNodeTrailingComments(node, node.lastToken(), start); + + var propertyName = node.propertyName.accept(this); + + var afterColonComments = this.convertTokenTrailingComments(node.colonToken, this.position + node.colonToken.leadingTriviaWidth() + node.colonToken.width()); + + this.movePast(node.colonToken); + var expression = node.expression.accept(this); + expression.setPreComments(this.mergeComments(afterColonComments, expression.preComments())); + + var result = new TypeScript.SimplePropertyAssignment(propertyName, expression); + this.setSpan(result, start, node); + + result.setPreComments(preComments); + result.setPostComments(postComments); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + var start = this.position; + + var propertyName = node.propertyName.accept(this); + var callSignature = this.visitCallSignature(node.callSignature); + var block = this.visitBlock(node.block); + + var result = new TypeScript.FunctionPropertyAssignment(propertyName, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionExpression = function (node) { + var start = this.position; + + this.movePast(node.functionKeyword); + var name = node.identifier === null ? null : this.visitIdentifier(node.identifier); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? node.block.accept(this) : null; + + var result = new TypeScript.FunctionExpression(name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEmptyStatement = function (node) { + var start = this.position; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.EmptyStatement(); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTryStatement = function (node) { + var start = this.position; + + this.movePast(node.tryKeyword); + var tryBody = node.block.accept(this); + + var catchClause = null; + if (node.catchClause !== null) { + catchClause = node.catchClause.accept(this); + } + + var finallyBody = null; + if (node.finallyClause !== null) { + finallyBody = node.finallyClause.accept(this); + } + + var result = new TypeScript.TryStatement(tryBody, catchClause, finallyBody); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCatchClause = function (node) { + var start = this.position; + + this.movePast(node.catchKeyword); + this.movePast(node.openParenToken); + var identifier = this.visitIdentifier(node.identifier); + var typeAnnotation = this.visitTypeAnnotation(node.typeAnnotation); + this.movePast(node.closeParenToken); + var block = node.block.accept(this); + + var result = new TypeScript.CatchClause(identifier, typeAnnotation, block); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFinallyClause = function (node) { + var start = this.position; + this.movePast(node.finallyKeyword); + var block = node.block.accept(this); + + var result = new TypeScript.FinallyClause(block); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitLabeledStatement = function (node) { + var start = this.position; + + var identifier = this.visitIdentifier(node.identifier); + this.movePast(node.colonToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.LabeledStatement(identifier, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDoStatement = function (node) { + var start = this.position; + + this.movePast(node.doKeyword); + var statement = node.statement.accept(this); + var whileKeyword = this.createTokenSpan(this.position, node.whileKeyword); + + this.movePast(node.whileKeyword); + this.movePast(node.openParenToken); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + this.movePast(node.semicolonToken); + + var result = new TypeScript.DoStatement(statement, whileKeyword, condition); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeOfExpression = function (node) { + var start = this.position; + + this.movePast(node.typeOfKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.TypeOfExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDeleteExpression = function (node) { + var start = this.position; + + this.movePast(node.deleteKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.DeleteExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVoidExpression = function (node) { + var start = this.position; + + this.movePast(node.voidKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.VoidExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDebuggerStatement = function (node) { + var start = this.position; + + this.movePast(node.debuggerKeyword); + this.movePast(node.semicolonToken); + + var result = new TypeScript.DebuggerStatement(); + this.setSpan(result, start, node); + + return result; + }; + return SyntaxTreeToAstVisitor; + })(); + TypeScript.SyntaxTreeToAstVisitor = SyntaxTreeToAstVisitor; + + function applyDelta(ast, delta) { + if (ast) { + if (ast._start !== -1) { + ast._start += delta; + } + + if (ast._end !== -1) { + ast._end += delta; + } + } + } + + function applyDeltaToComments(comments, delta) { + if (comments && comments.length > 0) { + for (var i = 0; i < comments.length; i++) { + var comment = comments[i]; + applyDelta(comment, delta); + } + } + } + + var SyntaxTreeToIncrementalAstVisitor = (function (_super) { + __extends(SyntaxTreeToIncrementalAstVisitor, _super); + function SyntaxTreeToIncrementalAstVisitor() { + _super.apply(this, arguments); + } + SyntaxTreeToIncrementalAstVisitor.prototype.applyDelta = function (ast, delta) { + if (delta === 0) { + return; + } + + var pre = function (cur) { + applyDelta(cur, delta); + applyDeltaToComments(cur.preComments(), delta); + applyDeltaToComments(cur.postComments(), delta); + + switch (cur.kind()) { + case 146 /* Block */: + applyDelta(cur.closeBraceToken, delta); + break; + + case 226 /* ArgumentList */: + applyDelta(cur.closeParenToken, delta); + break; + + case 130 /* ModuleDeclaration */: + applyDelta(cur.endingToken, delta); + break; + + case 131 /* ClassDeclaration */: + applyDelta(cur.closeBraceToken, delta); + break; + + case 161 /* DoStatement */: + applyDelta(cur.whileKeyword, delta); + break; + + case 151 /* SwitchStatement */: + applyDelta(cur.closeParenToken, delta); + break; + } + }; + + TypeScript.getAstWalkerFactory().simpleWalk(ast, pre); + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.setSpanExplicit = function (span, start, end) { + if (span._start !== -1) { + var delta = start - span._start; + this.applyDelta(span, delta); + + span._end = end; + } else { + _super.prototype.setSpanExplicit.call(this, span, start, end); + } + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.getAndMovePastAST = function (element) { + if (this.previousTokenTrailingComments !== null) { + return null; + } + + var result = element._ast; + if (!result) { + return null; + } + + var start = this.position; + this.movePast(element); + this.setSpan(result, start, element); + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.setAST = function (element, ast) { + element._ast = ast; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSyntaxList = function (list) { + var result = this.getAndMovePastAST(list); + if (!result) { + result = _super.prototype.visitSyntaxList.call(this, list); + + if (list.childCount() > 0) { + this.setAST(list, result); + } + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSeparatedSyntaxList = function (list) { + var result = this.getAndMovePastAST(list); + if (!result) { + result = _super.prototype.visitSeparatedSyntaxList.call(this, list); + + if (list.childCount() > 0) { + this.setAST(list, result); + } + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitToken = function (token) { + var result = this.getAndMovePastAST(token); + + if (!result) { + result = _super.prototype.visitToken.call(this, token); + this.setAST(token, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitClassDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitClassDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitInterfaceDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitInterfaceDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitHeritageClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitHeritageClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitModuleDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitModuleDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitImportDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitImportDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitExportAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitExportAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPrefixUnaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPrefixUnaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayLiteralExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitArrayLiteralExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitOmittedExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitOmittedExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParenthesizedExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSimpleArrowFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParenthesizedArrowFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitQualifiedName = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + var result = _super.prototype.visitQualifiedName.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructorType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitArrayType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitGenericType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitGenericType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBlock = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBlock.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParameter = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParameter.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberAccessExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberAccessExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPostfixUnaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPostfixUnaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitElementAccessExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitElementAccessExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitInvocationExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitInvocationExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBinaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBinaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConditionalExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConditionalExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMethodSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMethodSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitIndexSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitIndexSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPropertySignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPropertySignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCallSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCallSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeParameter = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTypeParameter.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitIfStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitIfStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitExpressionStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitExpressionStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructorDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberFunctionDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitGetAccessor = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitGetAccessor.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSetAccessor = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSetAccessor.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberVariableDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberVariableDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitThrowStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitThrowStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitReturnStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitReturnStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectCreationExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectCreationExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSwitchStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSwitchStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCaseSwitchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCaseSwitchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDefaultSwitchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDefaultSwitchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBreakStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBreakStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitContinueStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitContinueStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitForStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitForStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitForInStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitForInStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitWhileStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitWhileStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitWithStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitWithStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCastExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCastExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectLiteralExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectLiteralExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSimplePropertyAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSimplePropertyAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionPropertyAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitEmptyStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitEmptyStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTryStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTryStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCatchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCatchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitLabeledStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitLabeledStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDoStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDoStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeOfExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTypeOfExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDeleteExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDeleteExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitVoidExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitVoidExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDebuggerStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDebuggerStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + return SyntaxTreeToIncrementalAstVisitor; + })(SyntaxTreeToAstVisitor); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ASTSpan = (function () { + function ASTSpan(_start, _end) { + this._start = _start; + this._end = _end; + } + ASTSpan.prototype.start = function () { + return this._start; + }; + + ASTSpan.prototype.end = function () { + return this._end; + }; + return ASTSpan; + })(); + TypeScript.ASTSpan = ASTSpan; + + var astID = 0; + + function structuralEqualsNotIncludingPosition(ast1, ast2) { + return structuralEquals(ast1, ast2, false); + } + TypeScript.structuralEqualsNotIncludingPosition = structuralEqualsNotIncludingPosition; + + function structuralEqualsIncludingPosition(ast1, ast2) { + return structuralEquals(ast1, ast2, true); + } + TypeScript.structuralEqualsIncludingPosition = structuralEqualsIncludingPosition; + + function commentStructuralEqualsNotIncludingPosition(ast1, ast2) { + return commentStructuralEquals(ast1, ast2, false); + } + + function commentStructuralEqualsIncludingPosition(ast1, ast2) { + return commentStructuralEquals(ast1, ast2, true); + } + + function structuralEquals(ast1, ast2, includingPosition) { + if (ast1 === ast2) { + return true; + } + + return ast1 !== null && ast2 !== null && ast1.kind() === ast2.kind() && ast1.structuralEquals(ast2, includingPosition); + } + + function commentStructuralEquals(ast1, ast2, includingPosition) { + if (ast1 === ast2) { + return true; + } + + return ast1 !== null && ast2 !== null && ast1.structuralEquals(ast2, includingPosition); + } + + function astArrayStructuralEquals(array1, array2, includingPosition) { + return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? structuralEqualsIncludingPosition : structuralEqualsNotIncludingPosition); + } + + function commentArrayStructuralEquals(array1, array2, includingPosition) { + return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? commentStructuralEqualsIncludingPosition : commentStructuralEqualsNotIncludingPosition); + } + + var AST = (function () { + function AST() { + this.parent = null; + this._start = -1; + this._end = -1; + this._trailingTriviaWidth = 0; + this._astID = astID++; + this._preComments = null; + this._postComments = null; + } + AST.prototype.syntaxID = function () { + return this._astID; + }; + + AST.prototype.start = function () { + return this._start; + }; + + AST.prototype.end = function () { + return this._end; + }; + + AST.prototype.trailingTriviaWidth = function () { + return this._trailingTriviaWidth; + }; + + AST.prototype.fileName = function () { + return this.parent.fileName(); + }; + + AST.prototype.kind = function () { + throw TypeScript.Errors.abstract(); + }; + + AST.prototype.preComments = function () { + return this._preComments; + }; + + AST.prototype.postComments = function () { + return this._postComments; + }; + + AST.prototype.setPreComments = function (comments) { + if (comments && comments.length) { + this._preComments = comments; + } else if (this._preComments) { + this._preComments = null; + } + }; + + AST.prototype.setPostComments = function (comments) { + if (comments && comments.length) { + this._postComments = comments; + } else if (this._postComments) { + this._postComments = null; + } + }; + + AST.prototype.width = function () { + return this.end() - this.start(); + }; + + AST.prototype.structuralEquals = function (ast, includingPosition) { + if (includingPosition) { + if (this.start() !== ast.start() || this.end() !== ast.end()) { + return false; + } + } + + return commentArrayStructuralEquals(this.preComments(), ast.preComments(), includingPosition) && commentArrayStructuralEquals(this.postComments(), ast.postComments(), includingPosition); + }; + return AST; + })(); + TypeScript.AST = AST; + + var ISyntaxList2 = (function (_super) { + __extends(ISyntaxList2, _super); + function ISyntaxList2(_fileName, members) { + _super.call(this); + this._fileName = _fileName; + this.members = members; + + for (var i = 0, n = members.length; i < n; i++) { + members[i].parent = this; + } + } + ISyntaxList2.prototype.childCount = function () { + return this.members.length; + }; + + ISyntaxList2.prototype.childAt = function (index) { + return this.members[index]; + }; + + ISyntaxList2.prototype.fileName = function () { + return this._fileName; + }; + + ISyntaxList2.prototype.kind = function () { + return 1 /* List */; + }; + + ISyntaxList2.prototype.firstOrDefault = function (func) { + return TypeScript.ArrayUtilities.firstOrDefault(this.members, func); + }; + + ISyntaxList2.prototype.lastOrDefault = function (func) { + return TypeScript.ArrayUtilities.lastOrDefault(this.members, func); + }; + + ISyntaxList2.prototype.any = function (func) { + return TypeScript.ArrayUtilities.any(this.members, func); + }; + + ISyntaxList2.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition); + }; + return ISyntaxList2; + })(AST); + TypeScript.ISyntaxList2 = ISyntaxList2; + + var ISeparatedSyntaxList2 = (function (_super) { + __extends(ISeparatedSyntaxList2, _super); + function ISeparatedSyntaxList2(_fileName, members, _separatorCount) { + _super.call(this); + this._fileName = _fileName; + this.members = members; + this._separatorCount = _separatorCount; + + for (var i = 0, n = members.length; i < n; i++) { + members[i].parent = this; + } + } + ISeparatedSyntaxList2.prototype.nonSeparatorCount = function () { + return this.members.length; + }; + + ISeparatedSyntaxList2.prototype.separatorCount = function () { + return this._separatorCount; + }; + + ISeparatedSyntaxList2.prototype.nonSeparatorAt = function (index) { + return this.members[index]; + }; + + ISeparatedSyntaxList2.prototype.nonSeparatorIndexOf = function (ast) { + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + if (this.nonSeparatorAt(i) === ast) { + return i; + } + } + + return -1; + }; + + ISeparatedSyntaxList2.prototype.fileName = function () { + return this._fileName; + }; + + ISeparatedSyntaxList2.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + ISeparatedSyntaxList2.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition); + }; + return ISeparatedSyntaxList2; + })(AST); + TypeScript.ISeparatedSyntaxList2 = ISeparatedSyntaxList2; + + var SourceUnit = (function (_super) { + __extends(SourceUnit, _super); + function SourceUnit(moduleElements, _fileName) { + _super.call(this); + this.moduleElements = moduleElements; + this._fileName = _fileName; + moduleElements && (moduleElements.parent = this); + } + SourceUnit.prototype.fileName = function () { + return this._fileName; + }; + + SourceUnit.prototype.kind = function () { + return 120 /* SourceUnit */; + }; + + SourceUnit.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition); + }; + return SourceUnit; + })(AST); + TypeScript.SourceUnit = SourceUnit; + + var Identifier = (function (_super) { + __extends(Identifier, _super); + function Identifier(_text) { + _super.call(this); + this._text = _text; + this._valueText = null; + } + Identifier.prototype.text = function () { + return this._text; + }; + Identifier.prototype.valueText = function () { + if (!this._valueText) { + var text = this._text; + if (text === "__proto__") { + this._valueText = "#__proto__"; + } else { + this._valueText = TypeScript.Syntax.massageEscapes(text); + } + } + + return this._valueText; + }; + + Identifier.prototype.kind = function () { + return 11 /* IdentifierName */; + }; + + Identifier.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text; + }; + return Identifier; + })(AST); + TypeScript.Identifier = Identifier; + + var LiteralExpression = (function (_super) { + __extends(LiteralExpression, _super); + function LiteralExpression(_nodeType, _text, _valueText) { + _super.call(this); + this._nodeType = _nodeType; + this._text = _text; + this._valueText = _valueText; + } + LiteralExpression.prototype.text = function () { + return this._text; + }; + + LiteralExpression.prototype.valueText = function () { + return this._valueText; + }; + + LiteralExpression.prototype.kind = function () { + return this._nodeType; + }; + + LiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return LiteralExpression; + })(AST); + TypeScript.LiteralExpression = LiteralExpression; + + var ThisExpression = (function (_super) { + __extends(ThisExpression, _super); + function ThisExpression(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + ThisExpression.prototype.text = function () { + return this._text; + }; + + ThisExpression.prototype.valueText = function () { + return this._valueText; + }; + + ThisExpression.prototype.kind = function () { + return 35 /* ThisKeyword */; + }; + + ThisExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return ThisExpression; + })(AST); + TypeScript.ThisExpression = ThisExpression; + + var SuperExpression = (function (_super) { + __extends(SuperExpression, _super); + function SuperExpression(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + SuperExpression.prototype.text = function () { + return this._text; + }; + + SuperExpression.prototype.valueText = function () { + return this._valueText; + }; + + SuperExpression.prototype.kind = function () { + return 50 /* SuperKeyword */; + }; + + SuperExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return SuperExpression; + })(AST); + TypeScript.SuperExpression = SuperExpression; + + var NumericLiteral = (function (_super) { + __extends(NumericLiteral, _super); + function NumericLiteral(_value, _text, _valueText) { + _super.call(this); + this._value = _value; + this._text = _text; + this._valueText = _valueText; + } + NumericLiteral.prototype.text = function () { + return this._text; + }; + NumericLiteral.prototype.valueText = function () { + return this._valueText; + }; + NumericLiteral.prototype.value = function () { + return this._value; + }; + + NumericLiteral.prototype.kind = function () { + return 13 /* NumericLiteral */; + }; + + NumericLiteral.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && (this._value === ast._value || (isNaN(this._value) && isNaN(ast._value))) && this._text === ast._text; + }; + return NumericLiteral; + })(AST); + TypeScript.NumericLiteral = NumericLiteral; + + var RegularExpressionLiteral = (function (_super) { + __extends(RegularExpressionLiteral, _super); + function RegularExpressionLiteral(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + RegularExpressionLiteral.prototype.text = function () { + return this._text; + }; + + RegularExpressionLiteral.prototype.valueText = function () { + return this._valueText; + }; + + RegularExpressionLiteral.prototype.kind = function () { + return 12 /* RegularExpressionLiteral */; + }; + return RegularExpressionLiteral; + })(AST); + TypeScript.RegularExpressionLiteral = RegularExpressionLiteral; + + var StringLiteral = (function (_super) { + __extends(StringLiteral, _super); + function StringLiteral(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + this._valueText = _valueText === "__proto__" ? "#__proto__" : _valueText; + } + StringLiteral.prototype.text = function () { + return this._text; + }; + StringLiteral.prototype.valueText = function () { + return this._valueText; + }; + + StringLiteral.prototype.kind = function () { + return 14 /* StringLiteral */; + }; + + StringLiteral.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text; + }; + return StringLiteral; + })(AST); + TypeScript.StringLiteral = StringLiteral; + + var TypeAnnotation = (function (_super) { + __extends(TypeAnnotation, _super); + function TypeAnnotation(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + TypeAnnotation.prototype.kind = function () { + return 244 /* TypeAnnotation */; + }; + return TypeAnnotation; + })(AST); + TypeScript.TypeAnnotation = TypeAnnotation; + + var BuiltInType = (function (_super) { + __extends(BuiltInType, _super); + function BuiltInType(_nodeType, _text, _valueText) { + _super.call(this); + this._nodeType = _nodeType; + this._text = _text; + this._valueText = _valueText; + } + BuiltInType.prototype.text = function () { + return this._text; + }; + + BuiltInType.prototype.valueText = function () { + return this._valueText; + }; + + BuiltInType.prototype.kind = function () { + return this._nodeType; + }; + return BuiltInType; + })(AST); + TypeScript.BuiltInType = BuiltInType; + + var ExternalModuleReference = (function (_super) { + __extends(ExternalModuleReference, _super); + function ExternalModuleReference(stringLiteral) { + _super.call(this); + this.stringLiteral = stringLiteral; + stringLiteral && (stringLiteral.parent = this); + } + ExternalModuleReference.prototype.kind = function () { + return 245 /* ExternalModuleReference */; + }; + return ExternalModuleReference; + })(AST); + TypeScript.ExternalModuleReference = ExternalModuleReference; + + var ModuleNameModuleReference = (function (_super) { + __extends(ModuleNameModuleReference, _super); + function ModuleNameModuleReference(moduleName) { + _super.call(this); + this.moduleName = moduleName; + moduleName && (moduleName.parent = this); + } + ModuleNameModuleReference.prototype.kind = function () { + return 246 /* ModuleNameModuleReference */; + }; + return ModuleNameModuleReference; + })(AST); + TypeScript.ModuleNameModuleReference = ModuleNameModuleReference; + + var ImportDeclaration = (function (_super) { + __extends(ImportDeclaration, _super); + function ImportDeclaration(modifiers, identifier, moduleReference) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.moduleReference = moduleReference; + identifier && (identifier.parent = this); + moduleReference && (moduleReference.parent = this); + } + ImportDeclaration.prototype.kind = function () { + return 133 /* ImportDeclaration */; + }; + + ImportDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.moduleReference, ast.moduleReference, includingPosition); + }; + return ImportDeclaration; + })(AST); + TypeScript.ImportDeclaration = ImportDeclaration; + + var ExportAssignment = (function (_super) { + __extends(ExportAssignment, _super); + function ExportAssignment(identifier) { + _super.call(this); + this.identifier = identifier; + identifier && (identifier.parent = this); + } + ExportAssignment.prototype.kind = function () { + return 134 /* ExportAssignment */; + }; + + ExportAssignment.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition); + }; + return ExportAssignment; + })(AST); + TypeScript.ExportAssignment = ExportAssignment; + + var TypeParameterList = (function (_super) { + __extends(TypeParameterList, _super); + function TypeParameterList(typeParameters) { + _super.call(this); + this.typeParameters = typeParameters; + typeParameters && (typeParameters.parent = this); + } + TypeParameterList.prototype.kind = function () { + return 229 /* TypeParameterList */; + }; + return TypeParameterList; + })(AST); + TypeScript.TypeParameterList = TypeParameterList; + + var ClassDeclaration = (function (_super) { + __extends(ClassDeclaration, _super); + function ClassDeclaration(modifiers, identifier, typeParameterList, heritageClauses, classElements, closeBraceToken) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.classElements = classElements; + this.closeBraceToken = closeBraceToken; + identifier && (identifier.parent = this); + typeParameterList && (typeParameterList.parent = this); + heritageClauses && (heritageClauses.parent = this); + classElements && (classElements.parent = this); + } + ClassDeclaration.prototype.kind = function () { + return 131 /* ClassDeclaration */; + }; + + ClassDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.classElements, ast.classElements, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition); + }; + return ClassDeclaration; + })(AST); + TypeScript.ClassDeclaration = ClassDeclaration; + + var InterfaceDeclaration = (function (_super) { + __extends(InterfaceDeclaration, _super); + function InterfaceDeclaration(modifiers, identifier, typeParameterList, heritageClauses, body) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.body = body; + identifier && (identifier.parent = this); + typeParameterList && (typeParameterList.parent = this); + body && (body.parent = this); + heritageClauses && (heritageClauses.parent = this); + } + InterfaceDeclaration.prototype.kind = function () { + return 128 /* InterfaceDeclaration */; + }; + + InterfaceDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.body, ast.body, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition); + }; + return InterfaceDeclaration; + })(AST); + TypeScript.InterfaceDeclaration = InterfaceDeclaration; + + var HeritageClause = (function (_super) { + __extends(HeritageClause, _super); + function HeritageClause(_nodeType, typeNames) { + _super.call(this); + this._nodeType = _nodeType; + this.typeNames = typeNames; + typeNames && (typeNames.parent = this); + } + HeritageClause.prototype.kind = function () { + return this._nodeType; + }; + + HeritageClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeNames, ast.typeNames, includingPosition); + }; + return HeritageClause; + })(AST); + TypeScript.HeritageClause = HeritageClause; + + var ModuleDeclaration = (function (_super) { + __extends(ModuleDeclaration, _super); + function ModuleDeclaration(modifiers, name, stringLiteral, moduleElements, endingToken) { + _super.call(this); + this.modifiers = modifiers; + this.name = name; + this.stringLiteral = stringLiteral; + this.moduleElements = moduleElements; + this.endingToken = endingToken; + name && (name.parent = this); + stringLiteral && (stringLiteral.parent = this); + moduleElements && (moduleElements.parent = this); + } + ModuleDeclaration.prototype.kind = function () { + return 130 /* ModuleDeclaration */; + }; + + ModuleDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition); + }; + return ModuleDeclaration; + })(AST); + TypeScript.ModuleDeclaration = ModuleDeclaration; + + var FunctionDeclaration = (function (_super) { + __extends(FunctionDeclaration, _super); + function FunctionDeclaration(modifiers, identifier, callSignature, block) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + identifier && (identifier.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionDeclaration.prototype.kind = function () { + return 129 /* FunctionDeclaration */; + }; + + FunctionDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.callSignature, ast.callSignature, includingPosition); + }; + return FunctionDeclaration; + })(AST); + TypeScript.FunctionDeclaration = FunctionDeclaration; + + var VariableStatement = (function (_super) { + __extends(VariableStatement, _super); + function VariableStatement(modifiers, declaration) { + _super.call(this); + this.modifiers = modifiers; + this.declaration = declaration; + declaration && (declaration.parent = this); + } + VariableStatement.prototype.kind = function () { + return 148 /* VariableStatement */; + }; + + VariableStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declaration, ast.declaration, includingPosition); + }; + return VariableStatement; + })(AST); + TypeScript.VariableStatement = VariableStatement; + + var VariableDeclaration = (function (_super) { + __extends(VariableDeclaration, _super); + function VariableDeclaration(declarators) { + _super.call(this); + this.declarators = declarators; + declarators && (declarators.parent = this); + } + VariableDeclaration.prototype.kind = function () { + return 224 /* VariableDeclaration */; + }; + + VariableDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declarators, ast.declarators, includingPosition); + }; + return VariableDeclaration; + })(AST); + TypeScript.VariableDeclaration = VariableDeclaration; + + var VariableDeclarator = (function (_super) { + __extends(VariableDeclarator, _super); + function VariableDeclarator(propertyName, typeAnnotation, equalsValueClause) { + _super.call(this); + this.propertyName = propertyName; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + propertyName && (propertyName.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + VariableDeclarator.prototype.kind = function () { + return 225 /* VariableDeclarator */; + }; + return VariableDeclarator; + })(AST); + TypeScript.VariableDeclarator = VariableDeclarator; + + var EqualsValueClause = (function (_super) { + __extends(EqualsValueClause, _super); + function EqualsValueClause(value) { + _super.call(this); + this.value = value; + value && (value.parent = this); + } + EqualsValueClause.prototype.kind = function () { + return 232 /* EqualsValueClause */; + }; + return EqualsValueClause; + })(AST); + TypeScript.EqualsValueClause = EqualsValueClause; + + var PrefixUnaryExpression = (function (_super) { + __extends(PrefixUnaryExpression, _super); + function PrefixUnaryExpression(_nodeType, operand) { + _super.call(this); + this._nodeType = _nodeType; + this.operand = operand; + operand && (operand.parent = this); + } + PrefixUnaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + PrefixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition); + }; + return PrefixUnaryExpression; + })(AST); + TypeScript.PrefixUnaryExpression = PrefixUnaryExpression; + + var ArrayLiteralExpression = (function (_super) { + __extends(ArrayLiteralExpression, _super); + function ArrayLiteralExpression(expressions) { + _super.call(this); + this.expressions = expressions; + expressions && (expressions.parent = this); + } + ArrayLiteralExpression.prototype.kind = function () { + return 214 /* ArrayLiteralExpression */; + }; + + ArrayLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expressions, ast.expressions, includingPosition); + }; + return ArrayLiteralExpression; + })(AST); + TypeScript.ArrayLiteralExpression = ArrayLiteralExpression; + + var OmittedExpression = (function (_super) { + __extends(OmittedExpression, _super); + function OmittedExpression() { + _super.apply(this, arguments); + } + OmittedExpression.prototype.kind = function () { + return 223 /* OmittedExpression */; + }; + + OmittedExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return OmittedExpression; + })(AST); + TypeScript.OmittedExpression = OmittedExpression; + + var ParenthesizedExpression = (function (_super) { + __extends(ParenthesizedExpression, _super); + function ParenthesizedExpression(openParenTrailingComments, expression) { + _super.call(this); + this.openParenTrailingComments = openParenTrailingComments; + this.expression = expression; + expression && (expression.parent = this); + } + ParenthesizedExpression.prototype.kind = function () { + return 217 /* ParenthesizedExpression */; + }; + + ParenthesizedExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ParenthesizedExpression; + })(AST); + TypeScript.ParenthesizedExpression = ParenthesizedExpression; + + var SimpleArrowFunctionExpression = (function (_super) { + __extends(SimpleArrowFunctionExpression, _super); + function SimpleArrowFunctionExpression(identifier, block, expression) { + _super.call(this); + this.identifier = identifier; + this.block = block; + this.expression = expression; + identifier && (identifier.parent = this); + block && (block.parent = this); + expression && (expression.parent = this); + } + SimpleArrowFunctionExpression.prototype.kind = function () { + return 219 /* SimpleArrowFunctionExpression */; + }; + return SimpleArrowFunctionExpression; + })(AST); + TypeScript.SimpleArrowFunctionExpression = SimpleArrowFunctionExpression; + + var ParenthesizedArrowFunctionExpression = (function (_super) { + __extends(ParenthesizedArrowFunctionExpression, _super); + function ParenthesizedArrowFunctionExpression(callSignature, block, expression) { + _super.call(this); + this.callSignature = callSignature; + this.block = block; + this.expression = expression; + callSignature && (callSignature.parent = this); + block && (block.parent = this); + expression && (expression.parent = this); + } + ParenthesizedArrowFunctionExpression.prototype.kind = function () { + return 218 /* ParenthesizedArrowFunctionExpression */; + }; + return ParenthesizedArrowFunctionExpression; + })(AST); + TypeScript.ParenthesizedArrowFunctionExpression = ParenthesizedArrowFunctionExpression; + + var QualifiedName = (function (_super) { + __extends(QualifiedName, _super); + function QualifiedName(left, right) { + _super.call(this); + this.left = left; + this.right = right; + left && (left.parent = this); + right && (right.parent = this); + } + QualifiedName.prototype.kind = function () { + return 121 /* QualifiedName */; + }; + + QualifiedName.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition); + }; + return QualifiedName; + })(AST); + TypeScript.QualifiedName = QualifiedName; + + var ParameterList = (function (_super) { + __extends(ParameterList, _super); + function ParameterList(openParenTrailingComments, parameters) { + _super.call(this); + this.openParenTrailingComments = openParenTrailingComments; + this.parameters = parameters; + parameters && (parameters.parent = this); + } + ParameterList.prototype.kind = function () { + return 227 /* ParameterList */; + }; + return ParameterList; + })(AST); + TypeScript.ParameterList = ParameterList; + + var ConstructorType = (function (_super) { + __extends(ConstructorType, _super); + function ConstructorType(typeParameterList, parameterList, type) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.type = type; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + type && (type.parent = this); + } + ConstructorType.prototype.kind = function () { + return 125 /* ConstructorType */; + }; + return ConstructorType; + })(AST); + TypeScript.ConstructorType = ConstructorType; + + var FunctionType = (function (_super) { + __extends(FunctionType, _super); + function FunctionType(typeParameterList, parameterList, type) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.type = type; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + type && (type.parent = this); + } + FunctionType.prototype.kind = function () { + return 123 /* FunctionType */; + }; + return FunctionType; + })(AST); + TypeScript.FunctionType = FunctionType; + + var ObjectType = (function (_super) { + __extends(ObjectType, _super); + function ObjectType(typeMembers) { + _super.call(this); + this.typeMembers = typeMembers; + typeMembers && (typeMembers.parent = this); + } + ObjectType.prototype.kind = function () { + return 122 /* ObjectType */; + }; + + ObjectType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeMembers, ast.typeMembers, includingPosition); + }; + return ObjectType; + })(AST); + TypeScript.ObjectType = ObjectType; + + var ArrayType = (function (_super) { + __extends(ArrayType, _super); + function ArrayType(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + ArrayType.prototype.kind = function () { + return 124 /* ArrayType */; + }; + + ArrayType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition); + }; + return ArrayType; + })(AST); + TypeScript.ArrayType = ArrayType; + + var TypeArgumentList = (function (_super) { + __extends(TypeArgumentList, _super); + function TypeArgumentList(typeArguments) { + _super.call(this); + this.typeArguments = typeArguments; + typeArguments && (typeArguments.parent = this); + } + TypeArgumentList.prototype.kind = function () { + return 228 /* TypeArgumentList */; + }; + return TypeArgumentList; + })(AST); + TypeScript.TypeArgumentList = TypeArgumentList; + + var GenericType = (function (_super) { + __extends(GenericType, _super); + function GenericType(name, typeArgumentList) { + _super.call(this); + this.name = name; + this.typeArgumentList = typeArgumentList; + name && (name.parent = this); + typeArgumentList && (typeArgumentList.parent = this); + } + GenericType.prototype.kind = function () { + return 126 /* GenericType */; + }; + + GenericType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.typeArgumentList, ast.typeArgumentList, includingPosition); + }; + return GenericType; + })(AST); + TypeScript.GenericType = GenericType; + + var TypeQuery = (function (_super) { + __extends(TypeQuery, _super); + function TypeQuery(name) { + _super.call(this); + this.name = name; + name && (name.parent = this); + } + TypeQuery.prototype.kind = function () { + return 127 /* TypeQuery */; + }; + + TypeQuery.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition); + }; + return TypeQuery; + })(AST); + TypeScript.TypeQuery = TypeQuery; + + var Block = (function (_super) { + __extends(Block, _super); + function Block(statements, closeBraceLeadingComments, closeBraceToken) { + _super.call(this); + this.statements = statements; + this.closeBraceLeadingComments = closeBraceLeadingComments; + this.closeBraceToken = closeBraceToken; + statements && (statements.parent = this); + } + Block.prototype.kind = function () { + return 146 /* Block */; + }; + + Block.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return Block; + })(AST); + TypeScript.Block = Block; + + var Parameter = (function (_super) { + __extends(Parameter, _super); + function Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + _super.call(this); + this.dotDotDotToken = dotDotDotToken; + this.modifiers = modifiers; + this.identifier = identifier; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + identifier && (identifier.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + Parameter.prototype.kind = function () { + return 242 /* Parameter */; + }; + return Parameter; + })(AST); + TypeScript.Parameter = Parameter; + + var MemberAccessExpression = (function (_super) { + __extends(MemberAccessExpression, _super); + function MemberAccessExpression(expression, name) { + _super.call(this); + this.expression = expression; + this.name = name; + expression && (expression.parent = this); + name && (name.parent = this); + } + MemberAccessExpression.prototype.kind = function () { + return 212 /* MemberAccessExpression */; + }; + + MemberAccessExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.name, ast.name, includingPosition); + }; + return MemberAccessExpression; + })(AST); + TypeScript.MemberAccessExpression = MemberAccessExpression; + + var PostfixUnaryExpression = (function (_super) { + __extends(PostfixUnaryExpression, _super); + function PostfixUnaryExpression(_nodeType, operand) { + _super.call(this); + this._nodeType = _nodeType; + this.operand = operand; + operand && (operand.parent = this); + } + PostfixUnaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + PostfixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition); + }; + return PostfixUnaryExpression; + })(AST); + TypeScript.PostfixUnaryExpression = PostfixUnaryExpression; + + var ElementAccessExpression = (function (_super) { + __extends(ElementAccessExpression, _super); + function ElementAccessExpression(expression, argumentExpression) { + _super.call(this); + this.expression = expression; + this.argumentExpression = argumentExpression; + expression && (expression.parent = this); + argumentExpression && (argumentExpression.parent = this); + } + ElementAccessExpression.prototype.kind = function () { + return 221 /* ElementAccessExpression */; + }; + + ElementAccessExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentExpression, ast.argumentExpression, includingPosition); + }; + return ElementAccessExpression; + })(AST); + TypeScript.ElementAccessExpression = ElementAccessExpression; + + var InvocationExpression = (function (_super) { + __extends(InvocationExpression, _super); + function InvocationExpression(expression, argumentList) { + _super.call(this); + this.expression = expression; + this.argumentList = argumentList; + expression && (expression.parent = this); + argumentList && (argumentList.parent = this); + } + InvocationExpression.prototype.kind = function () { + return 213 /* InvocationExpression */; + }; + + InvocationExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition); + }; + return InvocationExpression; + })(AST); + TypeScript.InvocationExpression = InvocationExpression; + + var ArgumentList = (function (_super) { + __extends(ArgumentList, _super); + function ArgumentList(typeArgumentList, arguments, closeParenToken) { + _super.call(this); + this.typeArgumentList = typeArgumentList; + this.arguments = arguments; + this.closeParenToken = closeParenToken; + typeArgumentList && (typeArgumentList.parent = this); + arguments && (arguments.parent = this); + } + ArgumentList.prototype.kind = function () { + return 226 /* ArgumentList */; + }; + return ArgumentList; + })(AST); + TypeScript.ArgumentList = ArgumentList; + + var BinaryExpression = (function (_super) { + __extends(BinaryExpression, _super); + function BinaryExpression(_nodeType, left, right) { + _super.call(this); + this._nodeType = _nodeType; + this.left = left; + this.right = right; + left && (left.parent = this); + right && (right.parent = this); + } + BinaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + BinaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition); + }; + return BinaryExpression; + })(AST); + TypeScript.BinaryExpression = BinaryExpression; + + var ConditionalExpression = (function (_super) { + __extends(ConditionalExpression, _super); + function ConditionalExpression(condition, whenTrue, whenFalse) { + _super.call(this); + this.condition = condition; + this.whenTrue = whenTrue; + this.whenFalse = whenFalse; + condition && (condition.parent = this); + whenTrue && (whenTrue.parent = this); + whenFalse && (whenFalse.parent = this); + } + ConditionalExpression.prototype.kind = function () { + return 186 /* ConditionalExpression */; + }; + + ConditionalExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.whenTrue, ast.whenTrue, includingPosition) && structuralEquals(this.whenFalse, ast.whenFalse, includingPosition); + }; + return ConditionalExpression; + })(AST); + TypeScript.ConditionalExpression = ConditionalExpression; + + var ConstructSignature = (function (_super) { + __extends(ConstructSignature, _super); + function ConstructSignature(callSignature) { + _super.call(this); + this.callSignature = callSignature; + callSignature && (callSignature.parent = this); + } + ConstructSignature.prototype.kind = function () { + return 143 /* ConstructSignature */; + }; + return ConstructSignature; + })(AST); + TypeScript.ConstructSignature = ConstructSignature; + + var MethodSignature = (function (_super) { + __extends(MethodSignature, _super); + function MethodSignature(propertyName, questionToken, callSignature) { + _super.call(this); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.callSignature = callSignature; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + } + MethodSignature.prototype.kind = function () { + return 145 /* MethodSignature */; + }; + return MethodSignature; + })(AST); + TypeScript.MethodSignature = MethodSignature; + + var IndexSignature = (function (_super) { + __extends(IndexSignature, _super); + function IndexSignature(parameter, typeAnnotation) { + _super.call(this); + this.parameter = parameter; + this.typeAnnotation = typeAnnotation; + parameter && (parameter.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + IndexSignature.prototype.kind = function () { + return 144 /* IndexSignature */; + }; + return IndexSignature; + })(AST); + TypeScript.IndexSignature = IndexSignature; + + var PropertySignature = (function (_super) { + __extends(PropertySignature, _super); + function PropertySignature(propertyName, questionToken, typeAnnotation) { + _super.call(this); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + propertyName && (propertyName.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + PropertySignature.prototype.kind = function () { + return 141 /* PropertySignature */; + }; + return PropertySignature; + })(AST); + TypeScript.PropertySignature = PropertySignature; + + var CallSignature = (function (_super) { + __extends(CallSignature, _super); + function CallSignature(typeParameterList, parameterList, typeAnnotation) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + CallSignature.prototype.kind = function () { + return 142 /* CallSignature */; + }; + return CallSignature; + })(AST); + TypeScript.CallSignature = CallSignature; + + var TypeParameter = (function (_super) { + __extends(TypeParameter, _super); + function TypeParameter(identifier, constraint) { + _super.call(this); + this.identifier = identifier; + this.constraint = constraint; + identifier && (identifier.parent = this); + constraint && (constraint.parent = this); + } + TypeParameter.prototype.kind = function () { + return 238 /* TypeParameter */; + }; + + TypeParameter.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.constraint, ast.constraint, includingPosition); + }; + return TypeParameter; + })(AST); + TypeScript.TypeParameter = TypeParameter; + + var Constraint = (function (_super) { + __extends(Constraint, _super); + function Constraint(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + Constraint.prototype.kind = function () { + return 239 /* Constraint */; + }; + return Constraint; + })(AST); + TypeScript.Constraint = Constraint; + + var ElseClause = (function (_super) { + __extends(ElseClause, _super); + function ElseClause(statement) { + _super.call(this); + this.statement = statement; + statement && (statement.parent = this); + } + ElseClause.prototype.kind = function () { + return 235 /* ElseClause */; + }; + + ElseClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ElseClause; + })(AST); + TypeScript.ElseClause = ElseClause; + + var IfStatement = (function (_super) { + __extends(IfStatement, _super); + function IfStatement(condition, statement, elseClause) { + _super.call(this); + this.condition = condition; + this.statement = statement; + this.elseClause = elseClause; + condition && (condition.parent = this); + statement && (statement.parent = this); + elseClause && (elseClause.parent = this); + } + IfStatement.prototype.kind = function () { + return 147 /* IfStatement */; + }; + + IfStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.elseClause, ast.elseClause, includingPosition); + }; + return IfStatement; + })(AST); + TypeScript.IfStatement = IfStatement; + + var ExpressionStatement = (function (_super) { + __extends(ExpressionStatement, _super); + function ExpressionStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ExpressionStatement.prototype.kind = function () { + return 149 /* ExpressionStatement */; + }; + + ExpressionStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ExpressionStatement; + })(AST); + TypeScript.ExpressionStatement = ExpressionStatement; + + var ConstructorDeclaration = (function (_super) { + __extends(ConstructorDeclaration, _super); + function ConstructorDeclaration(parameterList, block) { + _super.call(this); + this.parameterList = parameterList; + this.block = block; + parameterList && (parameterList.parent = this); + block && (block.parent = this); + } + ConstructorDeclaration.prototype.kind = function () { + return 137 /* ConstructorDeclaration */; + }; + return ConstructorDeclaration; + })(AST); + TypeScript.ConstructorDeclaration = ConstructorDeclaration; + + var MemberFunctionDeclaration = (function (_super) { + __extends(MemberFunctionDeclaration, _super); + function MemberFunctionDeclaration(modifiers, propertyName, callSignature, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + MemberFunctionDeclaration.prototype.kind = function () { + return 135 /* MemberFunctionDeclaration */; + }; + return MemberFunctionDeclaration; + })(AST); + TypeScript.MemberFunctionDeclaration = MemberFunctionDeclaration; + + var GetAccessor = (function (_super) { + __extends(GetAccessor, _super); + function GetAccessor(modifiers, propertyName, parameterList, typeAnnotation, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + this.block = block; + propertyName && (propertyName.parent = this); + parameterList && (parameterList.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + block && (block.parent = this); + } + GetAccessor.prototype.kind = function () { + return 139 /* GetAccessor */; + }; + return GetAccessor; + })(AST); + TypeScript.GetAccessor = GetAccessor; + + var SetAccessor = (function (_super) { + __extends(SetAccessor, _super); + function SetAccessor(modifiers, propertyName, parameterList, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.block = block; + propertyName && (propertyName.parent = this); + parameterList && (parameterList.parent = this); + block && (block.parent = this); + } + SetAccessor.prototype.kind = function () { + return 140 /* SetAccessor */; + }; + return SetAccessor; + })(AST); + TypeScript.SetAccessor = SetAccessor; + + var MemberVariableDeclaration = (function (_super) { + __extends(MemberVariableDeclaration, _super); + function MemberVariableDeclaration(modifiers, variableDeclarator) { + _super.call(this); + this.modifiers = modifiers; + this.variableDeclarator = variableDeclarator; + variableDeclarator && (variableDeclarator.parent = this); + } + MemberVariableDeclaration.prototype.kind = function () { + return 136 /* MemberVariableDeclaration */; + }; + return MemberVariableDeclaration; + })(AST); + TypeScript.MemberVariableDeclaration = MemberVariableDeclaration; + + var IndexMemberDeclaration = (function (_super) { + __extends(IndexMemberDeclaration, _super); + function IndexMemberDeclaration(indexSignature) { + _super.call(this); + this.indexSignature = indexSignature; + indexSignature && (indexSignature.parent = this); + } + IndexMemberDeclaration.prototype.kind = function () { + return 138 /* IndexMemberDeclaration */; + }; + return IndexMemberDeclaration; + })(AST); + TypeScript.IndexMemberDeclaration = IndexMemberDeclaration; + + var ThrowStatement = (function (_super) { + __extends(ThrowStatement, _super); + function ThrowStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ThrowStatement.prototype.kind = function () { + return 157 /* ThrowStatement */; + }; + + ThrowStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ThrowStatement; + })(AST); + TypeScript.ThrowStatement = ThrowStatement; + + var ReturnStatement = (function (_super) { + __extends(ReturnStatement, _super); + function ReturnStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ReturnStatement.prototype.kind = function () { + return 150 /* ReturnStatement */; + }; + + ReturnStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ReturnStatement; + })(AST); + TypeScript.ReturnStatement = ReturnStatement; + + var ObjectCreationExpression = (function (_super) { + __extends(ObjectCreationExpression, _super); + function ObjectCreationExpression(expression, argumentList) { + _super.call(this); + this.expression = expression; + this.argumentList = argumentList; + expression && (expression.parent = this); + argumentList && (argumentList.parent = this); + } + ObjectCreationExpression.prototype.kind = function () { + return 216 /* ObjectCreationExpression */; + }; + + ObjectCreationExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition); + }; + return ObjectCreationExpression; + })(AST); + TypeScript.ObjectCreationExpression = ObjectCreationExpression; + + var SwitchStatement = (function (_super) { + __extends(SwitchStatement, _super); + function SwitchStatement(expression, closeParenToken, switchClauses) { + _super.call(this); + this.expression = expression; + this.closeParenToken = closeParenToken; + this.switchClauses = switchClauses; + expression && (expression.parent = this); + switchClauses && (switchClauses.parent = this); + } + SwitchStatement.prototype.kind = function () { + return 151 /* SwitchStatement */; + }; + + SwitchStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.switchClauses, ast.switchClauses, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return SwitchStatement; + })(AST); + TypeScript.SwitchStatement = SwitchStatement; + + var CaseSwitchClause = (function (_super) { + __extends(CaseSwitchClause, _super); + function CaseSwitchClause(expression, statements) { + _super.call(this); + this.expression = expression; + this.statements = statements; + expression && (expression.parent = this); + statements && (statements.parent = this); + } + CaseSwitchClause.prototype.kind = function () { + return 233 /* CaseSwitchClause */; + }; + + CaseSwitchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return CaseSwitchClause; + })(AST); + TypeScript.CaseSwitchClause = CaseSwitchClause; + + var DefaultSwitchClause = (function (_super) { + __extends(DefaultSwitchClause, _super); + function DefaultSwitchClause(statements) { + _super.call(this); + this.statements = statements; + statements && (statements.parent = this); + } + DefaultSwitchClause.prototype.kind = function () { + return 234 /* DefaultSwitchClause */; + }; + + DefaultSwitchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return DefaultSwitchClause; + })(AST); + TypeScript.DefaultSwitchClause = DefaultSwitchClause; + + var BreakStatement = (function (_super) { + __extends(BreakStatement, _super); + function BreakStatement(identifier) { + _super.call(this); + this.identifier = identifier; + } + BreakStatement.prototype.kind = function () { + return 152 /* BreakStatement */; + }; + + BreakStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return BreakStatement; + })(AST); + TypeScript.BreakStatement = BreakStatement; + + var ContinueStatement = (function (_super) { + __extends(ContinueStatement, _super); + function ContinueStatement(identifier) { + _super.call(this); + this.identifier = identifier; + } + ContinueStatement.prototype.kind = function () { + return 153 /* ContinueStatement */; + }; + + ContinueStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return ContinueStatement; + })(AST); + TypeScript.ContinueStatement = ContinueStatement; + + var ForStatement = (function (_super) { + __extends(ForStatement, _super); + function ForStatement(variableDeclaration, initializer, condition, incrementor, statement) { + _super.call(this); + this.variableDeclaration = variableDeclaration; + this.initializer = initializer; + this.condition = condition; + this.incrementor = incrementor; + this.statement = statement; + variableDeclaration && (variableDeclaration.parent = this); + initializer && (initializer.parent = this); + condition && (condition.parent = this); + incrementor && (incrementor.parent = this); + statement && (statement.parent = this); + } + ForStatement.prototype.kind = function () { + return 154 /* ForStatement */; + }; + + ForStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.initializer, ast.initializer, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.incrementor, ast.incrementor, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ForStatement; + })(AST); + TypeScript.ForStatement = ForStatement; + + var ForInStatement = (function (_super) { + __extends(ForInStatement, _super); + function ForInStatement(variableDeclaration, left, expression, statement) { + _super.call(this); + this.variableDeclaration = variableDeclaration; + this.left = left; + this.expression = expression; + this.statement = statement; + variableDeclaration && (variableDeclaration.parent = this); + left && (left.parent = this); + expression && (expression.parent = this); + statement && (statement.parent = this); + } + ForInStatement.prototype.kind = function () { + return 155 /* ForInStatement */; + }; + + ForInStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.variableDeclaration, ast.variableDeclaration, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ForInStatement; + })(AST); + TypeScript.ForInStatement = ForInStatement; + + var WhileStatement = (function (_super) { + __extends(WhileStatement, _super); + function WhileStatement(condition, statement) { + _super.call(this); + this.condition = condition; + this.statement = statement; + condition && (condition.parent = this); + statement && (statement.parent = this); + } + WhileStatement.prototype.kind = function () { + return 158 /* WhileStatement */; + }; + + WhileStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return WhileStatement; + })(AST); + TypeScript.WhileStatement = WhileStatement; + + var WithStatement = (function (_super) { + __extends(WithStatement, _super); + function WithStatement(condition, statement) { + _super.call(this); + this.condition = condition; + this.statement = statement; + condition && (condition.parent = this); + statement && (statement.parent = this); + } + WithStatement.prototype.kind = function () { + return 163 /* WithStatement */; + }; + + WithStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return WithStatement; + })(AST); + TypeScript.WithStatement = WithStatement; + + var EnumDeclaration = (function (_super) { + __extends(EnumDeclaration, _super); + function EnumDeclaration(modifiers, identifier, enumElements) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.enumElements = enumElements; + identifier && (identifier.parent = this); + enumElements && (enumElements.parent = this); + } + EnumDeclaration.prototype.kind = function () { + return 132 /* EnumDeclaration */; + }; + return EnumDeclaration; + })(AST); + TypeScript.EnumDeclaration = EnumDeclaration; + + var EnumElement = (function (_super) { + __extends(EnumElement, _super); + function EnumElement(propertyName, equalsValueClause) { + _super.call(this); + this.propertyName = propertyName; + this.equalsValueClause = equalsValueClause; + propertyName && (propertyName.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + EnumElement.prototype.kind = function () { + return 243 /* EnumElement */; + }; + return EnumElement; + })(AST); + TypeScript.EnumElement = EnumElement; + + var CastExpression = (function (_super) { + __extends(CastExpression, _super); + function CastExpression(type, expression) { + _super.call(this); + this.type = type; + this.expression = expression; + type && (type.parent = this); + expression && (expression.parent = this); + } + CastExpression.prototype.kind = function () { + return 220 /* CastExpression */; + }; + + CastExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return CastExpression; + })(AST); + TypeScript.CastExpression = CastExpression; + + var ObjectLiteralExpression = (function (_super) { + __extends(ObjectLiteralExpression, _super); + function ObjectLiteralExpression(propertyAssignments) { + _super.call(this); + this.propertyAssignments = propertyAssignments; + propertyAssignments && (propertyAssignments.parent = this); + } + ObjectLiteralExpression.prototype.kind = function () { + return 215 /* ObjectLiteralExpression */; + }; + + ObjectLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.propertyAssignments, ast.propertyAssignments, includingPosition); + }; + return ObjectLiteralExpression; + })(AST); + TypeScript.ObjectLiteralExpression = ObjectLiteralExpression; + + var SimplePropertyAssignment = (function (_super) { + __extends(SimplePropertyAssignment, _super); + function SimplePropertyAssignment(propertyName, expression) { + _super.call(this); + this.propertyName = propertyName; + this.expression = expression; + propertyName && (propertyName.parent = this); + expression && (expression.parent = this); + } + SimplePropertyAssignment.prototype.kind = function () { + return 240 /* SimplePropertyAssignment */; + }; + return SimplePropertyAssignment; + })(AST); + TypeScript.SimplePropertyAssignment = SimplePropertyAssignment; + + var FunctionPropertyAssignment = (function (_super) { + __extends(FunctionPropertyAssignment, _super); + function FunctionPropertyAssignment(propertyName, callSignature, block) { + _super.call(this); + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionPropertyAssignment.prototype.kind = function () { + return 241 /* FunctionPropertyAssignment */; + }; + return FunctionPropertyAssignment; + })(AST); + TypeScript.FunctionPropertyAssignment = FunctionPropertyAssignment; + + var FunctionExpression = (function (_super) { + __extends(FunctionExpression, _super); + function FunctionExpression(identifier, callSignature, block) { + _super.call(this); + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + identifier && (identifier.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionExpression.prototype.kind = function () { + return 222 /* FunctionExpression */; + }; + return FunctionExpression; + })(AST); + TypeScript.FunctionExpression = FunctionExpression; + + var EmptyStatement = (function (_super) { + __extends(EmptyStatement, _super); + function EmptyStatement() { + _super.apply(this, arguments); + } + EmptyStatement.prototype.kind = function () { + return 156 /* EmptyStatement */; + }; + + EmptyStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return EmptyStatement; + })(AST); + TypeScript.EmptyStatement = EmptyStatement; + + var TryStatement = (function (_super) { + __extends(TryStatement, _super); + function TryStatement(block, catchClause, finallyClause) { + _super.call(this); + this.block = block; + this.catchClause = catchClause; + this.finallyClause = finallyClause; + block && (block.parent = this); + catchClause && (catchClause.parent = this); + finallyClause && (finallyClause.parent = this); + } + TryStatement.prototype.kind = function () { + return 159 /* TryStatement */; + }; + + TryStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.catchClause, ast.catchClause, includingPosition) && structuralEquals(this.finallyClause, ast.finallyClause, includingPosition); + }; + return TryStatement; + })(AST); + TypeScript.TryStatement = TryStatement; + + var CatchClause = (function (_super) { + __extends(CatchClause, _super); + function CatchClause(identifier, typeAnnotation, block) { + _super.call(this); + this.identifier = identifier; + this.typeAnnotation = typeAnnotation; + this.block = block; + identifier && (identifier.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + block && (block.parent = this); + } + CatchClause.prototype.kind = function () { + return 236 /* CatchClause */; + }; + + CatchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.typeAnnotation, ast.typeAnnotation, includingPosition) && structuralEquals(this.block, ast.block, includingPosition); + }; + return CatchClause; + })(AST); + TypeScript.CatchClause = CatchClause; + + var FinallyClause = (function (_super) { + __extends(FinallyClause, _super); + function FinallyClause(block) { + _super.call(this); + this.block = block; + block && (block.parent = this); + } + FinallyClause.prototype.kind = function () { + return 237 /* FinallyClause */; + }; + + FinallyClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition); + }; + return FinallyClause; + })(AST); + TypeScript.FinallyClause = FinallyClause; + + var LabeledStatement = (function (_super) { + __extends(LabeledStatement, _super); + function LabeledStatement(identifier, statement) { + _super.call(this); + this.identifier = identifier; + this.statement = statement; + identifier && (identifier.parent = this); + statement && (statement.parent = this); + } + LabeledStatement.prototype.kind = function () { + return 160 /* LabeledStatement */; + }; + + LabeledStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return LabeledStatement; + })(AST); + TypeScript.LabeledStatement = LabeledStatement; + + var DoStatement = (function (_super) { + __extends(DoStatement, _super); + function DoStatement(statement, whileKeyword, condition) { + _super.call(this); + this.statement = statement; + this.whileKeyword = whileKeyword; + this.condition = condition; + statement && (statement.parent = this); + condition && (condition.parent = this); + } + DoStatement.prototype.kind = function () { + return 161 /* DoStatement */; + }; + + DoStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition); + }; + return DoStatement; + })(AST); + TypeScript.DoStatement = DoStatement; + + var TypeOfExpression = (function (_super) { + __extends(TypeOfExpression, _super); + function TypeOfExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + TypeOfExpression.prototype.kind = function () { + return 171 /* TypeOfExpression */; + }; + + TypeOfExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return TypeOfExpression; + })(AST); + TypeScript.TypeOfExpression = TypeOfExpression; + + var DeleteExpression = (function (_super) { + __extends(DeleteExpression, _super); + function DeleteExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + DeleteExpression.prototype.kind = function () { + return 170 /* DeleteExpression */; + }; + + DeleteExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return DeleteExpression; + })(AST); + TypeScript.DeleteExpression = DeleteExpression; + + var VoidExpression = (function (_super) { + __extends(VoidExpression, _super); + function VoidExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + VoidExpression.prototype.kind = function () { + return 172 /* VoidExpression */; + }; + + VoidExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return VoidExpression; + })(AST); + TypeScript.VoidExpression = VoidExpression; + + var DebuggerStatement = (function (_super) { + __extends(DebuggerStatement, _super); + function DebuggerStatement() { + _super.apply(this, arguments); + } + DebuggerStatement.prototype.kind = function () { + return 162 /* DebuggerStatement */; + }; + return DebuggerStatement; + })(AST); + TypeScript.DebuggerStatement = DebuggerStatement; + + var Comment = (function () { + function Comment(_trivia, endsLine, _start, _end) { + this._trivia = _trivia; + this.endsLine = endsLine; + this._start = _start; + this._end = _end; + } + Comment.prototype.start = function () { + return this._start; + }; + + Comment.prototype.end = function () { + return this._end; + }; + + Comment.prototype.fullText = function () { + return this._trivia.fullText(); + }; + + Comment.prototype.kind = function () { + return this._trivia.kind(); + }; + + Comment.prototype.structuralEquals = function (ast, includingPosition) { + if (includingPosition) { + if (this.start() !== ast.start() || this.end() !== ast.end()) { + return false; + } + } + + return this._trivia.fullText() === ast._trivia.fullText() && this.endsLine === ast.endsLine; + }; + return Comment; + })(); + TypeScript.Comment = Comment; + + function diagnosticFromDecl(decl, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + var span = decl.getSpan(); + return new TypeScript.Diagnostic(decl.fileName(), decl.semanticInfoChain().lineMap(decl.fileName()), span.start(), span.length(), diagnosticKey, arguments); + } + TypeScript.diagnosticFromDecl = diagnosticFromDecl; + + function min(a, b) { + return a <= b ? a : b; + } +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (IOUtils) { + function createDirectoryStructure(ioHost, dirName) { + if (ioHost.directoryExists(dirName)) { + return; + } + + var parentDirectory = ioHost.dirName(dirName); + if (parentDirectory != "") { + createDirectoryStructure(ioHost, parentDirectory); + } + ioHost.createDirectory(dirName); + } + + function writeFileAndFolderStructure(ioHost, fileName, contents, writeByteOrderMark) { + var start = new Date().getTime(); + var path = ioHost.resolvePath(fileName); + TypeScript.ioHostResolvePathTime += new Date().getTime() - start; + + var start = new Date().getTime(); + var dirName = ioHost.dirName(path); + TypeScript.ioHostDirectoryNameTime += new Date().getTime() - start; + + var start = new Date().getTime(); + createDirectoryStructure(ioHost, dirName); + TypeScript.ioHostCreateDirectoryStructureTime += new Date().getTime() - start; + + var start = new Date().getTime(); + ioHost.writeFile(path, contents, writeByteOrderMark); + TypeScript.ioHostWriteFileTime += new Date().getTime() - start; + } + IOUtils.writeFileAndFolderStructure = writeFileAndFolderStructure; + + function throwIOError(message, error) { + var errorMessage = message; + if (error && error.message) { + errorMessage += (" " + error.message); + } + throw new Error(errorMessage); + } + IOUtils.throwIOError = throwIOError; + + function combine(prefix, suffix) { + return prefix + "/" + suffix; + } + IOUtils.combine = combine; + + var BufferedTextWriter = (function () { + function BufferedTextWriter(writer, capacity) { + if (typeof capacity === "undefined") { capacity = 1024; } + this.writer = writer; + this.capacity = capacity; + this.buffer = ""; + } + BufferedTextWriter.prototype.Write = function (str) { + this.buffer += str; + if (this.buffer.length >= this.capacity) { + this.writer.Write(this.buffer); + this.buffer = ""; + } + }; + BufferedTextWriter.prototype.WriteLine = function (str) { + this.Write(str + '\r\n'); + }; + BufferedTextWriter.prototype.Close = function () { + this.writer.Write(this.buffer); + this.writer.Close(); + this.buffer = null; + }; + return BufferedTextWriter; + })(); + IOUtils.BufferedTextWriter = BufferedTextWriter; + })(TypeScript.IOUtils || (TypeScript.IOUtils = {})); + var IOUtils = TypeScript.IOUtils; + + TypeScript.IO = (function () { + function getWindowsScriptHostIO() { + var fso = new ActiveXObject("Scripting.FileSystemObject"); + var streamObjectPool = []; + + function getStreamObject() { + if (streamObjectPool.length > 0) { + return streamObjectPool.pop(); + } else { + return new ActiveXObject("ADODB.Stream"); + } + } + + function releaseStreamObject(obj) { + streamObjectPool.push(obj); + } + + var args = []; + for (var i = 0; i < WScript.Arguments.length; i++) { + args[i] = WScript.Arguments.Item(i); + } + + return { + readFile: function (path, codepage) { + return TypeScript.Environment.readFile(path, codepage); + }, + writeFile: function (path, contents, writeByteOrderMark) { + TypeScript.Environment.writeFile(path, contents, writeByteOrderMark); + }, + fileExists: function (path) { + return fso.FileExists(path); + }, + resolvePath: function (path) { + return fso.GetAbsolutePathName(path); + }, + dirName: function (path) { + return fso.GetParentFolderName(path); + }, + findFile: function (rootPath, partialFilePath) { + var path = fso.GetAbsolutePathName(rootPath) + "/" + partialFilePath; + + while (true) { + if (fso.FileExists(path)) { + return { fileInformation: this.readFile(path), path: path }; + } else { + rootPath = fso.GetParentFolderName(fso.GetAbsolutePathName(rootPath)); + + if (rootPath == "") { + return null; + } else { + path = fso.BuildPath(rootPath, partialFilePath); + } + } + } + }, + deleteFile: function (path) { + try { + if (fso.FileExists(path)) { + fso.DeleteFile(path, true); + } + } catch (e) { + IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_delete_file_0, [path]), e); + } + }, + directoryExists: function (path) { + return fso.FolderExists(path); + }, + createDirectory: function (path) { + try { + if (!this.directoryExists(path)) { + fso.CreateFolder(path); + } + } catch (e) { + IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_create_directory_0, [path]), e); + } + }, + dir: function (path, spec, options) { + options = options || {}; + function filesInFolder(folder, root) { + var paths = []; + var fc; + + if (options.recursive) { + fc = new Enumerator(folder.subfolders); + + for (; !fc.atEnd(); fc.moveNext()) { + paths = paths.concat(filesInFolder(fc.item(), root + "/" + fc.item().Name)); + } + } + + fc = new Enumerator(folder.files); + + for (; !fc.atEnd(); fc.moveNext()) { + if (!spec || fc.item().Name.match(spec)) { + paths.push(root + "/" + fc.item().Name); + } + } + + return paths; + } + + var folder = fso.GetFolder(path); + var paths = []; + + return filesInFolder(folder, path); + }, + print: function (str) { + WScript.StdOut.Write(str); + }, + printLine: function (str) { + WScript.Echo(str); + }, + arguments: args, + stderr: WScript.StdErr, + stdout: WScript.StdOut, + watchFile: null, + run: function (source, fileName) { + try { + eval(source); + } catch (e) { + IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Error_while_executing_file_0, [fileName]), e); + } + }, + getExecutingFilePath: function () { + return WScript.ScriptFullName; + }, + quit: function (exitCode) { + if (typeof exitCode === "undefined") { exitCode = 0; } + try { + WScript.Quit(exitCode); + } catch (e) { + } + } + }; + } + ; + + function getNodeIO() { + var _fs = require('fs'); + var _path = require('path'); + var _module = require('module'); + + return { + readFile: function (file, codepage) { + return TypeScript.Environment.readFile(file, codepage); + }, + writeFile: function (path, contents, writeByteOrderMark) { + TypeScript.Environment.writeFile(path, contents, writeByteOrderMark); + }, + deleteFile: function (path) { + try { + _fs.unlinkSync(path); + } catch (e) { + IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_delete_file_0, [path]), e); + } + }, + fileExists: function (path) { + return _fs.existsSync(path); + }, + dir: function dir(path, spec, options) { + options = options || {}; + + function filesInFolder(folder) { + var paths = []; + + try { + var files = _fs.readdirSync(folder); + for (var i = 0; i < files.length; i++) { + var stat = _fs.statSync(folder + "/" + files[i]); + if (options.recursive && stat.isDirectory()) { + paths = paths.concat(filesInFolder(folder + "/" + files[i])); + } else if (stat.isFile() && (!spec || files[i].match(spec))) { + paths.push(folder + "/" + files[i]); + } + } + } catch (err) { + } + + return paths; + } + + return filesInFolder(path); + }, + createDirectory: function (path) { + try { + if (!this.directoryExists(path)) { + _fs.mkdirSync(path); + } + } catch (e) { + IOUtils.throwIOError(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_create_directory_0, [path]), e); + } + }, + directoryExists: function (path) { + return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); + }, + resolvePath: function (path) { + return _path.resolve(path); + }, + dirName: function (path) { + var dirPath = _path.dirname(path); + + if (dirPath === path) { + dirPath = null; + } + + return dirPath; + }, + findFile: function (rootPath, partialFilePath) { + var path = rootPath + "/" + partialFilePath; + + while (true) { + if (_fs.existsSync(path)) { + return { fileInformation: this.readFile(path), path: path }; + } else { + var parentPath = _path.resolve(rootPath, ".."); + + if (rootPath === parentPath) { + return null; + } else { + rootPath = parentPath; + path = _path.resolve(rootPath, partialFilePath); + } + } + } + }, + print: function (str) { + process.stdout.write(str); + }, + printLine: function (str) { + process.stdout.write(str + '\n'); + }, + arguments: process.argv.slice(2), + stderr: { + Write: function (str) { + process.stderr.write(str); + }, + WriteLine: function (str) { + process.stderr.write(str + '\n'); + }, + Close: function () { + } + }, + stdout: { + Write: function (str) { + process.stdout.write(str); + }, + WriteLine: function (str) { + process.stdout.write(str + '\n'); + }, + Close: function () { + } + }, + watchFile: function (fileName, callback) { + var firstRun = true; + var processingChange = false; + + var fileChanged = function (curr, prev) { + if (!firstRun) { + if (curr.mtime < prev.mtime) { + return; + } + + _fs.unwatchFile(fileName, fileChanged); + if (!processingChange) { + processingChange = true; + callback(fileName); + setTimeout(function () { + processingChange = false; + }, 100); + } + } + firstRun = false; + _fs.watchFile(fileName, { persistent: true, interval: 500 }, fileChanged); + }; + + fileChanged(); + return { + fileName: fileName, + close: function () { + _fs.unwatchFile(fileName, fileChanged); + } + }; + }, + run: function (source, fileName) { + require.main.fileName = fileName; + require.main.paths = _module._nodeModulePaths(_path.dirname(_fs.realpathSync(fileName))); + require.main._compile(source, fileName); + }, + getExecutingFilePath: function () { + return process.mainModule.filename; + }, + quit: function (code) { + var stderrFlushed = process.stderr.write(''); + var stdoutFlushed = process.stdout.write(''); + process.stderr.on('drain', function () { + stderrFlushed = true; + if (stdoutFlushed) { + process.exit(code); + } + }); + process.stdout.on('drain', function () { + stdoutFlushed = true; + if (stderrFlushed) { + process.exit(code); + } + }); + setTimeout(function () { + process.exit(code); + }, 5); + } + }; + } + ; + + if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") + return getWindowsScriptHostIO(); + else if (typeof module !== 'undefined' && module.exports) + return getNodeIO(); + else + return null; + })(); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var OptionsParser = (function () { + function OptionsParser(host, version) { + this.host = host; + this.version = version; + this.DEFAULT_SHORT_FLAG = "-"; + this.DEFAULT_LONG_FLAG = "--"; + this.printedVersion = false; + this.unnamed = []; + this.options = []; + } + OptionsParser.prototype.findOption = function (arg) { + var upperCaseArg = arg && arg.toUpperCase(); + + for (var i = 0; i < this.options.length; i++) { + var current = this.options[i]; + + if (upperCaseArg === (current.short && current.short.toUpperCase()) || upperCaseArg === (current.name && current.name.toUpperCase())) { + return current; + } + } + + return null; + }; + + OptionsParser.prototype.printUsage = function () { + this.printVersion(); + + var optionsWord = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.options, null); + var fileWord = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.file1, null); + var tscSyntax = "tsc [" + optionsWord + "] [" + fileWord + " ..]"; + var syntaxHelp = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Syntax_0, [tscSyntax]); + this.host.printLine(syntaxHelp); + this.host.printLine(""); + this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Examples, null) + " tsc hello.ts"); + this.host.printLine(" tsc --out foo.js foo.ts"); + this.host.printLine(" tsc @args.txt"); + this.host.printLine(""); + this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Options, null)); + + var output = []; + var maxLength = 0; + var i = 0; + + this.options = this.options.sort(function (a, b) { + var aName = a.name.toLowerCase(); + var bName = b.name.toLowerCase(); + + if (aName > bName) { + return 1; + } else if (aName < bName) { + return -1; + } else { + return 0; + } + }); + + for (i = 0; i < this.options.length; i++) { + var option = this.options[i]; + + if (option.experimental) { + continue; + } + + if (!option.usage) { + break; + } + + var usageString = " "; + var type = option.type ? (" " + TypeScript.getLocalizedText(option.type, null)) : ""; + + if (option.short) { + usageString += this.DEFAULT_SHORT_FLAG + option.short + type + ", "; + } + + usageString += this.DEFAULT_LONG_FLAG + option.name + type; + + output.push([usageString, TypeScript.getLocalizedText(option.usage.locCode, option.usage.args)]); + + if (usageString.length > maxLength) { + maxLength = usageString.length; + } + } + + var fileDescription = TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Insert_command_line_options_and_files_from_a_file, null); + output.push([" @<" + fileWord + ">", fileDescription]); + + for (i = 0; i < output.length; i++) { + this.host.printLine(output[i][0] + (new Array(maxLength - output[i][0].length + 3)).join(" ") + output[i][1]); + } + }; + + OptionsParser.prototype.printVersion = function () { + if (!this.printedVersion) { + this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Version_0, [this.version])); + this.printedVersion = true; + } + }; + + OptionsParser.prototype.option = function (name, config, short) { + if (!config) { + config = short; + short = null; + } + + config.name = name; + config.short = short; + config.flag = false; + + this.options.push(config); + }; + + OptionsParser.prototype.flag = function (name, config, short) { + if (!config) { + config = short; + short = null; + } + + config.name = name; + config.short = short; + config.flag = true; + + this.options.push(config); + }; + + OptionsParser.prototype.parseString = function (argString) { + var position = 0; + var tokens = argString.match(/\s+|"|[^\s"]+/g); + + function peek() { + return tokens[position]; + } + + function consume() { + return tokens[position++]; + } + + function consumeQuotedString() { + var value = ''; + consume(); + + var token = peek(); + + while (token && token !== '"') { + consume(); + + value += token; + + token = peek(); + } + + consume(); + + return value; + } + + var args = []; + var currentArg = ''; + + while (position < tokens.length) { + var token = peek(); + + if (token === '"') { + currentArg += consumeQuotedString(); + } else if (token.match(/\s/)) { + if (currentArg.length > 0) { + args.push(currentArg); + currentArg = ''; + } + + consume(); + } else { + consume(); + currentArg += token; + } + } + + if (currentArg.length > 0) { + args.push(currentArg); + } + + this.parse(args); + }; + + OptionsParser.prototype.parse = function (args) { + var position = 0; + + function consume() { + return args[position++]; + } + + while (position < args.length) { + var current = consume(); + var match = current.match(/^(--?|@)(.*)/); + var value = null; + + if (match) { + if (match[1] === '@') { + this.parseString(this.host.readFile(match[2], null).contents); + } else { + var arg = match[2]; + var option = this.findOption(arg); + + if (option === null) { + this.host.printLine(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unknown_option_0, [arg])); + this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Use_the_0_flag_to_see_options, ["--help"])); + } else { + if (!option.flag) { + value = consume(); + if (value === undefined) { + this.host.printLine(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Option_0_specified_without_1, [arg, TypeScript.getLocalizedText(option.type, null)])); + this.host.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.Use_the_0_flag_to_see_options, ["--help"])); + continue; + } + } + + option.set(value); + } + } + } else { + this.unnamed.push(current); + } + } + }; + return OptionsParser; + })(); + TypeScript.OptionsParser = OptionsParser; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SourceFile = (function () { + function SourceFile(scriptSnapshot, byteOrderMark) { + this.scriptSnapshot = scriptSnapshot; + this.byteOrderMark = byteOrderMark; + } + return SourceFile; + })(); + + var DiagnosticsLogger = (function () { + function DiagnosticsLogger(ioHost) { + this.ioHost = ioHost; + } + DiagnosticsLogger.prototype.information = function () { + return false; + }; + DiagnosticsLogger.prototype.debug = function () { + return false; + }; + DiagnosticsLogger.prototype.warning = function () { + return false; + }; + DiagnosticsLogger.prototype.error = function () { + return false; + }; + DiagnosticsLogger.prototype.fatal = function () { + return false; + }; + DiagnosticsLogger.prototype.log = function (s) { + this.ioHost.stdout.WriteLine(s); + }; + return DiagnosticsLogger; + })(); + + var BatchCompiler = (function () { + function BatchCompiler(ioHost) { + this.ioHost = ioHost; + this.compilerVersion = "0.9.5.0"; + this.inputFiles = []; + this.resolvedFiles = []; + this.fileNameToSourceFile = new TypeScript.StringHashTable(); + this.hasErrors = false; + this.logger = null; + this.fileExistsCache = TypeScript.createIntrinsicsObject(); + this.resolvePathCache = TypeScript.createIntrinsicsObject(); + } + BatchCompiler.prototype.batchCompile = function () { + var _this = this; + var start = new Date().getTime(); + + TypeScript.CompilerDiagnostics.diagnosticWriter = { Alert: function (s) { + _this.ioHost.printLine(s); + } }; + + if (this.parseOptions()) { + this.logger = this.compilationSettings.gatherDiagnostics() ? new DiagnosticsLogger(this.ioHost) : new TypeScript.NullLogger(); + + if (this.compilationSettings.watch()) { + this.watchFiles(); + return; + } + + this.resolve(); + + this.compile(); + + if (this.compilationSettings.gatherDiagnostics()) { + this.logger.log(""); + this.logger.log("File resolution time: " + TypeScript.fileResolutionTime); + this.logger.log(" file read: " + TypeScript.fileResolutionIOTime); + this.logger.log(" scan imports: " + TypeScript.fileResolutionScanImportsTime); + this.logger.log(" import search: " + TypeScript.fileResolutionImportFileSearchTime); + this.logger.log(" get lib.d.ts: " + TypeScript.fileResolutionGetDefaultLibraryTime); + + this.logger.log("SyntaxTree parse time: " + TypeScript.syntaxTreeParseTime); + this.logger.log("Syntax Diagnostics time: " + TypeScript.syntaxDiagnosticsTime); + this.logger.log("AST translation time: " + TypeScript.astTranslationTime); + this.logger.log(""); + this.logger.log("Type check time: " + TypeScript.typeCheckTime); + this.logger.log(""); + this.logger.log("Emit time: " + TypeScript.emitTime); + this.logger.log("Declaration emit time: " + TypeScript.declarationEmitTime); + + this.logger.log("Total number of symbols created: " + TypeScript.pullSymbolID); + this.logger.log("Specialized types created: " + TypeScript.nSpecializationsCreated); + this.logger.log("Specialized signatures created: " + TypeScript.nSpecializedSignaturesCreated); + + this.logger.log(" IsExternallyVisibleTime: " + TypeScript.declarationEmitIsExternallyVisibleTime); + this.logger.log(" TypeSignatureTime: " + TypeScript.declarationEmitTypeSignatureTime); + this.logger.log(" GetBoundDeclTypeTime: " + TypeScript.declarationEmitGetBoundDeclTypeTime); + this.logger.log(" IsOverloadedCallSignatureTime: " + TypeScript.declarationEmitIsOverloadedCallSignatureTime); + this.logger.log(" FunctionDeclarationGetSymbolTime: " + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime); + this.logger.log(" GetBaseTypeTime: " + TypeScript.declarationEmitGetBaseTypeTime); + this.logger.log(" GetAccessorFunctionTime: " + TypeScript.declarationEmitGetAccessorFunctionTime); + this.logger.log(" GetTypeParameterSymbolTime: " + TypeScript.declarationEmitGetTypeParameterSymbolTime); + this.logger.log(" GetImportDeclarationSymbolTime: " + TypeScript.declarationEmitGetImportDeclarationSymbolTime); + + this.logger.log("Emit write file time: " + TypeScript.emitWriteFileTime); + + this.logger.log("Compiler resolve path time: " + TypeScript.compilerResolvePathTime); + this.logger.log("Compiler directory name time: " + TypeScript.compilerDirectoryNameTime); + this.logger.log("Compiler directory exists time: " + TypeScript.compilerDirectoryExistsTime); + this.logger.log("Compiler file exists time: " + TypeScript.compilerFileExistsTime); + + this.logger.log("IO host resolve path time: " + TypeScript.ioHostResolvePathTime); + this.logger.log("IO host directory name time: " + TypeScript.ioHostDirectoryNameTime); + this.logger.log("IO host create directory structure time: " + TypeScript.ioHostCreateDirectoryStructureTime); + this.logger.log("IO host write file time: " + TypeScript.ioHostWriteFileTime); + + this.logger.log("Node make directory time: " + TypeScript.nodeMakeDirectoryTime); + this.logger.log("Node writeFileSync time: " + TypeScript.nodeWriteFileSyncTime); + this.logger.log("Node createBuffer time: " + TypeScript.nodeCreateBufferTime); + } + } + + this.ioHost.quit(this.hasErrors ? 1 : 0); + }; + + BatchCompiler.prototype.resolve = function () { + var _this = this; + var includeDefaultLibrary = !this.compilationSettings.noLib(); + var resolvedFiles = []; + + var start = new Date().getTime(); + + if (!this.compilationSettings.noResolve()) { + var resolutionResults = TypeScript.ReferenceResolver.resolve(this.inputFiles, this, this.compilationSettings.useCaseSensitiveFileResolution()); + resolvedFiles = resolutionResults.resolvedFiles; + + includeDefaultLibrary = !this.compilationSettings.noLib() && !resolutionResults.seenNoDefaultLibTag; + + resolutionResults.diagnostics.forEach(function (d) { + return _this.addDiagnostic(d); + }); + } else { + for (var i = 0, n = this.inputFiles.length; i < n; i++) { + var inputFile = this.inputFiles[i]; + var referencedFiles = []; + var importedFiles = []; + + if (this.compilationSettings.generateDeclarationFiles()) { + var references = TypeScript.getReferencedFiles(inputFile, this.getScriptSnapshot(inputFile)); + for (var j = 0; j < references.length; j++) { + referencedFiles.push(references[j].path); + } + + inputFile = this.resolvePath(inputFile); + } + + resolvedFiles.push({ + path: inputFile, + referencedFiles: referencedFiles, + importedFiles: importedFiles + }); + } + } + + var defaultLibStart = new Date().getTime(); + if (includeDefaultLibrary) { + var libraryResolvedFile = { + path: this.getDefaultLibraryFilePath(), + referencedFiles: [], + importedFiles: [] + }; + + resolvedFiles = [libraryResolvedFile].concat(resolvedFiles); + } + TypeScript.fileResolutionGetDefaultLibraryTime += new Date().getTime() - defaultLibStart; + + this.resolvedFiles = resolvedFiles; + + TypeScript.fileResolutionTime = new Date().getTime() - start; + }; + + BatchCompiler.prototype.compile = function () { + var _this = this; + var compiler = new TypeScript.TypeScriptCompiler(this.logger, this.compilationSettings); + + this.resolvedFiles.forEach(function (resolvedFile) { + var sourceFile = _this.getSourceFile(resolvedFile.path); + compiler.addFile(resolvedFile.path, sourceFile.scriptSnapshot, sourceFile.byteOrderMark, 0, false, resolvedFile.referencedFiles); + }); + + for (var it = compiler.compile(function (path) { + return _this.resolvePath(path); + }); it.moveNext();) { + var result = it.current(); + + result.diagnostics.forEach(function (d) { + return _this.addDiagnostic(d); + }); + if (!this.tryWriteOutputFiles(result.outputFiles)) { + return; + } + } + }; + + BatchCompiler.prototype.parseOptions = function () { + var _this = this; + var opts = new TypeScript.OptionsParser(this.ioHost, this.compilerVersion); + + var mutableSettings = new TypeScript.CompilationSettings(); + opts.option('out', { + usage: { + locCode: TypeScript.DiagnosticCode.Concatenate_and_emit_output_to_single_file, + args: null + }, + type: TypeScript.DiagnosticCode.file2, + set: function (str) { + mutableSettings.outFileOption = str; + } + }); + + opts.option('outDir', { + usage: { + locCode: TypeScript.DiagnosticCode.Redirect_output_structure_to_the_directory, + args: null + }, + type: TypeScript.DiagnosticCode.DIRECTORY, + set: function (str) { + mutableSettings.outDirOption = str; + } + }); + + opts.flag('sourcemap', { + usage: { + locCode: TypeScript.DiagnosticCode.Generates_corresponding_0_file, + args: ['.map'] + }, + set: function () { + mutableSettings.mapSourceFiles = true; + } + }); + + opts.option('mapRoot', { + usage: { + locCode: TypeScript.DiagnosticCode.Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations, + args: null + }, + type: TypeScript.DiagnosticCode.LOCATION, + set: function (str) { + mutableSettings.mapRoot = str; + } + }); + + opts.option('sourceRoot', { + usage: { + locCode: TypeScript.DiagnosticCode.Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations, + args: null + }, + type: TypeScript.DiagnosticCode.LOCATION, + set: function (str) { + mutableSettings.sourceRoot = str; + } + }); + + opts.flag('declaration', { + usage: { + locCode: TypeScript.DiagnosticCode.Generates_corresponding_0_file, + args: ['.d.ts'] + }, + set: function () { + mutableSettings.generateDeclarationFiles = true; + } + }, 'd'); + + if (this.ioHost.watchFile) { + opts.flag('watch', { + usage: { + locCode: TypeScript.DiagnosticCode.Watch_input_files, + args: null + }, + set: function () { + mutableSettings.watch = true; + } + }, 'w'); + } + + opts.flag('propagateEnumConstants', { + experimental: true, + set: function () { + mutableSettings.propagateEnumConstants = true; + } + }); + + opts.flag('removeComments', { + usage: { + locCode: TypeScript.DiagnosticCode.Do_not_emit_comments_to_output, + args: null + }, + set: function () { + mutableSettings.removeComments = true; + } + }); + + opts.flag('noResolve', { + usage: { + locCode: TypeScript.DiagnosticCode.Skip_resolution_and_preprocessing, + args: null + }, + set: function () { + mutableSettings.noResolve = true; + } + }); + + opts.flag('noLib', { + experimental: true, + set: function () { + mutableSettings.noLib = true; + } + }); + + opts.flag('diagnostics', { + experimental: true, + set: function () { + mutableSettings.gatherDiagnostics = true; + } + }); + + opts.option('target', { + usage: { + locCode: TypeScript.DiagnosticCode.Specify_ECMAScript_target_version_0_default_or_1, + args: ['ES3', 'ES5'] + }, + type: TypeScript.DiagnosticCode.VERSION, + set: function (type) { + type = type.toLowerCase(); + + if (type === 'es3') { + mutableSettings.codeGenTarget = 0 /* EcmaScript3 */; + } else if (type === 'es5') { + mutableSettings.codeGenTarget = 1 /* EcmaScript5 */; + } else { + _this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2, [type, "ES3", "ES5"])); + } + } + }, 't'); + + opts.option('module', { + usage: { + locCode: TypeScript.DiagnosticCode.Specify_module_code_generation_0_or_1, + args: ['commonjs', 'amd'] + }, + type: TypeScript.DiagnosticCode.KIND, + set: function (type) { + type = type.toLowerCase(); + + if (type === 'commonjs') { + mutableSettings.moduleGenTarget = 1 /* Synchronous */; + } else if (type === 'amd') { + mutableSettings.moduleGenTarget = 2 /* Asynchronous */; + } else { + _this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Module_code_generation_0_not_supported, [type])); + } + } + }, 'm'); + + var needsHelp = false; + opts.flag('help', { + usage: { + locCode: TypeScript.DiagnosticCode.Print_this_message, + args: null + }, + set: function () { + needsHelp = true; + } + }, 'h'); + + opts.flag('useCaseSensitiveFileResolution', { + experimental: true, + set: function () { + mutableSettings.useCaseSensitiveFileResolution = true; + } + }); + var shouldPrintVersionOnly = false; + opts.flag('version', { + usage: { + locCode: TypeScript.DiagnosticCode.Print_the_compiler_s_version_0, + args: [this.compilerVersion] + }, + set: function () { + shouldPrintVersionOnly = true; + } + }, 'v'); + + var locale = null; + opts.option('locale', { + experimental: true, + usage: { + locCode: TypeScript.DiagnosticCode.Specify_locale_for_errors_and_messages_For_example_0_or_1, + args: ['en', 'ja-jp'] + }, + type: TypeScript.DiagnosticCode.STRING, + set: function (value) { + locale = value; + } + }); + + opts.flag('noImplicitAny', { + usage: { + locCode: TypeScript.DiagnosticCode.Warn_on_expressions_and_declarations_with_an_implied_any_type, + args: null + }, + set: function () { + mutableSettings.noImplicitAny = true; + } + }); + + if (TypeScript.Environment.supportsCodePage()) { + opts.option('codepage', { + usage: { + locCode: TypeScript.DiagnosticCode.Specify_the_codepage_to_use_when_opening_source_files, + args: null + }, + type: TypeScript.DiagnosticCode.NUMBER, + set: function (arg) { + mutableSettings.codepage = parseInt(arg, 10); + } + }); + } + + opts.parse(this.ioHost.arguments); + + this.compilationSettings = TypeScript.ImmutableCompilationSettings.fromCompilationSettings(mutableSettings); + + if (locale) { + if (!this.setLocale(locale)) { + return false; + } + } + + this.inputFiles.push.apply(this.inputFiles, opts.unnamed); + + if (this.inputFiles.length === 0 || needsHelp) { + opts.printUsage(); + return false; + } else if (shouldPrintVersionOnly) { + opts.printVersion(); + } + + return !this.hasErrors; + }; + + BatchCompiler.prototype.setLocale = function (locale) { + var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase()); + if (!matchResult) { + this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, ['en', 'ja-jp'])); + return false; + } + + var language = matchResult[1]; + var territory = matchResult[3]; + + if (!this.setLanguageAndTerritory(language, territory) && !this.setLanguageAndTerritory(language, null)) { + this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Unsupported_locale_0, [locale])); + return false; + } + + return true; + }; + + BatchCompiler.prototype.setLanguageAndTerritory = function (language, territory) { + var compilerFilePath = this.ioHost.getExecutingFilePath(); + var containingDirectoryPath = this.ioHost.dirName(compilerFilePath); + + var filePath = TypeScript.IOUtils.combine(containingDirectoryPath, language); + if (territory) { + filePath = filePath + "-" + territory; + } + + filePath = this.resolvePath(TypeScript.IOUtils.combine(filePath, "diagnosticMessages.generated.json")); + + if (!this.fileExists(filePath)) { + return false; + } + + var fileContents = this.ioHost.readFile(filePath, this.compilationSettings.codepage()); + TypeScript.LocalizedDiagnosticMessages = JSON.parse(fileContents.contents); + return true; + }; + + BatchCompiler.prototype.watchFiles = function () { + var _this = this; + if (!this.ioHost.watchFile) { + this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Current_host_does_not_support_0_option, ['-w[atch]'])); + return; + } + + var lastResolvedFileSet = []; + var watchers = {}; + var firstTime = true; + + var addWatcher = function (fileName) { + if (!watchers[fileName]) { + var watcher = _this.ioHost.watchFile(fileName, onWatchedFileChange); + watchers[fileName] = watcher; + } else { + TypeScript.CompilerDiagnostics.debugPrint("Cannot watch file, it is already watched."); + } + }; + + var removeWatcher = function (fileName) { + if (watchers[fileName]) { + watchers[fileName].close(); + delete watchers[fileName]; + } else { + TypeScript.CompilerDiagnostics.debugPrint("Cannot stop watching file, it is not being watched."); + } + }; + + var onWatchedFileChange = function () { + _this.hasErrors = false; + + _this.fileNameToSourceFile = new TypeScript.StringHashTable(); + + _this.resolve(); + + var oldFiles = lastResolvedFileSet; + var newFiles = _this.resolvedFiles.map(function (resolvedFile) { + return resolvedFile.path; + }).sort(); + + var i = 0, j = 0; + while (i < oldFiles.length && j < newFiles.length) { + var compareResult = oldFiles[i].localeCompare(newFiles[j]); + if (compareResult === 0) { + i++; + j++; + } else if (compareResult < 0) { + removeWatcher(oldFiles[i]); + i++; + } else { + addWatcher(newFiles[j]); + j++; + } + } + + for (var k = i; k < oldFiles.length; k++) { + removeWatcher(oldFiles[k]); + } + + for (k = j; k < newFiles.length; k++) { + addWatcher(newFiles[k]); + } + + lastResolvedFileSet = newFiles; + + if (!firstTime) { + var fileNames = ""; + for (var k = 0; k < lastResolvedFileSet.length; k++) { + fileNames += TypeScript.Environment.newLine + " " + lastResolvedFileSet[k]; + } + _this.ioHost.printLine(TypeScript.getLocalizedText(TypeScript.DiagnosticCode.NL_Recompiling_0, [fileNames])); + } else { + firstTime = false; + } + + _this.compile(); + }; + + this.ioHost.stderr = this.ioHost.stdout; + + onWatchedFileChange(); + }; + + BatchCompiler.prototype.getSourceFile = function (fileName) { + var sourceFile = this.fileNameToSourceFile.lookup(fileName); + if (!sourceFile) { + var fileInformation; + + try { + fileInformation = this.ioHost.readFile(fileName, this.compilationSettings.codepage()); + } catch (e) { + this.addDiagnostic(new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_read_file_0_1, [fileName, e.message])); + fileInformation = new TypeScript.FileInformation("", 0 /* None */); + } + + var snapshot = TypeScript.ScriptSnapshot.fromString(fileInformation.contents); + var sourceFile = new SourceFile(snapshot, fileInformation.byteOrderMark); + this.fileNameToSourceFile.add(fileName, sourceFile); + } + + return sourceFile; + }; + + BatchCompiler.prototype.getDefaultLibraryFilePath = function () { + var compilerFilePath = this.ioHost.getExecutingFilePath(); + var containingDirectoryPath = this.ioHost.dirName(compilerFilePath); + var libraryFilePath = this.resolvePath(TypeScript.IOUtils.combine(containingDirectoryPath, "lib.d.ts")); + + return libraryFilePath; + }; + + BatchCompiler.prototype.getScriptSnapshot = function (fileName) { + return this.getSourceFile(fileName).scriptSnapshot; + }; + + BatchCompiler.prototype.resolveRelativePath = function (path, directory) { + var start = new Date().getTime(); + + var unQuotedPath = TypeScript.stripStartAndEndQuotes(path); + var normalizedPath; + + if (TypeScript.isRooted(unQuotedPath) || !directory) { + normalizedPath = unQuotedPath; + } else { + normalizedPath = TypeScript.IOUtils.combine(directory, unQuotedPath); + } + + normalizedPath = this.resolvePath(normalizedPath); + + normalizedPath = TypeScript.switchToForwardSlashes(normalizedPath); + + return normalizedPath; + }; + + BatchCompiler.prototype.fileExists = function (path) { + var exists = this.fileExistsCache[path]; + if (exists === undefined) { + var start = new Date().getTime(); + exists = this.ioHost.fileExists(path); + this.fileExistsCache[path] = exists; + TypeScript.compilerFileExistsTime += new Date().getTime() - start; + } + + return exists; + }; + + BatchCompiler.prototype.getParentDirectory = function (path) { + var start = new Date().getTime(); + var result = this.ioHost.dirName(path); + TypeScript.compilerDirectoryNameTime += new Date().getTime() - start; + + return result; + }; + + BatchCompiler.prototype.addDiagnostic = function (diagnostic) { + var diagnosticInfo = diagnostic.info(); + if (diagnosticInfo.category === 1 /* Error */) { + this.hasErrors = true; + } + + if (diagnostic.fileName()) { + this.ioHost.stderr.Write(diagnostic.fileName() + "(" + (diagnostic.line() + 1) + "," + (diagnostic.character() + 1) + "): "); + } + + this.ioHost.stderr.WriteLine(diagnostic.message()); + }; + + BatchCompiler.prototype.tryWriteOutputFiles = function (outputFiles) { + for (var i = 0, n = outputFiles.length; i < n; i++) { + var outputFile = outputFiles[i]; + + try { + this.writeFile(outputFile.name, outputFile.text, outputFile.writeByteOrderMark); + } catch (e) { + this.addDiagnostic(new TypeScript.Diagnostic(outputFile.name, null, 0, 0, TypeScript.DiagnosticCode.Emit_Error_0, [e.message])); + return false; + } + } + + return true; + }; + + BatchCompiler.prototype.writeFile = function (fileName, contents, writeByteOrderMark) { + var start = new Date().getTime(); + TypeScript.IOUtils.writeFileAndFolderStructure(this.ioHost, fileName, contents, writeByteOrderMark); + TypeScript.emitWriteFileTime += new Date().getTime() - start; + }; + + BatchCompiler.prototype.directoryExists = function (path) { + var start = new Date().getTime(); + var result = this.ioHost.directoryExists(path); + TypeScript.compilerDirectoryExistsTime += new Date().getTime() - start; + return result; + }; + + BatchCompiler.prototype.resolvePath = function (path) { + var cachedValue = this.resolvePathCache[path]; + if (!cachedValue) { + var start = new Date().getTime(); + cachedValue = this.ioHost.resolvePath(path); + this.resolvePathCache[path] = cachedValue; + TypeScript.compilerResolvePathTime += new Date().getTime() - start; + } + + return cachedValue; + }; + return BatchCompiler; + })(); + TypeScript.BatchCompiler = BatchCompiler; + + var batch = new TypeScript.BatchCompiler(TypeScript.IO); + batch.batchCompile(); +})(TypeScript || (TypeScript = {})); diff --git a/_infrastructure/tests/typescript/0.9.5/typescript.js b/_infrastructure/tests/typescript/0.9.5/typescript.js new file mode 100644 index 000000000..e95da074e --- /dev/null +++ b/_infrastructure/tests/typescript/0.9.5/typescript.js @@ -0,0 +1,59575 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +var TypeScript; +(function (TypeScript) { + TypeScript.DiagnosticCode = { + error_TS_0_1: "error TS{0}: {1}", + warning_TS_0_1: "warning TS{0}: {1}", + Unrecognized_escape_sequence: "Unrecognized escape sequence.", + Unexpected_character_0: "Unexpected character {0}.", + Missing_close_quote_character: "Missing close quote character.", + Identifier_expected: "Identifier expected.", + _0_keyword_expected: "'{0}' keyword expected.", + _0_expected: "'{0}' expected.", + Identifier_expected_0_is_a_keyword: "Identifier expected; '{0}' is a keyword.", + Automatic_semicolon_insertion_not_allowed: "Automatic semicolon insertion not allowed.", + Unexpected_token_0_expected: "Unexpected token; '{0}' expected.", + Trailing_separator_not_allowed: "Trailing separator not allowed.", + AsteriskSlash_expected: "'*/' expected.", + public_or_private_modifier_must_precede_static: "'public' or 'private' modifier must precede 'static'.", + Unexpected_token: "Unexpected token.", + Catch_clause_parameter_cannot_have_a_type_annotation: "Catch clause parameter cannot have a type annotation.", + Rest_parameter_must_be_last_in_list: "Rest parameter must be last in list.", + Parameter_cannot_have_question_mark_and_initializer: "Parameter cannot have question mark and initializer.", + Required_parameter_cannot_follow_optional_parameter: "Required parameter cannot follow optional parameter.", + Index_signatures_cannot_have_rest_parameters: "Index signatures cannot have rest parameters.", + Index_signature_parameter_cannot_have_accessibility_modifiers: "Index signature parameter cannot have accessibility modifiers.", + Index_signature_parameter_cannot_have_a_question_mark: "Index signature parameter cannot have a question mark.", + Index_signature_parameter_cannot_have_an_initializer: "Index signature parameter cannot have an initializer.", + Index_signature_must_have_a_type_annotation: "Index signature must have a type annotation.", + Index_signature_parameter_must_have_a_type_annotation: "Index signature parameter must have a type annotation.", + Index_signature_parameter_type_must_be_string_or_number: "Index signature parameter type must be 'string' or 'number'.", + extends_clause_already_seen: "'extends' clause already seen.", + extends_clause_must_precede_implements_clause: "'extends' clause must precede 'implements' clause.", + Classes_can_only_extend_a_single_class: "Classes can only extend a single class.", + implements_clause_already_seen: "'implements' clause already seen.", + Accessibility_modifier_already_seen: "Accessibility modifier already seen.", + _0_modifier_must_precede_1_modifier: "'{0}' modifier must precede '{1}' modifier.", + _0_modifier_already_seen: "'{0}' modifier already seen.", + _0_modifier_cannot_appear_on_a_class_element: "'{0}' modifier cannot appear on a class element.", + Interface_declaration_cannot_have_implements_clause: "Interface declaration cannot have 'implements' clause.", + super_invocation_cannot_have_type_arguments: "'super' invocation cannot have type arguments.", + Only_ambient_modules_can_use_quoted_names: "Only ambient modules can use quoted names.", + Statements_are_not_allowed_in_ambient_contexts: "Statements are not allowed in ambient contexts.", + Implementations_are_not_allowed_in_ambient_contexts: "Implementations are not allowed in ambient contexts.", + declare_modifier_not_allowed_for_code_already_in_an_ambient_context: "'declare' modifier not allowed for code already in an ambient context.", + Initializers_are_not_allowed_in_ambient_contexts: "Initializers are not allowed in ambient contexts.", + Parameter_property_declarations_can_only_be_used_in_constructors: "Parameter property declarations can only be used in constructors.", + Function_implementation_expected: "Function implementation expected.", + Constructor_implementation_expected: "Constructor implementation expected.", + Function_overload_name_must_be_0: "Function overload name must be '{0}'.", + _0_modifier_cannot_appear_on_a_module_element: "'{0}' modifier cannot appear on a module element.", + declare_modifier_cannot_appear_on_an_interface_declaration: "'declare' modifier cannot appear on an interface declaration.", + declare_modifier_required_for_top_level_element: "'declare' modifier required for top level element.", + Rest_parameter_cannot_be_optional: "Rest parameter cannot be optional.", + Rest_parameter_cannot_have_an_initializer: "Rest parameter cannot have an initializer.", + set_accessor_must_have_one_and_only_one_parameter: "'set' accessor must have one and only one parameter.", + set_accessor_parameter_cannot_be_optional: "'set' accessor parameter cannot be optional.", + set_accessor_parameter_cannot_have_an_initializer: "'set' accessor parameter cannot have an initializer.", + set_accessor_cannot_have_rest_parameter: "'set' accessor cannot have rest parameter.", + get_accessor_cannot_have_parameters: "'get' accessor cannot have parameters.", + Modifiers_cannot_appear_here: "Modifiers cannot appear here.", + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: "Accessors are only available when targeting ECMAScript 5 and higher.", + Class_name_cannot_be_0: "Class name cannot be '{0}'.", + Interface_name_cannot_be_0: "Interface name cannot be '{0}'.", + Enum_name_cannot_be_0: "Enum name cannot be '{0}'.", + Module_name_cannot_be_0: "Module name cannot be '{0}'.", + Enum_member_must_have_initializer: "Enum member must have initializer.", + Export_assignment_cannot_be_used_in_internal_modules: "Export assignment cannot be used in internal modules.", + Export_assignment_not_allowed_in_module_with_exported_element: "Export assignment not allowed in module with exported element.", + Module_cannot_have_multiple_export_assignments: "Module cannot have multiple export assignments.", + Ambient_enum_elements_can_only_have_integer_literal_initializers: "Ambient enum elements can only have integer literal initializers.", + module_class_interface_enum_import_or_statement: "module, class, interface, enum, import or statement", + constructor_function_accessor_or_variable: "constructor, function, accessor or variable", + statement: "statement", + case_or_default_clause: "case or default clause", + identifier: "identifier", + call_construct_index_property_or_function_signature: "call, construct, index, property or function signature", + expression: "expression", + type_name: "type name", + property_or_accessor: "property or accessor", + parameter: "parameter", + type: "type", + type_parameter: "type parameter", + declare_modifier_not_allowed_on_import_declaration: "'declare' modifier not allowed on import declaration.", + Function_overload_must_be_static: "Function overload must be static.", + Function_overload_must_not_be_static: "Function overload must not be static.", + Parameter_property_declarations_cannot_be_used_in_an_ambient_context: "Parameter property declarations cannot be used in an ambient context.", + Parameter_property_declarations_cannot_be_used_in_a_constructor_overload: "Parameter property declarations cannot be used in a constructor overload.", + Invalid_reference_directive_syntax: "Invalid 'reference' directive syntax.", + Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: "Octal literals are not available when targeting ECMAScript 5 and higher.", + Accessors_are_not_allowed_in_ambient_contexts: "Accessors are not allowed in ambient contexts.", + _0_modifier_cannot_appear_on_a_constructor_declaration: "'{0}' modifier cannot appear on a constructor declaration.", + _0_modifier_cannot_appear_on_a_parameter: "'{0}' modifier cannot appear on a parameter.", + Duplicate_identifier_0: "Duplicate identifier '{0}'.", + The_name_0_does_not_exist_in_the_current_scope: "The name '{0}' does not exist in the current scope.", + The_name_0_does_not_refer_to_a_value: "The name '{0}' does not refer to a value.", + super_can_only_be_used_inside_a_class_instance_method: "'super' can only be used inside a class instance method.", + The_left_hand_side_of_an_assignment_expression_must_be_a_variable_property_or_indexer: "The left-hand side of an assignment expression must be a variable, property or indexer.", + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: "Value of type '{0}' is not callable. Did you mean to include 'new'?", + Value_of_type_0_is_not_callable: "Value of type '{0}' is not callable.", + Value_of_type_0_is_not_newable: "Value of type '{0}' is not newable.", + Value_of_type_0_is_not_indexable_by_type_1: "Value of type '{0}' is not indexable by type '{1}'.", + Operator_0_cannot_be_applied_to_types_1_and_2: "Operator '{0}' cannot be applied to types '{1}' and '{2}'.", + Operator_0_cannot_be_applied_to_types_1_and_2_3: "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}", + Cannot_convert_0_to_1: "Cannot convert '{0}' to '{1}'.", + Cannot_convert_0_to_1_NL_2: "Cannot convert '{0}' to '{1}':{NL}{2}", + Expected_var_class_interface_or_module: "Expected var, class, interface, or module.", + Operator_0_cannot_be_applied_to_type_1: "Operator '{0}' cannot be applied to type '{1}'.", + Getter_0_already_declared: "Getter '{0}' already declared.", + Setter_0_already_declared: "Setter '{0}' already declared.", + Exported_class_0_extends_private_class_1: "Exported class '{0}' extends private class '{1}'.", + Exported_class_0_implements_private_interface_1: "Exported class '{0}' implements private interface '{1}'.", + Exported_interface_0_extends_private_interface_1: "Exported interface '{0}' extends private interface '{1}'.", + Exported_class_0_extends_class_from_inaccessible_module_1: "Exported class '{0}' extends class from inaccessible module {1}.", + Exported_class_0_implements_interface_from_inaccessible_module_1: "Exported class '{0}' implements interface from inaccessible module {1}.", + Exported_interface_0_extends_interface_from_inaccessible_module_1: "Exported interface '{0}' extends interface from inaccessible module {1}.", + Public_static_property_0_of_exported_class_has_or_is_using_private_type_1: "Public static property '{0}' of exported class has or is using private type '{1}'.", + Public_property_0_of_exported_class_has_or_is_using_private_type_1: "Public property '{0}' of exported class has or is using private type '{1}'.", + Property_0_of_exported_interface_has_or_is_using_private_type_1: "Property '{0}' of exported interface has or is using private type '{1}'.", + Exported_variable_0_has_or_is_using_private_type_1: "Exported variable '{0}' has or is using private type '{1}'.", + Public_static_property_0_of_exported_class_is_using_inaccessible_module_1: "Public static property '{0}' of exported class is using inaccessible module {1}.", + Public_property_0_of_exported_class_is_using_inaccessible_module_1: "Public property '{0}' of exported class is using inaccessible module {1}.", + Property_0_of_exported_interface_is_using_inaccessible_module_1: "Property '{0}' of exported interface is using inaccessible module {1}.", + Exported_variable_0_is_using_inaccessible_module_1: "Exported variable '{0}' is using inaccessible module {1}.", + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.", + Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.", + Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.", + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.", + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.", + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.", + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "Parameter '{0}' of public method from exported class has or is using private type '{1}'.", + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "Parameter '{0}' of method from exported interface has or is using private type '{1}'.", + Parameter_0_of_exported_function_has_or_is_using_private_type_1: "Parameter '{0}' of exported function has or is using private type '{1}'.", + Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.", + Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.", + Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.", + Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.", + Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}", + Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.", + Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "Parameter '{0}' of public method from exported class is using inaccessible module {1}.", + Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "Parameter '{0}' of method from exported interface is using inaccessible module {1}.", + Parameter_0_of_exported_function_is_using_inaccessible_module_1: "Parameter '{0}' of exported function is using inaccessible module {1}.", + Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public static property getter from exported class has or is using private type '{0}'.", + Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0: "Return type of public property getter from exported class has or is using private type '{0}'.", + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of constructor signature from exported interface has or is using private type '{0}'.", + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of call signature from exported interface has or is using private type '{0}'.", + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0: "Return type of index signature from exported interface has or is using private type '{0}'.", + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public static method from exported class has or is using private type '{0}'.", + Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0: "Return type of public method from exported class has or is using private type '{0}'.", + Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0: "Return type of method from exported interface has or is using private type '{0}'.", + Return_type_of_exported_function_has_or_is_using_private_type_0: "Return type of exported function has or is using private type '{0}'.", + Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public static property getter from exported class is using inaccessible module {0}.", + Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0: "Return type of public property getter from exported class is using inaccessible module {0}.", + Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of constructor signature from exported interface is using inaccessible module {0}.", + Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of call signature from exported interface is using inaccessible module {0}.", + Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0: "Return type of index signature from exported interface is using inaccessible module {0}.", + Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public static method from exported class is using inaccessible module {0}.", + Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0: "Return type of public method from exported class is using inaccessible module {0}.", + Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0: "Return type of method from exported interface is using inaccessible module {0}.", + Return_type_of_exported_function_is_using_inaccessible_module_0: "Return type of exported function is using inaccessible module {0}.", + new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: "'new T[]' cannot be used to create an array. Use 'new Array()' instead.", + A_parameter_list_must_follow_a_generic_type_argument_list_expected: "A parameter list must follow a generic type argument list. '(' expected.", + Multiple_constructor_implementations_are_not_allowed: "Multiple constructor implementations are not allowed.", + Unable_to_resolve_external_module_0: "Unable to resolve external module '{0}'.", + Module_cannot_be_aliased_to_a_non_module_type: "Module cannot be aliased to a non-module type.", + A_class_may_only_extend_another_class: "A class may only extend another class.", + A_class_may_only_implement_another_class_or_interface: "A class may only implement another class or interface.", + An_interface_may_only_extend_another_class_or_interface: "An interface may only extend another class or interface.", + Unable_to_resolve_type: "Unable to resolve type.", + Unable_to_resolve_type_of_0: "Unable to resolve type of '{0}'.", + Unable_to_resolve_type_parameter_constraint: "Unable to resolve type parameter constraint.", + Type_parameter_constraint_cannot_be_a_primitive_type: "Type parameter constraint cannot be a primitive type.", + Supplied_parameters_do_not_match_any_signature_of_call_target: "Supplied parameters do not match any signature of call target.", + Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0: "Supplied parameters do not match any signature of call target:{NL}{0}", + Invalid_new_expression: "Invalid 'new' expression.", + Call_signatures_used_in_a_new_expression_must_have_a_void_return_type: "Call signatures used in a 'new' expression must have a 'void' return type.", + Could_not_select_overload_for_new_expression: "Could not select overload for 'new' expression.", + Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2: "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.", + Could_not_select_overload_for_call_expression: "Could not select overload for 'call' expression.", + Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: "Cannot invoke an expression whose type lacks a call signature.", + Calls_to_super_are_only_valid_inside_a_class: "Calls to 'super' are only valid inside a class.", + Generic_type_0_requires_1_type_argument_s: "Generic type '{0}' requires {1} type argument(s).", + Type_of_array_literal_cannot_be_determined_Best_common_type_could_not_be_found_for_array_elements: "Type of array literal cannot be determined. Best common type could not be found for array elements.", + Could_not_find_enclosing_symbol_for_dotted_name_0: "Could not find enclosing symbol for dotted name '{0}'.", + The_property_0_does_not_exist_on_value_of_type_1: "The property '{0}' does not exist on value of type '{1}'.", + Could_not_find_symbol_0: "Could not find symbol '{0}'.", + get_and_set_accessor_must_have_the_same_type: "'get' and 'set' accessor must have the same type.", + this_cannot_be_referenced_in_current_location: "'this' cannot be referenced in current location.", + Static_methods_cannot_reference_class_type_parameters: "Static methods cannot reference class type parameters.", + Class_0_is_recursively_referenced_as_a_base_type_of_itself: "Class '{0}' is recursively referenced as a base type of itself.", + Interface_0_is_recursively_referenced_as_a_base_type_of_itself: "Interface '{0}' is recursively referenced as a base type of itself.", + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.", + super_cannot_be_referenced_in_non_derived_classes: "'super' cannot be referenced in non-derived classes.", + A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.", + Constructors_for_derived_classes_must_contain_a_super_call: "Constructors for derived classes must contain a 'super' call.", + Super_calls_are_not_permitted_outside_constructors_or_in_local_functions_inside_constructors: "Super calls are not permitted outside constructors or in local functions inside constructors.", + _0_1_is_inaccessible: "'{0}.{1}' is inaccessible.", + this_cannot_be_referenced_within_module_bodies: "'this' cannot be referenced within module bodies.", + Invalid_expression_types_not_known_to_support_the_addition_operator: "Invalid '+' expression - types not known to support the addition operator.", + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.", + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.", + The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type: "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.", + Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation: "Variable declarations of a 'for' statement cannot use a type annotation.", + Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any: "Variable declarations of a 'for' statement must be of types 'string' or 'any'.", + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.", + The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number: "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.", + The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.", + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.", + The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_a_subtype_of_the_Function_interface_type: "The right-hand side of an 'instanceof' expression must be of type 'any' or a subtype of the 'Function' interface type.", + Setters_cannot_return_a_value: "Setters cannot return a value.", + Tried_to_query_type_of_uninitialized_module_0: "Tried to query type of uninitialized module '{0}'.", + Tried_to_set_variable_type_to_uninitialized_module_type_0: "Tried to set variable type to uninitialized module type '{0}'.", + Function_0_declared_a_non_void_return_type_but_has_no_return_expression: "Function '{0}' declared a non-void return type, but has no return expression.", + Getters_must_return_a_value: "Getters must return a value.", + Getter_and_setter_accessors_do_not_agree_in_visibility: "Getter and setter accessors do not agree in visibility.", + Invalid_left_hand_side_of_assignment_expression: "Invalid left-hand side of assignment expression.", + Function_declared_a_non_void_return_type_but_has_no_return_expression: "Function declared a non-void return type, but has no return expression.", + Cannot_resolve_return_type_reference: "Cannot resolve return type reference.", + Constructors_cannot_have_a_return_type_of_void: "Constructors cannot have a return type of 'void'.", + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'.", + All_symbols_within_a_with_block_will_be_resolved_to_any: "All symbols within a with block will be resolved to 'any'.", + Import_declarations_in_an_internal_module_cannot_reference_an_external_module: "Import declarations in an internal module cannot reference an external module.", + Class_0_declares_interface_1_but_does_not_implement_it_NL_2: "Class {0} declares interface {1} but does not implement it:{NL}{2}", + Class_0_declares_class_1_as_an_interface_but_does_not_implement_it_NL_2: "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}", + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: "The operand of an increment or decrement operator must be a variable, property or indexer.", + this_cannot_be_referenced_in_static_initializers_in_a_class_body: "'this' cannot be referenced in static initializers in a class body.", + Class_0_cannot_extend_class_1_NL_2: "Class '{0}' cannot extend class '{1}':{NL}{2}", + Interface_0_cannot_extend_class_1_NL_2: "Interface '{0}' cannot extend class '{1}':{NL}{2}", + Interface_0_cannot_extend_interface_1_NL_2: "Interface '{0}' cannot extend interface '{1}':{NL}{2}", + Duplicate_overload_signature_for_0: "Duplicate overload signature for '{0}'.", + Duplicate_constructor_overload_signature: "Duplicate constructor overload signature.", + Duplicate_overload_call_signature: "Duplicate overload call signature.", + Duplicate_overload_construct_signature: "Duplicate overload construct signature.", + Overload_signature_is_not_compatible_with_function_definition: "Overload signature is not compatible with function definition.", + Overload_signature_is_not_compatible_with_function_definition_NL_0: "Overload signature is not compatible with function definition:{NL}{0}", + Overload_signatures_must_all_be_public_or_private: "Overload signatures must all be public or private.", + Overload_signatures_must_all_be_exported_or_not_exported: "Overload signatures must all be exported or not exported.", + Overload_signatures_must_all_be_ambient_or_non_ambient: "Overload signatures must all be ambient or non-ambient.", + Overload_signatures_must_all_be_optional_or_required: "Overload signatures must all be optional or required.", + Specialized_overload_signature_is_not_subtype_of_any_non_specialized_signature: "Specialized overload signature is not subtype of any non-specialized signature.", + this_cannot_be_referenced_in_constructor_arguments: "'this' cannot be referenced in constructor arguments.", + Instance_member_cannot_be_accessed_off_a_class: "Instance member cannot be accessed off a class.", + Untyped_function_calls_may_not_accept_type_arguments: "Untyped function calls may not accept type arguments.", + Non_generic_functions_may_not_accept_type_arguments: "Non-generic functions may not accept type arguments.", + A_generic_type_may_not_reference_itself_with_a_wrapped_form_of_its_own_type_parameters: "A generic type may not reference itself with a wrapped form of its own type parameters.", + Rest_parameters_must_be_array_types: "Rest parameters must be array types.", + Overload_signature_implementation_cannot_use_specialized_type: "Overload signature implementation cannot use specialized type.", + Export_assignments_may_only_be_used_at_the_top_level_of_external_modules: "Export assignments may only be used at the top-level of external modules.", + Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.", + Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword: "Only public methods of the base class are accessible via the 'super' keyword.", + Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1: "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}'.", + Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1_NL_2: "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}':{NL}{2}", + All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0: "All numerically named properties must be subtypes of numeric indexer type '{0}'.", + All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0_NL_1: "All numerically named properties must be subtypes of numeric indexer type '{0}':{NL}{1}", + All_named_properties_must_be_subtypes_of_string_indexer_type_0: "All named properties must be subtypes of string indexer type '{0}'.", + All_named_properties_must_be_subtypes_of_string_indexer_type_0_NL_1: "All named properties must be subtypes of string indexer type '{0}':{NL}{1}", + Generic_type_references_must_include_all_type_arguments: "Generic type references must include all type arguments.", + Default_arguments_are_not_allowed_in_an_overload_parameter: "Default arguments are not allowed in an overload parameter.", + Overloads_cannot_differ_only_by_return_type: "Overloads cannot differ only by return type.", + Function_expression_declared_a_non_void_return_type_but_has_no_return_expression: "Function expression declared a non-void return type, but has no return expression.", + Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules: "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.", + Could_not_find_symbol_0_in_module_1: "Could not find symbol '{0}' in module '{1}'.", + Unable_to_resolve_module_reference_0: "Unable to resolve module reference '{0}'.", + Could_not_find_module_0_in_module_1: "Could not find module '{0}' in module '{1}'.", + Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.", + Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.", + Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1: "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.", + Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.", + Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1: "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.", + Type_reference_0_in_extends_clause_does_not_reference_constructor_function_for_1: "Type reference '{0}' in extends clause does not reference constructor function for '{1}'.", + Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1: "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.", + Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2: "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.", + Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}", + Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.", + Ambient_external_module_declaration_cannot_be_reopened: "Ambient external module declaration cannot be reopened.", + All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported: "All declarations of merged declaration '{0}' must be exported or not exported.", + super_cannot_be_referenced_in_constructor_arguments: "'super' cannot be referenced in constructor arguments.", + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: "Return type of constructor signature must be assignable to the instance type of the class.", + Ambient_external_module_declaration_must_be_defined_in_global_context: "Ambient external module declaration must be defined in global context.", + Ambient_external_module_declaration_cannot_specify_relative_module_name: "Ambient external module declaration cannot specify relative module name.", + Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name: "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.", + Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions: "Could not find the best common type of types of all return statement expressions.", + Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set: "Import declaration cannot refer to external module reference when --noResolve option is set.", + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.", + continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: "'continue' statement can only be used within an enclosing iteration statement.", + break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: "'break' statement can only be used within an enclosing iteration or switch statement.", + Jump_target_not_found: "Jump target not found.", + Jump_target_cannot_cross_function_boundary: "Jump target cannot cross function boundary.", + Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.", + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.", + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: "Expression resolves to '_super' that compiler uses to capture base class reference.", + TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.", + TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.", + TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.", + TypeParameter_0_of_exported_function_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported function has or is using private type '{1}'.", + TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.", + TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}", + TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.", + TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.", + TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.", + TypeParameter_0_of_exported_function_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported function is using inaccessible module {1}.", + TypeParameter_0_of_exported_class_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported class has or is using private type '{1}'.", + TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1: "TypeParameter '{0}' of exported interface has or is using private type '{1}'.", + TypeParameter_0_of_exported_class_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported class is using inaccessible module {1}.", + TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1: "TypeParameter '{0}' of exported interface is using inaccessible module {1}.", + Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter: "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.", + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.", + Type_of_conditional_0_must_be_identical_to_1_or_2: "Type of conditional '{0}' must be identical to '{1}' or '{2}'.", + Type_of_conditional_0_must_be_identical_to_1_2_or_3: "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.", + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.", + Type_0_is_missing_property_1_from_type_2: "Type '{0}' is missing property '{1}' from type '{2}'.", + Types_of_property_0_of_types_1_and_2_are_incompatible: "Types of property '{0}' of types '{1}' and '{2}' are incompatible.", + Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3: "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}", + Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2: "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.", + Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2: "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.", + Types_0_and_1_define_property_2_as_private: "Types '{0}' and '{1}' define property '{2}' as private.", + Call_signatures_of_types_0_and_1_are_incompatible: "Call signatures of types '{0}' and '{1}' are incompatible.", + Call_signatures_of_types_0_and_1_are_incompatible_NL_2: "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Type_0_requires_a_call_signature_but_type_1_lacks_one: "Type '{0}' requires a call signature, but type '{1}' lacks one.", + Construct_signatures_of_types_0_and_1_are_incompatible: "Construct signatures of types '{0}' and '{1}' are incompatible.", + Construct_signatures_of_types_0_and_1_are_incompatible_NL_2: "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Type_0_requires_a_construct_signature_but_type_1_lacks_one: "Type '{0}' requires a construct signature, but type '{1}' lacks one.", + Index_signatures_of_types_0_and_1_are_incompatible: "Index signatures of types '{0}' and '{1}' are incompatible.", + Index_signatures_of_types_0_and_1_are_incompatible_NL_2: "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}", + Call_signature_expects_0_or_fewer_parameters: "Call signature expects {0} or fewer parameters.", + Could_not_apply_type_0_to_argument_1_which_is_of_type_2: "Could not apply type '{0}' to argument {1} which is of type '{2}'.", + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.", + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.", + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.", + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.", + Types_of_static_property_0_of_class_1_and_class_2_are_incompatible: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.", + Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3: "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}", + Type_reference_cannot_refer_to_container_0: "Type reference cannot refer to container '{0}'.", + Type_reference_must_refer_to_type: "Type reference must refer to type.", + Enums_with_multiple_declarations_must_provide_an_initializer_for_the_first_enum_element: "Enums with multiple declarations must provide an initializer for the first enum element.", + _0_overload_s: " (+ {0} overload(s))", + Variable_declaration_cannot_have_the_same_name_as_an_import_declaration: "Variable declaration cannot have the same name as an import declaration.", + Signature_expected_0_type_arguments_got_1_instead: "Signature expected {0} type arguments, got {1} instead.", + Property_0_defined_as_optional_in_type_1_but_is_required_in_type_2: "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_do_not_refer_to_same_named_type: "Types '{0}' and '{1}' originating in inifinitely expanding type reference do not refer to same named type.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments: "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments.", + Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2: "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments:{NL}{2}", + Types_of_property_0_of_types_1_and_2_are_not_identical: "Types of property '{0}' of types '{1}' and '{2}' are not identical.", + Types_of_string_indexer_of_types_0_and_1_are_not_identical: "Types of string indexer of types '{0}' and '{1}' are not identical.", + Types_of_number_indexer_of_types_0_and_1_are_not_identical: "Types of number indexer of types '{0}' and '{1}' are not identical.", + Type_of_number_indexer_in_type_0_is_not_a_subtype_of_string_indexer_type_in_type_1_NL_2: "Type of number indexer in type '{0}' is not a subtype of string indexer type in type '{1}'.{NL}{2}", + Type_of_property_0_in_type_1_is_not_a_subtype_of_string_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not a subtype of string indexer type in type '{2}'.{NL}{3}", + Type_of_property_0_in_type_1_is_not_a_subtype_of_number_indexer_type_in_type_2_NL_3: "Type of property '{0}' in type '{1}' is not a subtype of number indexer type in type '{2}'.{NL}{3}", + Current_host_does_not_support_0_option: "Current host does not support '{0}' option.", + ECMAScript_target_version_0_not_supported_Specify_a_valid_target_version_1_default_or_2: "ECMAScript target version '{0}' not supported. Specify a valid target version: '{1}' (default), or '{2}'", + Module_code_generation_0_not_supported: "Module code generation '{0}' not supported.", + Could_not_find_file_0: "Could not find file: '{0}'.", + A_file_cannot_have_a_reference_to_itself: "A file cannot have a reference to itself.", + Cannot_resolve_referenced_file_0: "Cannot resolve referenced file: '{0}'.", + Cannot_find_the_common_subdirectory_path_for_the_input_files: "Cannot find the common subdirectory path for the input files.", + Emit_Error_0: "Emit Error: {0}.", + Cannot_read_file_0_1: "Cannot read file '{0}': {1}", + Unsupported_file_encoding: "Unsupported file encoding.", + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: "Locale must be of the form or -. For example '{0}' or '{1}'.", + Unsupported_locale_0: "Unsupported locale: '{0}'.", + Execution_Failed_NL: "Execution Failed.{NL}", + Invalid_call_to_up: "Invalid call to 'up'", + Invalid_call_to_down: "Invalid call to 'down'", + Base64_value_0_finished_with_a_continuation_bit: "Base64 value '{0}' finished with a continuation bit.", + Unknown_option_0: "Unknown option '{0}'", + Expected_0_arguments_to_message_got_1_instead: "Expected {0} arguments to message, got {1} instead.", + Expected_the_message_0_to_have_1_arguments_but_it_had_2: "Expected the message '{0}' to have {1} arguments, but it had {2}", + Could_not_delete_file_0: "Could not delete file '{0}'", + Could_not_create_directory_0: "Could not create directory '{0}'", + Error_while_executing_file_0: "Error while executing file '{0}': ", + Cannot_compile_external_modules_unless_the_module_flag_is_provided: "Cannot compile external modules unless the '--module' flag is provided.", + Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option mapRoot cannot be specified without specifying sourcemap option.", + Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Option sourceRoot cannot be specified without specifying sourcemap option.", + Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option: "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.", + Option_0_specified_without_1: "Option '{0}' specified without '{1}'", + codepage_option_not_supported_on_current_platform: "'codepage' option not supported on current platform.", + Concatenate_and_emit_output_to_single_file: "Concatenate and emit output to single file.", + Generates_corresponding_0_file: "Generates corresponding {0} file.", + Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: "Specifies the location where debugger should locate map files instead of generated locations.", + Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: "Specifies the location where debugger should locate TypeScript files instead of source locations.", + Watch_input_files: "Watch input files.", + Redirect_output_structure_to_the_directory: "Redirect output structure to the directory.", + Do_not_emit_comments_to_output: "Do not emit comments to output.", + Skip_resolution_and_preprocessing: "Skip resolution and preprocessing.", + Specify_ECMAScript_target_version_0_default_or_1: "Specify ECMAScript target version: '{0}' (default), or '{1}'", + Specify_module_code_generation_0_or_1: "Specify module code generation: '{0}' or '{1}'", + Print_this_message: "Print this message.", + Print_the_compiler_s_version_0: "Print the compiler's version: {0}", + Allow_use_of_deprecated_0_keyword_when_referencing_an_external_module: "Allow use of deprecated '{0}' keyword when referencing an external module.", + Specify_locale_for_errors_and_messages_For_example_0_or_1: "Specify locale for errors and messages. For example '{0}' or '{1}'", + Syntax_0: "Syntax: {0}", + options: "options", + file1: "file", + Examples: "Examples:", + Options: "Options:", + Insert_command_line_options_and_files_from_a_file: "Insert command line options and files from a file.", + Version_0: "Version {0}", + Use_the_0_flag_to_see_options: "Use the '{0}' flag to see options.", + NL_Recompiling_0: "{NL}Recompiling ({0}):", + STRING: "STRING", + KIND: "KIND", + file2: "FILE", + VERSION: "VERSION", + LOCATION: "LOCATION", + DIRECTORY: "DIRECTORY", + NUMBER: "NUMBER", + Specify_the_codepage_to_use_when_opening_source_files: "Specify the codepage to use when opening source files.", + This_version_of_the_Javascript_runtime_does_not_support_the_0_function: "This version of the Javascript runtime does not support the '{0}' function.", + Unknown_rule: "Unknown rule.", + Invalid_line_number_0: "Invalid line number ({0})", + Warn_on_expressions_and_declarations_with_an_implied_any_type: "Warn on expressions and declarations with an implied 'any' type.", + Variable_0_implicitly_has_an_any_type: "Variable '{0}' implicitly has an 'any' type.", + Parameter_0_of_1_implicitly_has_an_any_type: "Parameter '{0}' of '{1}' implicitly has an 'any' type.", + Parameter_0_of_function_type_implicitly_has_an_any_type: "Parameter '{0}' of function type implicitly has an 'any' type.", + Member_0_of_object_type_implicitly_has_an_any_type: "Member '{0}' of object type implicitly has an 'any' type.", + new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type: "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.", + _0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.", + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.", + Parameter_0_of_lambda_function_implicitly_has_an_any_type: "Parameter '{0}' of lambda function implicitly has an 'any' type.", + Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.", + Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.", + Array_Literal_implicitly_has_an_any_type_from_widening: "Array Literal implicitly has an 'any' type from widening.", + _0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type: "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type." + }; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ArrayUtilities = (function () { + function ArrayUtilities() { + } + ArrayUtilities.isArray = function (value) { + return Object.prototype.toString.apply(value, []) === '[object Array]'; + }; + + ArrayUtilities.sequenceEquals = function (array1, array2, equals) { + if (array1 === array2) { + return true; + } + + if (array1 === null || array2 === null) { + return false; + } + + if (array1.length !== array2.length) { + return false; + } + + for (var i = 0, n = array1.length; i < n; i++) { + if (!equals(array1[i], array2[i])) { + return false; + } + } + + return true; + }; + + ArrayUtilities.contains = function (array, value) { + for (var i = 0; i < array.length; i++) { + if (array[i] === value) { + return true; + } + } + + return false; + }; + + ArrayUtilities.groupBy = function (array, func) { + var result = {}; + + for (var i = 0, n = array.length; i < n; i++) { + var v = array[i]; + var k = func(v); + + var list = result[k] || []; + list.push(v); + result[k] = list; + } + + return result; + }; + + ArrayUtilities.distinct = function (array, equalsFn) { + var result = []; + + for (var i = 0, n = array.length; i < n; i++) { + var current = array[i]; + for (var j = 0; j < result.length; j++) { + if (equalsFn(result[j], current)) { + break; + } + } + + if (j === result.length) { + result.push(current); + } + } + + return result; + }; + + ArrayUtilities.min = function (array, func) { + var min = func(array[0]); + + for (var i = 1; i < array.length; i++) { + var next = func(array[i]); + if (next < min) { + min = next; + } + } + + return min; + }; + + ArrayUtilities.max = function (array, func) { + var max = func(array[0]); + + for (var i = 1; i < array.length; i++) { + var next = func(array[i]); + if (next > max) { + max = next; + } + } + + return max; + }; + + ArrayUtilities.last = function (array) { + if (array.length === 0) { + throw TypeScript.Errors.argumentOutOfRange('array'); + } + + return array[array.length - 1]; + }; + + ArrayUtilities.lastOrDefault = function (array, predicate) { + for (var i = array.length - 1; i >= 0; i--) { + var v = array[i]; + if (predicate(v, i)) { + return v; + } + } + + return null; + }; + + ArrayUtilities.firstOrDefault = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + var value = array[i]; + if (func(value, i)) { + return value; + } + } + + return null; + }; + + ArrayUtilities.first = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + var value = array[i]; + if (!func || func(value, i)) { + return value; + } + } + + throw TypeScript.Errors.invalidOperation(); + }; + + ArrayUtilities.sum = function (array, func) { + var result = 0; + + for (var i = 0, n = array.length; i < n; i++) { + result += func(array[i]); + } + + return result; + }; + + ArrayUtilities.select = function (values, func) { + var result = new Array(values.length); + + for (var i = 0; i < values.length; i++) { + result[i] = func(values[i]); + } + + return result; + }; + + ArrayUtilities.where = function (values, func) { + var result = new Array(); + + for (var i = 0; i < values.length; i++) { + if (func(values[i])) { + result.push(values[i]); + } + } + + return result; + }; + + ArrayUtilities.any = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + if (func(array[i])) { + return true; + } + } + + return false; + }; + + ArrayUtilities.all = function (array, func) { + for (var i = 0, n = array.length; i < n; i++) { + if (!func(array[i])) { + return false; + } + } + + return true; + }; + + ArrayUtilities.binarySearch = function (array, value) { + var low = 0; + var high = array.length - 1; + + while (low <= high) { + var middle = low + ((high - low) >> 1); + var midValue = array[middle]; + + if (midValue === value) { + return middle; + } else if (midValue > value) { + high = middle - 1; + } else { + low = middle + 1; + } + } + + return ~low; + }; + + ArrayUtilities.createArray = function (length, defaultValue) { + var result = new Array(length); + for (var i = 0; i < length; i++) { + result[i] = defaultValue; + } + + return result; + }; + + ArrayUtilities.grow = function (array, length, defaultValue) { + var count = length - array.length; + for (var i = 0; i < count; i++) { + array.push(defaultValue); + } + }; + + ArrayUtilities.copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) { + for (var i = 0; i < length; i++) { + destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i]; + } + }; + + ArrayUtilities.indexOf = function (array, predicate) { + for (var i = 0, n = array.length; i < n; i++) { + if (predicate(array[i])) { + return i; + } + } + + return -1; + }; + return ArrayUtilities; + })(); + TypeScript.ArrayUtilities = ArrayUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (BitVector) { + var pool = []; + var Constants; + (function (Constants) { + Constants[Constants["MaxBitsPerEncodedNumber"] = 30] = "MaxBitsPerEncodedNumber"; + Constants[Constants["BitsPerEncodedBiStateValue"] = 1] = "BitsPerEncodedBiStateValue"; + + Constants[Constants["BitsPerEncodedTriStateValue"] = 2] = "BitsPerEncodedTriStateValue"; + + Constants[Constants["BiStateEncodedTrue"] = 1] = "BiStateEncodedTrue"; + Constants[Constants["BiStateClearBitsMask"] = 1] = "BiStateClearBitsMask"; + + Constants[Constants["TriStateEncodedFalse"] = 1] = "TriStateEncodedFalse"; + Constants[Constants["TriStateEncodedTrue"] = 2] = "TriStateEncodedTrue"; + Constants[Constants["TriStateClearBitsMask"] = 3] = "TriStateClearBitsMask"; + })(Constants || (Constants = {})); + + var BitVectorImpl = (function () { + function BitVectorImpl(allowUndefinedValues) { + this.allowUndefinedValues = allowUndefinedValues; + this.isReleased = false; + this.bits = []; + } + BitVectorImpl.prototype.computeTriStateArrayIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */; + + return (index / encodedValuesPerNumber) >>> 0; + }; + + BitVectorImpl.prototype.computeBiStateArrayIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */; + + return (index / encodedValuesPerNumber) >>> 0; + }; + + BitVectorImpl.prototype.computeTriStateEncodedValueIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 2 /* BitsPerEncodedTriStateValue */; + + return (index % encodedValuesPerNumber) * 2 /* BitsPerEncodedTriStateValue */; + }; + + BitVectorImpl.prototype.computeBiStateEncodedValueIndex = function (index) { + var encodedValuesPerNumber = 30 /* MaxBitsPerEncodedNumber */ / 1 /* BitsPerEncodedBiStateValue */; + + return (index % encodedValuesPerNumber) * 1 /* BitsPerEncodedBiStateValue */; + }; + + BitVectorImpl.prototype.valueAt = function (index) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + if (this.allowUndefinedValues) { + var arrayIndex = this.computeTriStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + return undefined; + } + + var bitIndex = this.computeTriStateEncodedValueIndex(index); + if (encoded & (2 /* TriStateEncodedTrue */ << bitIndex)) { + return true; + } else if (encoded & (1 /* TriStateEncodedFalse */ << bitIndex)) { + return false; + } else { + return undefined; + } + } else { + var arrayIndex = this.computeBiStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + return false; + } + + var bitIndex = this.computeBiStateEncodedValueIndex(index); + if (encoded & (1 /* BiStateEncodedTrue */ << bitIndex)) { + return true; + } else { + return false; + } + } + }; + + BitVectorImpl.prototype.setValueAt = function (index, value) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + if (this.allowUndefinedValues) { + TypeScript.Debug.assert(value === true || value === false || value === undefined, "value must only be true, false or undefined."); + + var arrayIndex = this.computeTriStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + if (value === undefined) { + return; + } + + encoded = 0; + } + + var bitIndex = this.computeTriStateEncodedValueIndex(index); + + var clearMask = ~(3 /* TriStateClearBitsMask */ << bitIndex); + encoded = encoded & clearMask; + + if (value === true) { + encoded = encoded | (2 /* TriStateEncodedTrue */ << bitIndex); + } else if (value === false) { + encoded = encoded | (1 /* TriStateEncodedFalse */ << bitIndex); + } + + this.bits[arrayIndex] = encoded; + } else { + TypeScript.Debug.assert(value === true || value === false, "value must only be true or false."); + + var arrayIndex = this.computeBiStateArrayIndex(index); + var encoded = this.bits[arrayIndex]; + if (encoded === undefined) { + if (value === false) { + return; + } + + encoded = 0; + } + + var bitIndex = this.computeBiStateEncodedValueIndex(index); + + encoded = encoded & ~(1 /* BiStateClearBitsMask */ << bitIndex); + + if (value) { + encoded = encoded | (1 /* BiStateEncodedTrue */ << bitIndex); + } + + this.bits[arrayIndex] = encoded; + } + }; + + BitVectorImpl.prototype.release = function () { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + this.isReleased = true; + this.bits.length = 0; + pool.push(this); + }; + return BitVectorImpl; + })(); + + function getBitVector(allowUndefinedValues) { + if (pool.length === 0) { + return new BitVectorImpl(allowUndefinedValues); + } + + var vector = pool.pop(); + vector.isReleased = false; + vector.allowUndefinedValues = allowUndefinedValues; + + return vector; + } + BitVector.getBitVector = getBitVector; + })(TypeScript.BitVector || (TypeScript.BitVector = {})); + var BitVector = TypeScript.BitVector; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (BitMatrix) { + var pool = []; + + var BitMatrixImpl = (function () { + function BitMatrixImpl(allowUndefinedValues) { + this.allowUndefinedValues = allowUndefinedValues; + this.isReleased = false; + this.vectors = []; + } + BitMatrixImpl.prototype.valueAt = function (x, y) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + var vector = this.vectors[x]; + if (!vector) { + return this.allowUndefinedValues ? undefined : false; + } + + return vector.valueAt(y); + }; + + BitMatrixImpl.prototype.setValueAt = function (x, y, value) { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + var vector = this.vectors[x]; + if (!vector) { + if (value === undefined) { + return; + } + + vector = TypeScript.BitVector.getBitVector(this.allowUndefinedValues); + this.vectors[x] = vector; + } + + vector.setValueAt(y, value); + }; + + BitMatrixImpl.prototype.release = function () { + TypeScript.Debug.assert(!this.isReleased, "Should not use a released bitvector"); + this.isReleased = true; + + for (var name in this.vectors) { + if (this.vectors.hasOwnProperty(name)) { + var vector = this.vectors[name]; + vector.release(); + } + } + + this.vectors.length = 0; + pool.push(this); + }; + return BitMatrixImpl; + })(); + + function getBitMatrix(allowUndefinedValues) { + if (pool.length === 0) { + return new BitMatrixImpl(allowUndefinedValues); + } + + var matrix = pool.pop(); + matrix.isReleased = false; + matrix.allowUndefinedValues = allowUndefinedValues; + + return matrix; + } + BitMatrix.getBitMatrix = getBitMatrix; + })(TypeScript.BitMatrix || (TypeScript.BitMatrix = {})); + var BitMatrix = TypeScript.BitMatrix; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Constants) { + Constants[Constants["Max31BitInteger"] = 1073741823] = "Max31BitInteger"; + Constants[Constants["Min31BitInteger"] = -1073741824] = "Min31BitInteger"; + })(TypeScript.Constants || (TypeScript.Constants = {})); + var Constants = TypeScript.Constants; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (AssertionLevel) { + AssertionLevel[AssertionLevel["None"] = 0] = "None"; + AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal"; + AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive"; + AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive"; + })(TypeScript.AssertionLevel || (TypeScript.AssertionLevel = {})); + var AssertionLevel = TypeScript.AssertionLevel; + + var Debug = (function () { + function Debug() { + } + Debug.shouldAssert = function (level) { + return this.currentAssertionLevel >= level; + }; + + Debug.assert = function (expression, message, verboseDebugInfo) { + if (typeof message === "undefined") { message = ""; } + if (typeof verboseDebugInfo === "undefined") { verboseDebugInfo = null; } + if (!expression) { + var verboseDebugString = ""; + if (verboseDebugInfo) { + verboseDebugString = "\r\nVerbose Debug Information:" + verboseDebugInfo(); + } + + throw new Error("Debug Failure. False expression: " + message + verboseDebugString); + } + }; + + Debug.fail = function (message) { + Debug.assert(false, message); + }; + Debug.currentAssertionLevel = 0 /* None */; + return Debug; + })(); + TypeScript.Debug = Debug; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.LocalizedDiagnosticMessages = null; + + var Diagnostic = (function () { + function Diagnostic(fileName, lineMap, start, length, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + this._diagnosticKey = diagnosticKey; + this._arguments = (arguments && arguments.length > 0) ? arguments : null; + this._fileName = fileName; + this._lineMap = lineMap; + this._start = start; + this._length = length; + } + Diagnostic.prototype.toJSON = function (key) { + var result = {}; + result.start = this.start(); + result.length = this.length(); + + result.diagnosticCode = this._diagnosticKey; + + var arguments = this.arguments(); + if (arguments && arguments.length > 0) { + result.arguments = arguments; + } + + return result; + }; + + Diagnostic.prototype.fileName = function () { + return this._fileName; + }; + + Diagnostic.prototype.line = function () { + return this._lineMap ? this._lineMap.getLineNumberFromPosition(this.start()) : 0; + }; + + Diagnostic.prototype.character = function () { + return this._lineMap ? this._lineMap.getLineAndCharacterFromPosition(this.start()).character() : 0; + }; + + Diagnostic.prototype.start = function () { + return this._start; + }; + + Diagnostic.prototype.length = function () { + return this._length; + }; + + Diagnostic.prototype.diagnosticKey = function () { + return this._diagnosticKey; + }; + + Diagnostic.prototype.arguments = function () { + return this._arguments; + }; + + Diagnostic.prototype.text = function () { + return TypeScript.getLocalizedText(this._diagnosticKey, this._arguments); + }; + + Diagnostic.prototype.message = function () { + return TypeScript.getDiagnosticMessage(this._diagnosticKey, this._arguments); + }; + + Diagnostic.prototype.additionalLocations = function () { + return []; + }; + + Diagnostic.equals = function (diagnostic1, diagnostic2) { + return diagnostic1._fileName === diagnostic2._fileName && diagnostic1._start === diagnostic2._start && diagnostic1._length === diagnostic2._length && diagnostic1._diagnosticKey === diagnostic2._diagnosticKey && TypeScript.ArrayUtilities.sequenceEquals(diagnostic1._arguments, diagnostic2._arguments, function (v1, v2) { + return v1 === v2; + }); + }; + + Diagnostic.prototype.info = function () { + return getDiagnosticInfoFromKey(this.diagnosticKey()); + }; + return Diagnostic; + })(); + TypeScript.Diagnostic = Diagnostic; + + function newLine() { + return TypeScript.Environment ? TypeScript.Environment.newLine : "\r\n"; + } + TypeScript.newLine = newLine; + + function getLargestIndex(diagnostic) { + var largest = -1; + var regex = /\{(\d+)\}/g; + + var match; + while ((match = regex.exec(diagnostic)) != null) { + var val = parseInt(match[1]); + if (!isNaN(val) && val > largest) { + largest = val; + } + } + + return largest; + } + + function getDiagnosticInfoFromKey(diagnosticKey) { + var result = TypeScript.diagnosticInformationMap[diagnosticKey]; + TypeScript.Debug.assert(result); + return result; + } + + function getLocalizedText(diagnosticKey, args) { + if (TypeScript.LocalizedDiagnosticMessages) { + } + + var diagnosticMessageText = TypeScript.LocalizedDiagnosticMessages ? TypeScript.LocalizedDiagnosticMessages[diagnosticKey] : diagnosticKey; + TypeScript.Debug.assert(diagnosticMessageText !== undefined && diagnosticMessageText !== null); + + var actualCount = args ? args.length : 0; + + var expectedCount = 1 + getLargestIndex(diagnosticKey); + + if (expectedCount !== actualCount) { + throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_0_arguments_to_message_got_1_instead, [expectedCount, actualCount])); + } + + var valueCount = 1 + getLargestIndex(diagnosticMessageText); + if (valueCount !== expectedCount) { + throw new Error(getLocalizedText(TypeScript.DiagnosticCode.Expected_the_message_0_to_have_1_arguments_but_it_had_2, [diagnosticMessageText, expectedCount, valueCount])); + } + + diagnosticMessageText = diagnosticMessageText.replace(/{(\d+)}/g, function (match, num) { + return typeof args[num] !== 'undefined' ? args[num] : match; + }); + + diagnosticMessageText = diagnosticMessageText.replace(/{(NL)}/g, function (match) { + return TypeScript.newLine(); + }); + + return diagnosticMessageText; + } + TypeScript.getLocalizedText = getLocalizedText; + + function getDiagnosticMessage(diagnosticKey, args) { + var diagnostic = getDiagnosticInfoFromKey(diagnosticKey); + var diagnosticMessageText = getLocalizedText(diagnosticKey, args); + + var message; + if (diagnostic.category === 1 /* Error */) { + message = getLocalizedText(TypeScript.DiagnosticCode.error_TS_0_1, [diagnostic.code, diagnosticMessageText]); + } else if (diagnostic.category === 0 /* Warning */) { + message = getLocalizedText(TypeScript.DiagnosticCode.warning_TS_0_1, [diagnostic.code, diagnosticMessageText]); + } else { + message = diagnosticMessageText; + } + + return message; + } + TypeScript.getDiagnosticMessage = getDiagnosticMessage; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Errors = (function () { + function Errors() { + } + Errors.argument = function (argument, message) { + return new Error("Invalid argument: " + argument + ". " + message); + }; + + Errors.argumentOutOfRange = function (argument) { + return new Error("Argument out of range: " + argument); + }; + + Errors.argumentNull = function (argument) { + return new Error("Argument null: " + argument); + }; + + Errors.abstract = function () { + return new Error("Operation not implemented properly by subclass."); + }; + + Errors.notYetImplemented = function () { + return new Error("Not yet implemented."); + }; + + Errors.invalidOperation = function (message) { + return new Error("Invalid operation: " + message); + }; + return Errors; + })(); + TypeScript.Errors = Errors; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Hash = (function () { + function Hash() { + } + Hash.computeFnv1aCharArrayHashCode = function (text, start, len) { + var hashCode = Hash.FNV_BASE; + var end = start + len; + + for (var i = start; i < end; i++) { + hashCode = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(hashCode ^ text[i], Hash.FNV_PRIME); + } + + return hashCode; + }; + + Hash.computeSimple31BitCharArrayHashCode = function (key, start, len) { + var hash = 0; + + for (var i = 0; i < len; i++) { + var ch = key[start + i]; + + hash = ((((hash << 5) - hash) | 0) + ch) | 0; + } + + return hash & 0x7FFFFFFF; + }; + + Hash.computeSimple31BitStringHashCode = function (key) { + var hash = 0; + + var start = 0; + var len = key.length; + + for (var i = 0; i < len; i++) { + var ch = key.charCodeAt(start + i); + + hash = ((((hash << 5) - hash) | 0) + ch) | 0; + } + + return hash & 0x7FFFFFFF; + }; + + Hash.computeMurmur2StringHashCode = function (key, seed) { + var m = 0x5bd1e995; + var r = 24; + + var numberOfCharsLeft = key.length; + var h = Math.abs(seed ^ numberOfCharsLeft); + + var index = 0; + while (numberOfCharsLeft >= 2) { + var c1 = key.charCodeAt(index); + var c2 = key.charCodeAt(index + 1); + + var k = Math.abs(c1 | (c2 << 16)); + + k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m); + k ^= k >> r; + k = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(k, m); + + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + h ^= k; + + index += 2; + numberOfCharsLeft -= 2; + } + + if (numberOfCharsLeft == 1) { + h ^= key.charCodeAt(index); + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + } + + h ^= h >> 13; + h = TypeScript.IntegerUtilities.integerMultiplyLow32Bits(h, m); + h ^= h >> 15; + + return h; + }; + + Hash.getPrime = function (min) { + for (var i = 0; i < Hash.primes.length; i++) { + var num = Hash.primes[i]; + if (num >= min) { + return num; + } + } + + throw TypeScript.Errors.notYetImplemented(); + }; + + Hash.expandPrime = function (oldSize) { + var num = oldSize << 1; + if (num > 2146435069 && 2146435069 > oldSize) { + return 2146435069; + } + return Hash.getPrime(num); + }; + + Hash.combine = function (value, currentHash) { + return (((currentHash << 5) + currentHash) + value) & 0x7FFFFFFF; + }; + Hash.FNV_BASE = 2166136261; + Hash.FNV_PRIME = 16777619; + + Hash.primes = [ + 3, 7, 11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, + 631, 761, 919, 1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, + 10103, 12143, 14591, 17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, + 90523, 108631, 130363, 156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, + 672827, 807403, 968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, + 4166287, 4999559, 5999471, 7199369]; + return Hash; + })(); + TypeScript.Hash = Hash; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Collections) { + Collections.DefaultHashTableCapacity = 1024; + + var HashTableEntry = (function () { + function HashTableEntry(Key, Value, HashCode, Next) { + this.Key = Key; + this.Value = Value; + this.HashCode = HashCode; + this.Next = Next; + } + return HashTableEntry; + })(); + + var HashTable = (function () { + function HashTable(capacity, hash) { + this.hash = hash; + this.count = 0; + var size = TypeScript.Hash.getPrime(capacity); + this.entries = TypeScript.ArrayUtilities.createArray(size, null); + } + HashTable.prototype.set = function (key, value) { + this.addOrSet(key, value, false); + }; + + HashTable.prototype.add = function (key, value) { + this.addOrSet(key, value, true); + }; + + HashTable.prototype.containsKey = function (key) { + var hashCode = this.computeHashCode(key); + var entry = this.findEntry(key, hashCode); + return entry !== null; + }; + + HashTable.prototype.get = function (key) { + var hashCode = this.computeHashCode(key); + var entry = this.findEntry(key, hashCode); + + return entry === null ? null : entry.Value; + }; + + HashTable.prototype.computeHashCode = function (key) { + var hashCode = this.hash === null ? key.hashCode : this.hash(key); + + hashCode = hashCode & 0x7FFFFFFF; + TypeScript.Debug.assert(hashCode >= 0); + + return hashCode; + }; + + HashTable.prototype.addOrSet = function (key, value, throwOnExistingEntry) { + var hashCode = this.computeHashCode(key); + + var entry = this.findEntry(key, hashCode); + if (entry !== null) { + if (throwOnExistingEntry) { + throw TypeScript.Errors.argument('key', "Key was already in table."); + } + + entry.Key = key; + entry.Value = value; + return; + } + + return this.addEntry(key, value, hashCode); + }; + + HashTable.prototype.findEntry = function (key, hashCode) { + for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) { + if (e.HashCode === hashCode && key === e.Key) { + return e; + } + } + + return null; + }; + + HashTable.prototype.addEntry = function (key, value, hashCode) { + var index = hashCode % this.entries.length; + + var e = new HashTableEntry(key, value, hashCode, this.entries[index]); + + this.entries[index] = e; + + if (this.count >= (this.entries.length / 2)) { + this.grow(); + } + + this.count++; + return e.Key; + }; + + HashTable.prototype.grow = function () { + var newSize = TypeScript.Hash.expandPrime(this.entries.length); + + var oldEntries = this.entries; + var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null); + + this.entries = newEntries; + + for (var i = 0; i < oldEntries.length; i++) { + var e = oldEntries[i]; + + while (e !== null) { + var newIndex = e.HashCode % newSize; + var tmp = e.Next; + e.Next = newEntries[newIndex]; + newEntries[newIndex] = e; + e = tmp; + } + } + }; + return HashTable; + })(); + Collections.HashTable = HashTable; + + function createHashTable(capacity, hash) { + if (typeof capacity === "undefined") { capacity = Collections.DefaultHashTableCapacity; } + if (typeof hash === "undefined") { hash = null; } + return new HashTable(capacity, hash); + } + Collections.createHashTable = createHashTable; + + var currentHashCode = 1; + function identityHashCode(value) { + if (value.__hash === undefined) { + value.__hash = currentHashCode; + currentHashCode++; + } + + return value.__hash; + } + Collections.identityHashCode = identityHashCode; + })(TypeScript.Collections || (TypeScript.Collections = {})); + var Collections = TypeScript.Collections; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + TypeScript.nodeMakeDirectoryTime = 0; + TypeScript.nodeCreateBufferTime = 0; + TypeScript.nodeWriteFileSyncTime = 0; + + (function (ByteOrderMark) { + ByteOrderMark[ByteOrderMark["None"] = 0] = "None"; + ByteOrderMark[ByteOrderMark["Utf8"] = 1] = "Utf8"; + ByteOrderMark[ByteOrderMark["Utf16BigEndian"] = 2] = "Utf16BigEndian"; + ByteOrderMark[ByteOrderMark["Utf16LittleEndian"] = 3] = "Utf16LittleEndian"; + })(TypeScript.ByteOrderMark || (TypeScript.ByteOrderMark = {})); + var ByteOrderMark = TypeScript.ByteOrderMark; + + var FileInformation = (function () { + function FileInformation(contents, byteOrderMark) { + this.contents = contents; + this.byteOrderMark = byteOrderMark; + } + return FileInformation; + })(); + TypeScript.FileInformation = FileInformation; + + TypeScript.Environment = (function () { + function getWindowsScriptHostEnvironment() { + try { + var fso = new ActiveXObject("Scripting.FileSystemObject"); + } catch (e) { + return null; + } + + var streamObjectPool = []; + + function getStreamObject() { + if (streamObjectPool.length > 0) { + return streamObjectPool.pop(); + } else { + return new ActiveXObject("ADODB.Stream"); + } + } + + function releaseStreamObject(obj) { + streamObjectPool.push(obj); + } + + var args = []; + for (var i = 0; i < WScript.Arguments.length; i++) { + args[i] = WScript.Arguments.Item(i); + } + + return { + newLine: "\r\n", + currentDirectory: function () { + return WScript.CreateObject("WScript.Shell").CurrentDirectory; + }, + supportsCodePage: function () { + return WScript.ReadFile; + }, + readFile: function (path, codepage) { + try { + if (codepage !== null && this.supportsCodePage()) { + try { + var contents = WScript.ReadFile(path, codepage); + return new FileInformation(contents, 0 /* None */); + } catch (e) { + } + } + + var streamObj = getStreamObject(); + streamObj.Open(); + streamObj.Type = 2; + + streamObj.Charset = 'x-ansi'; + + streamObj.LoadFromFile(path); + var bomChar = streamObj.ReadText(2); + + streamObj.Position = 0; + + var byteOrderMark = 0 /* None */; + + if (bomChar.charCodeAt(0) === 0xFE && bomChar.charCodeAt(1) === 0xFF) { + streamObj.Charset = 'unicode'; + byteOrderMark = 2 /* Utf16BigEndian */; + } else if (bomChar.charCodeAt(0) === 0xFF && bomChar.charCodeAt(1) === 0xFE) { + streamObj.Charset = 'unicode'; + byteOrderMark = 3 /* Utf16LittleEndian */; + } else if (bomChar.charCodeAt(0) === 0xEF && bomChar.charCodeAt(1) === 0xBB) { + streamObj.Charset = 'utf-8'; + byteOrderMark = 1 /* Utf8 */; + } else { + streamObj.Charset = 'utf-8'; + } + + var contents = streamObj.ReadText(-1); + streamObj.Close(); + releaseStreamObject(streamObj); + return new FileInformation(contents, byteOrderMark); + } catch (err) { + var message; + if (err.number === -2147024809) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Unsupported_file_encoding, null); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Cannot_read_file_0_1, [path, err.message]); + } + + throw new Error(message); + } + }, + writeFile: function (path, contents, writeByteOrderMark) { + var textStream = getStreamObject(); + textStream.Charset = 'utf-8'; + textStream.Open(); + textStream.WriteText(contents, 0); + + if (!writeByteOrderMark) { + textStream.Position = 3; + } else { + textStream.Position = 0; + } + + var fileStream = getStreamObject(); + fileStream.Type = 1; + fileStream.Open(); + + textStream.CopyTo(fileStream); + + fileStream.Flush(); + fileStream.SaveToFile(path, 2); + fileStream.Close(); + + textStream.Flush(); + textStream.Close(); + }, + fileExists: function (path) { + return fso.FileExists(path); + }, + deleteFile: function (path) { + if (fso.FileExists(path)) { + fso.DeleteFile(path, true); + } + }, + directoryExists: function (path) { + return fso.FolderExists(path); + }, + listFiles: function (path, spec, options) { + options = options || {}; + function filesInFolder(folder, root) { + var paths = []; + var fc; + + if (options.recursive) { + fc = new Enumerator(folder.subfolders); + + for (; !fc.atEnd(); fc.moveNext()) { + paths = paths.concat(filesInFolder(fc.item(), root + "\\" + fc.item().Name)); + } + } + + fc = new Enumerator(folder.files); + + for (; !fc.atEnd(); fc.moveNext()) { + if (!spec || fc.item().Name.match(spec)) { + paths.push(root + "\\" + fc.item().Name); + } + } + + return paths; + } + + var folder = fso.GetFolder(path); + var paths = []; + + return filesInFolder(folder, path); + }, + arguments: args, + standardOut: WScript.StdOut + }; + } + ; + + function getNodeEnvironment() { + var _fs = require('fs'); + var _path = require('path'); + var _module = require('module'); + var _os = require('os'); + + return { + newLine: _os.EOL, + currentDirectory: function () { + return process.cwd(); + }, + supportsCodePage: function () { + return false; + }, + readFile: function (file, codepage) { + if (codepage !== null) { + throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.codepage_option_not_supported_on_current_platform, null)); + } + + var buffer = _fs.readFileSync(file); + switch (buffer[0]) { + case 0xFE: + if (buffer[1] === 0xFF) { + var i = 0; + while ((i + 1) < buffer.length) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + i += 2; + } + return new FileInformation(buffer.toString("ucs2", 2), 2 /* Utf16BigEndian */); + } + break; + case 0xFF: + if (buffer[1] === 0xFE) { + return new FileInformation(buffer.toString("ucs2", 2), 3 /* Utf16LittleEndian */); + } + break; + case 0xEF: + if (buffer[1] === 0xBB) { + return new FileInformation(buffer.toString("utf8", 3), 1 /* Utf8 */); + } + } + + return new FileInformation(buffer.toString("utf8", 0), 0 /* None */); + }, + writeFile: function (path, contents, writeByteOrderMark) { + function mkdirRecursiveSync(path) { + var stats = _fs.statSync(path); + if (stats.isFile()) { + throw "\"" + path + "\" exists but isn't a directory."; + } else if (stats.isDirectory()) { + return; + } else { + mkdirRecursiveSync(_path.dirname(path)); + _fs.mkdirSync(path, 509); + } + } + var start = new Date().getTime(); + mkdirRecursiveSync(_path.dirname(path)); + TypeScript.nodeMakeDirectoryTime += new Date().getTime() - start; + + if (writeByteOrderMark) { + contents = '\uFEFF' + contents; + } + + var start = new Date().getTime(); + + var chunkLength = 4 * 1024; + var fileDescriptor = _fs.openSync(path, "w"); + try { + for (var index = 0; index < contents.length; index += chunkLength) { + var bufferStart = new Date().getTime(); + var buffer = new Buffer(contents.substr(index, chunkLength), "utf8"); + TypeScript.nodeCreateBufferTime += new Date().getTime() - bufferStart; + + _fs.writeSync(fileDescriptor, buffer, 0, buffer.length, null); + } + } finally { + _fs.closeSync(fileDescriptor); + } + + TypeScript.nodeWriteFileSyncTime += new Date().getTime() - start; + }, + fileExists: function (path) { + return _fs.existsSync(path); + }, + deleteFile: function (path) { + try { + _fs.unlinkSync(path); + } catch (e) { + } + }, + directoryExists: function (path) { + return _fs.existsSync(path) && _fs.statSync(path).isDirectory(); + }, + listFiles: function dir(path, spec, options) { + options = options || {}; + + function filesInFolder(folder) { + var paths = []; + + var files = _fs.readdirSync(folder); + for (var i = 0; i < files.length; i++) { + var stat = _fs.statSync(folder + "\\" + files[i]); + if (options.recursive && stat.isDirectory()) { + paths = paths.concat(filesInFolder(folder + "\\" + files[i])); + } else if (stat.isFile() && (!spec || files[i].match(spec))) { + paths.push(folder + "\\" + files[i]); + } + } + + return paths; + } + + return filesInFolder(path); + }, + arguments: process.argv.slice(2), + standardOut: { + Write: function (str) { + process.stdout.write(str); + }, + WriteLine: function (str) { + process.stdout.write(str + '\n'); + }, + Close: function () { + } + } + }; + } + ; + + if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") { + return getWindowsScriptHostEnvironment(); + } else if (typeof module !== 'undefined' && module.exports) { + return getNodeEnvironment(); + } else { + return null; + } + })(); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (IntegerUtilities) { + function integerDivide(numerator, denominator) { + return (numerator / denominator) >> 0; + } + IntegerUtilities.integerDivide = integerDivide; + + function integerMultiplyLow32Bits(n1, n2) { + var n1Low16 = n1 & 0x0000ffff; + var n1High16 = n1 >>> 16; + + var n2Low16 = n2 & 0x0000ffff; + var n2High16 = n2 >>> 16; + + var resultLow32 = (((n1 & 0xffff0000) * n2) >>> 0) + (((n1 & 0x0000ffff) * n2) >>> 0) >>> 0; + return resultLow32; + } + IntegerUtilities.integerMultiplyLow32Bits = integerMultiplyLow32Bits; + + function integerMultiplyHigh32Bits(n1, n2) { + var n1Low16 = n1 & 0x0000ffff; + var n1High16 = n1 >>> 16; + + var n2Low16 = n2 & 0x0000ffff; + var n2High16 = n2 >>> 16; + + var resultHigh32 = n1High16 * n2High16 + ((((n1Low16 * n2Low16) >>> 17) + n1Low16 * n2High16) >>> 15); + return resultHigh32; + } + IntegerUtilities.integerMultiplyHigh32Bits = integerMultiplyHigh32Bits; + + function isInteger(text) { + return /^[0-9]+$/.test(text); + } + IntegerUtilities.isInteger = isInteger; + + function isHexInteger(text) { + return /^0(x|X)[0-9a-fA-F]+$/.test(text); + } + IntegerUtilities.isHexInteger = isHexInteger; + })(TypeScript.IntegerUtilities || (TypeScript.IntegerUtilities = {})); + var IntegerUtilities = TypeScript.IntegerUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var LineMap = (function () { + function LineMap(_computeLineStarts, length) { + this._computeLineStarts = _computeLineStarts; + this.length = length; + this._lineStarts = null; + } + LineMap.prototype.toJSON = function (key) { + return { lineStarts: this.lineStarts(), length: this.length }; + }; + + LineMap.prototype.equals = function (other) { + return this.length === other.length && TypeScript.ArrayUtilities.sequenceEquals(this.lineStarts(), other.lineStarts(), function (v1, v2) { + return v1 === v2; + }); + }; + + LineMap.prototype.lineStarts = function () { + if (this._lineStarts === null) { + this._lineStarts = this._computeLineStarts(); + } + + return this._lineStarts; + }; + + LineMap.prototype.lineCount = function () { + return this.lineStarts().length; + }; + + LineMap.prototype.getPosition = function (line, character) { + return this.lineStarts()[line] + character; + }; + + LineMap.prototype.getLineNumberFromPosition = function (position) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + if (position === this.length) { + return this.lineCount() - 1; + } + + var lineNumber = TypeScript.ArrayUtilities.binarySearch(this.lineStarts(), position); + if (lineNumber < 0) { + lineNumber = (~lineNumber) - 1; + } + + return lineNumber; + }; + + LineMap.prototype.getLineStartPosition = function (lineNumber) { + return this.lineStarts()[lineNumber]; + }; + + LineMap.prototype.fillLineAndCharacterFromPosition = function (position, lineAndCharacter) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + lineAndCharacter.line = lineNumber; + lineAndCharacter.character = position - this.lineStarts()[lineNumber]; + }; + + LineMap.prototype.getLineAndCharacterFromPosition = function (position) { + if (position < 0 || position > this.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + + return new TypeScript.LineAndCharacter(lineNumber, position - this.lineStarts()[lineNumber]); + }; + LineMap.empty = new LineMap(function () { + return [0]; + }, 0); + return LineMap; + })(); + TypeScript.LineMap = LineMap; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var LineAndCharacter = (function () { + function LineAndCharacter(line, character) { + this._line = 0; + this._character = 0; + if (line < 0) { + throw TypeScript.Errors.argumentOutOfRange("line"); + } + + if (character < 0) { + throw TypeScript.Errors.argumentOutOfRange("character"); + } + + this._line = line; + this._character = character; + } + LineAndCharacter.prototype.line = function () { + return this._line; + }; + + LineAndCharacter.prototype.character = function () { + return this._character; + }; + return LineAndCharacter; + })(); + TypeScript.LineAndCharacter = LineAndCharacter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var MathPrototype = (function () { + function MathPrototype() { + } + MathPrototype.max = function (a, b) { + return a >= b ? a : b; + }; + + MathPrototype.min = function (a, b) { + return a <= b ? a : b; + }; + return MathPrototype; + })(); + TypeScript.MathPrototype = MathPrototype; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Collections) { + Collections.DefaultStringTableCapacity = 256; + + var StringTableEntry = (function () { + function StringTableEntry(Text, HashCode, Next) { + this.Text = Text; + this.HashCode = HashCode; + this.Next = Next; + } + return StringTableEntry; + })(); + + var StringTable = (function () { + function StringTable(capacity) { + this.count = 0; + var size = TypeScript.Hash.getPrime(capacity); + this.entries = TypeScript.ArrayUtilities.createArray(size, null); + } + StringTable.prototype.addCharArray = function (key, start, len) { + var hashCode = TypeScript.Hash.computeSimple31BitCharArrayHashCode(key, start, len) & 0x7FFFFFFF; + + var entry = this.findCharArrayEntry(key, start, len, hashCode); + if (entry !== null) { + return entry.Text; + } + + var slice = key.slice(start, start + len); + return this.addEntry(TypeScript.StringUtilities.fromCharCodeArray(slice), hashCode); + }; + + StringTable.prototype.findCharArrayEntry = function (key, start, len, hashCode) { + for (var e = this.entries[hashCode % this.entries.length]; e !== null; e = e.Next) { + if (e.HashCode === hashCode && StringTable.textCharArrayEquals(e.Text, key, start, len)) { + return e; + } + } + + return null; + }; + + StringTable.prototype.addEntry = function (text, hashCode) { + var index = hashCode % this.entries.length; + + var e = new StringTableEntry(text, hashCode, this.entries[index]); + + this.entries[index] = e; + + if (this.count === this.entries.length) { + this.grow(); + } + + this.count++; + return e.Text; + }; + + StringTable.prototype.grow = function () { + var newSize = TypeScript.Hash.expandPrime(this.entries.length); + + var oldEntries = this.entries; + var newEntries = TypeScript.ArrayUtilities.createArray(newSize, null); + + this.entries = newEntries; + + for (var i = 0; i < oldEntries.length; i++) { + var e = oldEntries[i]; + while (e !== null) { + var newIndex = e.HashCode % newSize; + var tmp = e.Next; + e.Next = newEntries[newIndex]; + newEntries[newIndex] = e; + e = tmp; + } + } + }; + + StringTable.textCharArrayEquals = function (text, array, start, length) { + if (text.length !== length) { + return false; + } + + var s = start; + for (var i = 0; i < length; i++) { + if (text.charCodeAt(i) !== array[s]) { + return false; + } + + s++; + } + + return true; + }; + return StringTable; + })(); + Collections.StringTable = StringTable; + + Collections.DefaultStringTable = new StringTable(Collections.DefaultStringTableCapacity); + })(TypeScript.Collections || (TypeScript.Collections = {})); + var Collections = TypeScript.Collections; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var StringUtilities = (function () { + function StringUtilities() { + } + StringUtilities.isString = function (value) { + return Object.prototype.toString.apply(value, []) === '[object String]'; + }; + + StringUtilities.fromCharCodeArray = function (array) { + return String.fromCharCode.apply(null, array); + }; + + StringUtilities.endsWith = function (string, value) { + return string.substring(string.length - value.length, string.length) === value; + }; + + StringUtilities.startsWith = function (string, value) { + return string.substr(0, value.length) === value; + }; + + StringUtilities.copyTo = function (source, sourceIndex, destination, destinationIndex, count) { + for (var i = 0; i < count; i++) { + destination[destinationIndex + i] = source.charCodeAt(sourceIndex + i); + } + }; + + StringUtilities.repeat = function (value, count) { + return Array(count + 1).join(value); + }; + + StringUtilities.stringEquals = function (val1, val2) { + return val1 === val2; + }; + return StringUtilities; + })(); + TypeScript.StringUtilities = StringUtilities; +})(TypeScript || (TypeScript = {})); +var global = Function("return this").call(null); + +var TypeScript; +(function (TypeScript) { + var Clock; + (function (Clock) { + Clock.now; + Clock.resolution; + + if (typeof WScript !== "undefined" && typeof global['WScript'].InitializeProjection !== "undefined") { + global['WScript'].InitializeProjection(); + + Clock.now = function () { + return TestUtilities.QueryPerformanceCounter(); + }; + + Clock.resolution = TestUtilities.QueryPerformanceFrequency(); + } else { + Clock.now = function () { + return Date.now(); + }; + + Clock.resolution = 1000; + } + })(Clock || (Clock = {})); + + var Timer = (function () { + function Timer() { + this.time = 0; + } + Timer.prototype.start = function () { + this.time = 0; + this.startTime = Clock.now(); + }; + + Timer.prototype.end = function () { + this.time = (Clock.now() - this.startTime); + }; + return Timer; + })(); + TypeScript.Timer = Timer; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Message"] = 2] = "Message"; + DiagnosticCategory[DiagnosticCategory["NoPrefix"] = 3] = "NoPrefix"; + })(TypeScript.DiagnosticCategory || (TypeScript.DiagnosticCategory = {})); + var DiagnosticCategory = TypeScript.DiagnosticCategory; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.diagnosticInformationMap = { + "error TS{0}: {1}": { + "code": 0, + "category": 3 /* NoPrefix */ + }, + "warning TS{0}: {1}": { + "code": 1, + "category": 3 /* NoPrefix */ + }, + "Unrecognized escape sequence.": { + "code": 1000, + "category": 1 /* Error */ + }, + "Unexpected character {0}.": { + "code": 1001, + "category": 1 /* Error */ + }, + "Missing close quote character.": { + "code": 1002, + "category": 1 /* Error */ + }, + "Identifier expected.": { + "code": 1003, + "category": 1 /* Error */ + }, + "'{0}' keyword expected.": { + "code": 1004, + "category": 1 /* Error */ + }, + "'{0}' expected.": { + "code": 1005, + "category": 1 /* Error */ + }, + "Identifier expected; '{0}' is a keyword.": { + "code": 1006, + "category": 1 /* Error */ + }, + "Automatic semicolon insertion not allowed.": { + "code": 1007, + "category": 1 /* Error */ + }, + "Unexpected token; '{0}' expected.": { + "code": 1008, + "category": 1 /* Error */ + }, + "Trailing separator not allowed.": { + "code": 1009, + "category": 1 /* Error */ + }, + "'*/' expected.": { + "code": 1010, + "category": 1 /* Error */ + }, + "'public' or 'private' modifier must precede 'static'.": { + "code": 1011, + "category": 1 /* Error */ + }, + "Unexpected token.": { + "code": 1012, + "category": 1 /* Error */ + }, + "Catch clause parameter cannot have a type annotation.": { + "code": 1013, + "category": 1 /* Error */ + }, + "Rest parameter must be last in list.": { + "code": 1014, + "category": 1 /* Error */ + }, + "Parameter cannot have question mark and initializer.": { + "code": 1015, + "category": 1 /* Error */ + }, + "Required parameter cannot follow optional parameter.": { + "code": 1016, + "category": 1 /* Error */ + }, + "Index signatures cannot have rest parameters.": { + "code": 1017, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have accessibility modifiers.": { + "code": 1018, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have a question mark.": { + "code": 1019, + "category": 1 /* Error */ + }, + "Index signature parameter cannot have an initializer.": { + "code": 1020, + "category": 1 /* Error */ + }, + "Index signature must have a type annotation.": { + "code": 1021, + "category": 1 /* Error */ + }, + "Index signature parameter must have a type annotation.": { + "code": 1022, + "category": 1 /* Error */ + }, + "Index signature parameter type must be 'string' or 'number'.": { + "code": 1023, + "category": 1 /* Error */ + }, + "'extends' clause already seen.": { + "code": 1024, + "category": 1 /* Error */ + }, + "'extends' clause must precede 'implements' clause.": { + "code": 1025, + "category": 1 /* Error */ + }, + "Classes can only extend a single class.": { + "code": 1026, + "category": 1 /* Error */ + }, + "'implements' clause already seen.": { + "code": 1027, + "category": 1 /* Error */ + }, + "Accessibility modifier already seen.": { + "code": 1028, + "category": 1 /* Error */ + }, + "'{0}' modifier must precede '{1}' modifier.": { + "code": 1029, + "category": 1 /* Error */ + }, + "'{0}' modifier already seen.": { + "code": 1030, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a class element.": { + "code": 1031, + "category": 1 /* Error */ + }, + "Interface declaration cannot have 'implements' clause.": { + "code": 1032, + "category": 1 /* Error */ + }, + "'super' invocation cannot have type arguments.": { + "code": 1034, + "category": 1 /* Error */ + }, + "Only ambient modules can use quoted names.": { + "code": 1035, + "category": 1 /* Error */ + }, + "Statements are not allowed in ambient contexts.": { + "code": 1036, + "category": 1 /* Error */ + }, + "Implementations are not allowed in ambient contexts.": { + "code": 1037, + "category": 1 /* Error */ + }, + "'declare' modifier not allowed for code already in an ambient context.": { + "code": 1038, + "category": 1 /* Error */ + }, + "Initializers are not allowed in ambient contexts.": { + "code": 1039, + "category": 1 /* Error */ + }, + "Parameter property declarations can only be used in constructors.": { + "code": 1040, + "category": 1 /* Error */ + }, + "Function implementation expected.": { + "code": 1041, + "category": 1 /* Error */ + }, + "Constructor implementation expected.": { + "code": 1042, + "category": 1 /* Error */ + }, + "Function overload name must be '{0}'.": { + "code": 1043, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a module element.": { + "code": 1044, + "category": 1 /* Error */ + }, + "'declare' modifier cannot appear on an interface declaration.": { + "code": 1045, + "category": 1 /* Error */ + }, + "'declare' modifier required for top level element.": { + "code": 1046, + "category": 1 /* Error */ + }, + "Rest parameter cannot be optional.": { + "code": 1047, + "category": 1 /* Error */ + }, + "Rest parameter cannot have an initializer.": { + "code": 1048, + "category": 1 /* Error */ + }, + "'set' accessor must have one and only one parameter.": { + "code": 1049, + "category": 1 /* Error */ + }, + "'set' accessor parameter cannot be optional.": { + "code": 1051, + "category": 1 /* Error */ + }, + "'set' accessor parameter cannot have an initializer.": { + "code": 1052, + "category": 1 /* Error */ + }, + "'set' accessor cannot have rest parameter.": { + "code": 1053, + "category": 1 /* Error */ + }, + "'get' accessor cannot have parameters.": { + "code": 1054, + "category": 1 /* Error */ + }, + "Modifiers cannot appear here.": { + "code": 1055, + "category": 1 /* Error */ + }, + "Accessors are only available when targeting ECMAScript 5 and higher.": { + "code": 1056, + "category": 1 /* Error */ + }, + "Class name cannot be '{0}'.": { + "code": 1057, + "category": 1 /* Error */ + }, + "Interface name cannot be '{0}'.": { + "code": 1058, + "category": 1 /* Error */ + }, + "Enum name cannot be '{0}'.": { + "code": 1059, + "category": 1 /* Error */ + }, + "Module name cannot be '{0}'.": { + "code": 1060, + "category": 1 /* Error */ + }, + "Enum member must have initializer.": { + "code": 1061, + "category": 1 /* Error */ + }, + "Export assignment cannot be used in internal modules.": { + "code": 1063, + "category": 1 /* Error */ + }, + "Export assignment not allowed in module with exported element.": { + "code": 1064, + "category": 1 /* Error */ + }, + "Module cannot have multiple export assignments.": { + "code": 1065, + "category": 1 /* Error */ + }, + "Ambient enum elements can only have integer literal initializers.": { + "code": 1066, + "category": 1 /* Error */ + }, + "module, class, interface, enum, import or statement": { + "code": 1067, + "category": 3 /* NoPrefix */ + }, + "constructor, function, accessor or variable": { + "code": 1068, + "category": 3 /* NoPrefix */ + }, + "statement": { + "code": 1069, + "category": 3 /* NoPrefix */ + }, + "case or default clause": { + "code": 1070, + "category": 3 /* NoPrefix */ + }, + "identifier": { + "code": 1071, + "category": 3 /* NoPrefix */ + }, + "call, construct, index, property or function signature": { + "code": 1072, + "category": 3 /* NoPrefix */ + }, + "expression": { + "code": 1073, + "category": 3 /* NoPrefix */ + }, + "type name": { + "code": 1074, + "category": 3 /* NoPrefix */ + }, + "property or accessor": { + "code": 1075, + "category": 3 /* NoPrefix */ + }, + "parameter": { + "code": 1076, + "category": 3 /* NoPrefix */ + }, + "type": { + "code": 1077, + "category": 3 /* NoPrefix */ + }, + "type parameter": { + "code": 1078, + "category": 3 /* NoPrefix */ + }, + "'declare' modifier not allowed on import declaration.": { + "code": 1079, + "category": 1 /* Error */ + }, + "Function overload must be static.": { + "code": 1080, + "category": 1 /* Error */ + }, + "Function overload must not be static.": { + "code": 1081, + "category": 1 /* Error */ + }, + "Parameter property declarations cannot be used in an ambient context.": { + "code": 1082, + "category": 1 /* Error */ + }, + "Parameter property declarations cannot be used in a constructor overload.": { + "code": 1083, + "category": 1 /* Error */ + }, + "Invalid 'reference' directive syntax.": { + "code": 1084, + "category": 1 /* Error */ + }, + "Octal literals are not available when targeting ECMAScript 5 and higher.": { + "code": 1085, + "category": 1 /* Error */ + }, + "Accessors are not allowed in ambient contexts.": { + "code": 1086, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a constructor declaration.": { + "code": 1089, + "category": 1 /* Error */ + }, + "'{0}' modifier cannot appear on a parameter.": { + "code": 1090, + "category": 1 /* Error */ + }, + "Duplicate identifier '{0}'.": { + "code": 2000, + "category": 1 /* Error */ + }, + "The name '{0}' does not exist in the current scope.": { + "code": 2001, + "category": 1 /* Error */ + }, + "The name '{0}' does not refer to a value.": { + "code": 2002, + "category": 1 /* Error */ + }, + "'super' can only be used inside a class instance method.": { + "code": 2003, + "category": 1 /* Error */ + }, + "The left-hand side of an assignment expression must be a variable, property or indexer.": { + "code": 2004, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not callable. Did you mean to include 'new'?": { + "code": 2161, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not callable.": { + "code": 2006, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not newable.": { + "code": 2007, + "category": 1 /* Error */ + }, + "Value of type '{0}' is not indexable by type '{1}'.": { + "code": 2008, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to types '{1}' and '{2}'.": { + "code": 2009, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to types '{1}' and '{2}': {3}": { + "code": 2010, + "category": 1 /* Error */ + }, + "Cannot convert '{0}' to '{1}'.": { + "code": 2011, + "category": 1 /* Error */ + }, + "Cannot convert '{0}' to '{1}':{NL}{2}": { + "code": 2012, + "category": 1 /* Error */ + }, + "Expected var, class, interface, or module.": { + "code": 2013, + "category": 1 /* Error */ + }, + "Operator '{0}' cannot be applied to type '{1}'.": { + "code": 2014, + "category": 1 /* Error */ + }, + "Getter '{0}' already declared.": { + "code": 2015, + "category": 1 /* Error */ + }, + "Setter '{0}' already declared.": { + "code": 2016, + "category": 1 /* Error */ + }, + "Exported class '{0}' extends private class '{1}'.": { + "code": 2018, + "category": 1 /* Error */ + }, + "Exported class '{0}' implements private interface '{1}'.": { + "code": 2019, + "category": 1 /* Error */ + }, + "Exported interface '{0}' extends private interface '{1}'.": { + "code": 2020, + "category": 1 /* Error */ + }, + "Exported class '{0}' extends class from inaccessible module {1}.": { + "code": 2021, + "category": 1 /* Error */ + }, + "Exported class '{0}' implements interface from inaccessible module {1}.": { + "code": 2022, + "category": 1 /* Error */ + }, + "Exported interface '{0}' extends interface from inaccessible module {1}.": { + "code": 2023, + "category": 1 /* Error */ + }, + "Public static property '{0}' of exported class has or is using private type '{1}'.": { + "code": 2024, + "category": 1 /* Error */ + }, + "Public property '{0}' of exported class has or is using private type '{1}'.": { + "code": 2025, + "category": 1 /* Error */ + }, + "Property '{0}' of exported interface has or is using private type '{1}'.": { + "code": 2026, + "category": 1 /* Error */ + }, + "Exported variable '{0}' has or is using private type '{1}'.": { + "code": 2027, + "category": 1 /* Error */ + }, + "Public static property '{0}' of exported class is using inaccessible module {1}.": { + "code": 2028, + "category": 1 /* Error */ + }, + "Public property '{0}' of exported class is using inaccessible module {1}.": { + "code": 2029, + "category": 1 /* Error */ + }, + "Property '{0}' of exported interface is using inaccessible module {1}.": { + "code": 2030, + "category": 1 /* Error */ + }, + "Exported variable '{0}' is using inaccessible module {1}.": { + "code": 2031, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor from exported class has or is using private type '{1}'.": { + "code": 2032, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static property setter from exported class has or is using private type '{1}'.": { + "code": 2033, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public property setter from exported class has or is using private type '{1}'.": { + "code": 2034, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": { + "code": 2035, + "category": 1 /* Error */ + }, + "Parameter '{0}' of call signature from exported interface has or is using private type '{1}'.": { + "code": 2036, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static method from exported class has or is using private type '{1}'.": { + "code": 2037, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public method from exported class has or is using private type '{1}'.": { + "code": 2038, + "category": 1 /* Error */ + }, + "Parameter '{0}' of method from exported interface has or is using private type '{1}'.": { + "code": 2039, + "category": 1 /* Error */ + }, + "Parameter '{0}' of exported function has or is using private type '{1}'.": { + "code": 2040, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor from exported class is using inaccessible module {1}.": { + "code": 2041, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static property setter from exported class is using inaccessible module {1}.": { + "code": 2042, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public property setter from exported class is using inaccessible module {1}.": { + "code": 2043, + "category": 1 /* Error */ + }, + "Parameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": { + "code": 2044, + "category": 1 /* Error */ + }, + "Parameter '{0}' of call signature from exported interface is using inaccessible module {1}": { + "code": 2045, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public static method from exported class is using inaccessible module {1}.": { + "code": 2046, + "category": 1 /* Error */ + }, + "Parameter '{0}' of public method from exported class is using inaccessible module {1}.": { + "code": 2047, + "category": 1 /* Error */ + }, + "Parameter '{0}' of method from exported interface is using inaccessible module {1}.": { + "code": 2048, + "category": 1 /* Error */ + }, + "Parameter '{0}' of exported function is using inaccessible module {1}.": { + "code": 2049, + "category": 1 /* Error */ + }, + "Return type of public static property getter from exported class has or is using private type '{0}'.": { + "code": 2050, + "category": 1 /* Error */ + }, + "Return type of public property getter from exported class has or is using private type '{0}'.": { + "code": 2051, + "category": 1 /* Error */ + }, + "Return type of constructor signature from exported interface has or is using private type '{0}'.": { + "code": 2052, + "category": 1 /* Error */ + }, + "Return type of call signature from exported interface has or is using private type '{0}'.": { + "code": 2053, + "category": 1 /* Error */ + }, + "Return type of index signature from exported interface has or is using private type '{0}'.": { + "code": 2054, + "category": 1 /* Error */ + }, + "Return type of public static method from exported class has or is using private type '{0}'.": { + "code": 2055, + "category": 1 /* Error */ + }, + "Return type of public method from exported class has or is using private type '{0}'.": { + "code": 2056, + "category": 1 /* Error */ + }, + "Return type of method from exported interface has or is using private type '{0}'.": { + "code": 2057, + "category": 1 /* Error */ + }, + "Return type of exported function has or is using private type '{0}'.": { + "code": 2058, + "category": 1 /* Error */ + }, + "Return type of public static property getter from exported class is using inaccessible module {0}.": { + "code": 2059, + "category": 1 /* Error */ + }, + "Return type of public property getter from exported class is using inaccessible module {0}.": { + "code": 2060, + "category": 1 /* Error */ + }, + "Return type of constructor signature from exported interface is using inaccessible module {0}.": { + "code": 2061, + "category": 1 /* Error */ + }, + "Return type of call signature from exported interface is using inaccessible module {0}.": { + "code": 2062, + "category": 1 /* Error */ + }, + "Return type of index signature from exported interface is using inaccessible module {0}.": { + "code": 2063, + "category": 1 /* Error */ + }, + "Return type of public static method from exported class is using inaccessible module {0}.": { + "code": 2064, + "category": 1 /* Error */ + }, + "Return type of public method from exported class is using inaccessible module {0}.": { + "code": 2065, + "category": 1 /* Error */ + }, + "Return type of method from exported interface is using inaccessible module {0}.": { + "code": 2066, + "category": 1 /* Error */ + }, + "Return type of exported function is using inaccessible module {0}.": { + "code": 2067, + "category": 1 /* Error */ + }, + "'new T[]' cannot be used to create an array. Use 'new Array()' instead.": { + "code": 2068, + "category": 1 /* Error */ + }, + "A parameter list must follow a generic type argument list. '(' expected.": { + "code": 2069, + "category": 1 /* Error */ + }, + "Multiple constructor implementations are not allowed.": { + "code": 2070, + "category": 1 /* Error */ + }, + "Unable to resolve external module '{0}'.": { + "code": 2071, + "category": 1 /* Error */ + }, + "Module cannot be aliased to a non-module type.": { + "code": 2072, + "category": 1 /* Error */ + }, + "A class may only extend another class.": { + "code": 2073, + "category": 1 /* Error */ + }, + "A class may only implement another class or interface.": { + "code": 2074, + "category": 1 /* Error */ + }, + "An interface may only extend another class or interface.": { + "code": 2075, + "category": 1 /* Error */ + }, + "Unable to resolve type.": { + "code": 2077, + "category": 1 /* Error */ + }, + "Unable to resolve type of '{0}'.": { + "code": 2078, + "category": 1 /* Error */ + }, + "Unable to resolve type parameter constraint.": { + "code": 2079, + "category": 1 /* Error */ + }, + "Type parameter constraint cannot be a primitive type.": { + "code": 2080, + "category": 1 /* Error */ + }, + "Supplied parameters do not match any signature of call target.": { + "code": 2081, + "category": 1 /* Error */ + }, + "Supplied parameters do not match any signature of call target:{NL}{0}": { + "code": 2082, + "category": 1 /* Error */ + }, + "Invalid 'new' expression.": { + "code": 2083, + "category": 1 /* Error */ + }, + "Call signatures used in a 'new' expression must have a 'void' return type.": { + "code": 2084, + "category": 1 /* Error */ + }, + "Could not select overload for 'new' expression.": { + "code": 2085, + "category": 1 /* Error */ + }, + "Type '{0}' does not satisfy the constraint '{1}' for type parameter '{2}'.": { + "code": 2086, + "category": 1 /* Error */ + }, + "Could not select overload for 'call' expression.": { + "code": 2087, + "category": 1 /* Error */ + }, + "Cannot invoke an expression whose type lacks a call signature.": { + "code": 2088, + "category": 1 /* Error */ + }, + "Calls to 'super' are only valid inside a class.": { + "code": 2089, + "category": 1 /* Error */ + }, + "Generic type '{0}' requires {1} type argument(s).": { + "code": 2090, + "category": 1 /* Error */ + }, + "Type of array literal cannot be determined. Best common type could not be found for array elements.": { + "code": 2092, + "category": 1 /* Error */ + }, + "Could not find enclosing symbol for dotted name '{0}'.": { + "code": 2093, + "category": 1 /* Error */ + }, + "The property '{0}' does not exist on value of type '{1}'.": { + "code": 2094, + "category": 1 /* Error */ + }, + "Could not find symbol '{0}'.": { + "code": 2095, + "category": 1 /* Error */ + }, + "'get' and 'set' accessor must have the same type.": { + "code": 2096, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in current location.": { + "code": 2097, + "category": 1 /* Error */ + }, + "Static methods cannot reference class type parameters.": { + "code": 2099, + "category": 1 /* Error */ + }, + "Class '{0}' is recursively referenced as a base type of itself.": { + "code": 2100, + "category": 1 /* Error */ + }, + "Interface '{0}' is recursively referenced as a base type of itself.": { + "code": 2101, + "category": 1 /* Error */ + }, + "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class.": { + "code": 2102, + "category": 1 /* Error */ + }, + "'super' cannot be referenced in non-derived classes.": { + "code": 2103, + "category": 1 /* Error */ + }, + "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.": { + "code": 2104, + "category": 1 /* Error */ + }, + "Constructors for derived classes must contain a 'super' call.": { + "code": 2105, + "category": 1 /* Error */ + }, + "Super calls are not permitted outside constructors or in local functions inside constructors.": { + "code": 2106, + "category": 1 /* Error */ + }, + "'{0}.{1}' is inaccessible.": { + "code": 2107, + "category": 1 /* Error */ + }, + "'this' cannot be referenced within module bodies.": { + "code": 2108, + "category": 1 /* Error */ + }, + "Invalid '+' expression - types not known to support the addition operator.": { + "code": 2111, + "category": 1 /* Error */ + }, + "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": { + "code": 2112, + "category": 1 /* Error */ + }, + "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.": { + "code": 2113, + "category": 1 /* Error */ + }, + "The type of a unary arithmetic operation operand must be of type 'any', 'number' or an enum type.": { + "code": 2114, + "category": 1 /* Error */ + }, + "Variable declarations of a 'for' statement cannot use a type annotation.": { + "code": 2115, + "category": 1 /* Error */ + }, + "Variable declarations of a 'for' statement must be of types 'string' or 'any'.": { + "code": 2116, + "category": 1 /* Error */ + }, + "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter.": { + "code": 2117, + "category": 1 /* Error */ + }, + "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.": { + "code": 2118, + "category": 1 /* Error */ + }, + "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter.": { + "code": 2119, + "category": 1 /* Error */ + }, + "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter.": { + "code": 2120, + "category": 1 /* Error */ + }, + "The right-hand side of an 'instanceof' expression must be of type 'any' or a subtype of the 'Function' interface type.": { + "code": 2121, + "category": 1 /* Error */ + }, + "Setters cannot return a value.": { + "code": 2122, + "category": 1 /* Error */ + }, + "Tried to query type of uninitialized module '{0}'.": { + "code": 2123, + "category": 1 /* Error */ + }, + "Tried to set variable type to uninitialized module type '{0}'.": { + "code": 2124, + "category": 1 /* Error */ + }, + "Function '{0}' declared a non-void return type, but has no return expression.": { + "code": 2125, + "category": 1 /* Error */ + }, + "Getters must return a value.": { + "code": 2126, + "category": 1 /* Error */ + }, + "Getter and setter accessors do not agree in visibility.": { + "code": 2127, + "category": 1 /* Error */ + }, + "Invalid left-hand side of assignment expression.": { + "code": 2130, + "category": 1 /* Error */ + }, + "Function declared a non-void return type, but has no return expression.": { + "code": 2131, + "category": 1 /* Error */ + }, + "Cannot resolve return type reference.": { + "code": 2132, + "category": 1 /* Error */ + }, + "Constructors cannot have a return type of 'void'.": { + "code": 2133, + "category": 1 /* Error */ + }, + "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'.": { + "code": 2134, + "category": 1 /* Error */ + }, + "All symbols within a with block will be resolved to 'any'.": { + "code": 2135, + "category": 1 /* Error */ + }, + "Import declarations in an internal module cannot reference an external module.": { + "code": 2136, + "category": 1 /* Error */ + }, + "Class {0} declares interface {1} but does not implement it:{NL}{2}": { + "code": 2137, + "category": 1 /* Error */ + }, + "Class {0} declares class {1} as an interface but does not implement it:{NL}{2}": { + "code": 2138, + "category": 1 /* Error */ + }, + "The operand of an increment or decrement operator must be a variable, property or indexer.": { + "code": 2139, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in static initializers in a class body.": { + "code": 2140, + "category": 1 /* Error */ + }, + "Class '{0}' cannot extend class '{1}':{NL}{2}": { + "code": 2141, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot extend class '{1}':{NL}{2}": { + "code": 2142, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot extend interface '{1}':{NL}{2}": { + "code": 2143, + "category": 1 /* Error */ + }, + "Duplicate overload signature for '{0}'.": { + "code": 2144, + "category": 1 /* Error */ + }, + "Duplicate constructor overload signature.": { + "code": 2145, + "category": 1 /* Error */ + }, + "Duplicate overload call signature.": { + "code": 2146, + "category": 1 /* Error */ + }, + "Duplicate overload construct signature.": { + "code": 2147, + "category": 1 /* Error */ + }, + "Overload signature is not compatible with function definition.": { + "code": 2148, + "category": 1 /* Error */ + }, + "Overload signature is not compatible with function definition:{NL}{0}": { + "code": 2149, + "category": 1 /* Error */ + }, + "Overload signatures must all be public or private.": { + "code": 2150, + "category": 1 /* Error */ + }, + "Overload signatures must all be exported or not exported.": { + "code": 2151, + "category": 1 /* Error */ + }, + "Overload signatures must all be ambient or non-ambient.": { + "code": 2152, + "category": 1 /* Error */ + }, + "Overload signatures must all be optional or required.": { + "code": 2153, + "category": 1 /* Error */ + }, + "Specialized overload signature is not subtype of any non-specialized signature.": { + "code": 2154, + "category": 1 /* Error */ + }, + "'this' cannot be referenced in constructor arguments.": { + "code": 2155, + "category": 1 /* Error */ + }, + "Instance member cannot be accessed off a class.": { + "code": 2157, + "category": 1 /* Error */ + }, + "Untyped function calls may not accept type arguments.": { + "code": 2158, + "category": 1 /* Error */ + }, + "Non-generic functions may not accept type arguments.": { + "code": 2159, + "category": 1 /* Error */ + }, + "A generic type may not reference itself with a wrapped form of its own type parameters.": { + "code": 2160, + "category": 1 /* Error */ + }, + "Rest parameters must be array types.": { + "code": 2162, + "category": 1 /* Error */ + }, + "Overload signature implementation cannot use specialized type.": { + "code": 2163, + "category": 1 /* Error */ + }, + "Export assignments may only be used at the top-level of external modules.": { + "code": 2164, + "category": 1 /* Error */ + }, + "Export assignments may only be made with variables, functions, classes, interfaces, enums and internal modules.": { + "code": 2165, + "category": 1 /* Error */ + }, + "Only public methods of the base class are accessible via the 'super' keyword.": { + "code": 2166, + "category": 1 /* Error */ + }, + "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}'.": { + "code": 2167, + "category": 1 /* Error */ + }, + "Numeric indexer type '{0}' must be a subtype of string indexer type '{1}':{NL}{2}": { + "code": 2168, + "category": 1 /* Error */ + }, + "All numerically named properties must be subtypes of numeric indexer type '{0}'.": { + "code": 2169, + "category": 1 /* Error */ + }, + "All numerically named properties must be subtypes of numeric indexer type '{0}':{NL}{1}": { + "code": 2170, + "category": 1 /* Error */ + }, + "All named properties must be subtypes of string indexer type '{0}'.": { + "code": 2171, + "category": 1 /* Error */ + }, + "All named properties must be subtypes of string indexer type '{0}':{NL}{1}": { + "code": 2172, + "category": 1 /* Error */ + }, + "Generic type references must include all type arguments.": { + "code": 2173, + "category": 1 /* Error */ + }, + "Default arguments are not allowed in an overload parameter.": { + "code": 2174, + "category": 1 /* Error */ + }, + "Overloads cannot differ only by return type.": { + "code": 2175, + "category": 1 /* Error */ + }, + "Function expression declared a non-void return type, but has no return expression.": { + "code": 2176, + "category": 1 /* Error */ + }, + "Import declaration referencing identifier from internal module can only be made with variables, functions, classes, interfaces, enums and internal modules.": { + "code": 2177, + "category": 1 /* Error */ + }, + "Could not find symbol '{0}' in module '{1}'.": { + "code": 2178, + "category": 1 /* Error */ + }, + "Unable to resolve module reference '{0}'.": { + "code": 2179, + "category": 1 /* Error */ + }, + "Could not find module '{0}' in module '{1}'.": { + "code": 2180, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned value with type that has or is using private type '{1}'.": { + "code": 2181, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned value with type that is using inaccessible module '{1}'.": { + "code": 2182, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned type that has or is using private type '{1}'.": { + "code": 2183, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned type that is using inaccessible module '{1}'.": { + "code": 2184, + "category": 1 /* Error */ + }, + "Exported import declaration '{0}' is assigned container that is or is using inaccessible module '{1}'.": { + "code": 2185, + "category": 1 /* Error */ + }, + "Type reference '{0}' in extends clause does not reference constructor function for '{1}'.": { + "code": 2186, + "category": 1 /* Error */ + }, + "Internal module reference '{0}' in import declaration does not reference module instance for '{1}'.": { + "code": 2187, + "category": 1 /* Error */ + }, + "Module '{0}' cannot merge with previous declaration of '{1}' in a different file '{2}'.": { + "code": 2188, + "category": 1 /* Error */ + }, + "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}':{NL}{3}": { + "code": 2189, + "category": 1 /* Error */ + }, + "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it.": { + "code": 2190, + "category": 1 /* Error */ + }, + "Ambient external module declaration cannot be reopened.": { + "code": 2191, + "category": 1 /* Error */ + }, + "All declarations of merged declaration '{0}' must be exported or not exported.": { + "code": 2192, + "category": 1 /* Error */ + }, + "'super' cannot be referenced in constructor arguments.": { + "code": 2193, + "category": 1 /* Error */ + }, + "Return type of constructor signature must be assignable to the instance type of the class.": { + "code": 2194, + "category": 1 /* Error */ + }, + "Ambient external module declaration must be defined in global context.": { + "code": 2195, + "category": 1 /* Error */ + }, + "Ambient external module declaration cannot specify relative module name.": { + "code": 2196, + "category": 1 /* Error */ + }, + "Import declaration in an ambient external module declaration cannot reference external module through relative external module name.": { + "code": 2197, + "category": 1 /* Error */ + }, + "Could not find the best common type of types of all return statement expressions.": { + "code": 2198, + "category": 1 /* Error */ + }, + "Import declaration cannot refer to external module reference when --noResolve option is set.": { + "code": 2199, + "category": 1 /* Error */ + }, + "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference.": { + "code": 2200, + "category": 1 /* Error */ + }, + "'continue' statement can only be used within an enclosing iteration statement.": { + "code": 2201, + "category": 1 /* Error */ + }, + "'break' statement can only be used within an enclosing iteration or switch statement.": { + "code": 2202, + "category": 1 /* Error */ + }, + "Jump target not found.": { + "code": 2203, + "category": 1 /* Error */ + }, + "Jump target cannot cross function boundary.": { + "code": 2204, + "category": 1 /* Error */ + }, + "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference.": { + "code": 2205, + "category": 1 /* Error */ + }, + "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference.": { + "code": 2206, + "category": 1 /* Error */ + }, + "Expression resolves to '_super' that compiler uses to capture base class reference.": { + "code": 2207, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of constructor signature from exported interface has or is using private type '{1}'.": { + "code": 2208, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of call signature from exported interface has or is using private type '{1}'.": { + "code": 2209, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public static method from exported class has or is using private type '{1}'.": { + "code": 2210, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public method from exported class has or is using private type '{1}'.": { + "code": 2211, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of method from exported interface has or is using private type '{1}'.": { + "code": 2212, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported function has or is using private type '{1}'.": { + "code": 2213, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of constructor signature from exported interface is using inaccessible module {1}.": { + "code": 2214, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of call signature from exported interface is using inaccessible module {1}": { + "code": 2215, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public static method from exported class is using inaccessible module {1}.": { + "code": 2216, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of public method from exported class is using inaccessible module {1}.": { + "code": 2217, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of method from exported interface is using inaccessible module {1}.": { + "code": 2218, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported function is using inaccessible module {1}.": { + "code": 2219, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported class has or is using private type '{1}'.": { + "code": 2220, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported interface has or is using private type '{1}'.": { + "code": 2221, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported class is using inaccessible module {1}.": { + "code": 2222, + "category": 1 /* Error */ + }, + "TypeParameter '{0}' of exported interface is using inaccessible module {1}.": { + "code": 2223, + "category": 1 /* Error */ + }, + "Duplicate identifier '_i'. Compiler uses '_i' to initialize rest parameter.": { + "code": 2224, + "category": 1 /* Error */ + }, + "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters.": { + "code": 2225, + "category": 1 /* Error */ + }, + "Type of conditional '{0}' must be identical to '{1}' or '{2}'.": { + "code": 2226, + "category": 1 /* Error */ + }, + "Type of conditional '{0}' must be identical to '{1}', '{2}' or '{3}'.": { + "code": 2227, + "category": 1 /* Error */ + }, + "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of an external module.": { + "code": 2228, + "category": 1 /* Error */ + }, + "Type '{0}' is missing property '{1}' from type '{2}'.": { + "code": 4000, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are incompatible.": { + "code": 4001, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are incompatible:{NL}{3}": { + "code": 4002, + "category": 3 /* NoPrefix */ + }, + "Property '{0}' defined as private in type '{1}' is defined as public in type '{2}'.": { + "code": 4003, + "category": 3 /* NoPrefix */ + }, + "Property '{0}' defined as public in type '{1}' is defined as private in type '{2}'.": { + "code": 4004, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' define property '{2}' as private.": { + "code": 4005, + "category": 3 /* NoPrefix */ + }, + "Call signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4006, + "category": 3 /* NoPrefix */ + }, + "Call signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4007, + "category": 3 /* NoPrefix */ + }, + "Type '{0}' requires a call signature, but type '{1}' lacks one.": { + "code": 4008, + "category": 3 /* NoPrefix */ + }, + "Construct signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4009, + "category": 3 /* NoPrefix */ + }, + "Construct signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4010, + "category": 3 /* NoPrefix */ + }, + "Type '{0}' requires a construct signature, but type '{1}' lacks one.": { + "code": 4011, + "category": 3 /* NoPrefix */ + }, + "Index signatures of types '{0}' and '{1}' are incompatible.": { + "code": 4012, + "category": 3 /* NoPrefix */ + }, + "Index signatures of types '{0}' and '{1}' are incompatible:{NL}{2}": { + "code": 4013, + "category": 3 /* NoPrefix */ + }, + "Call signature expects {0} or fewer parameters.": { + "code": 4014, + "category": 3 /* NoPrefix */ + }, + "Could not apply type '{0}' to argument {1} which is of type '{2}'.": { + "code": 4015, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function.": { + "code": 4016, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function.": { + "code": 4017, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor.": { + "code": 4018, + "category": 3 /* NoPrefix */ + }, + "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property.": { + "code": 4019, + "category": 3 /* NoPrefix */ + }, + "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible.": { + "code": 4020, + "category": 3 /* NoPrefix */ + }, + "Types of static property '{0}' of class '{1}' and class '{2}' are incompatible:{NL}{3}": { + "code": 4021, + "category": 3 /* NoPrefix */ + }, + "Type reference cannot refer to container '{0}'.": { + "code": 4022, + "category": 1 /* Error */ + }, + "Type reference must refer to type.": { + "code": 4023, + "category": 1 /* Error */ + }, + "Enums with multiple declarations must provide an initializer for the first enum element.": { + "code": 4024, + "category": 1 /* Error */ + }, + " (+ {0} overload(s))": { + "code": 4025, + "category": 2 /* Message */ + }, + "Variable declaration cannot have the same name as an import declaration.": { + "code": 4026, + "category": 1 /* Error */ + }, + "Signature expected {0} type arguments, got {1} instead.": { + "code": 4027, + "category": 1 /* Error */ + }, + "Property '{0}' defined as optional in type '{1}', but is required in type '{2}'.": { + "code": 4028, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference do not refer to same named type.": { + "code": 4029, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments.": { + "code": 4030, + "category": 3 /* NoPrefix */ + }, + "Types '{0}' and '{1}' originating in inifinitely expanding type reference have incompatible type arguments:{NL}{2}": { + "code": 4031, + "category": 3 /* NoPrefix */ + }, + "Types of property '{0}' of types '{1}' and '{2}' are not identical.": { + "code": 4032, + "category": 3 /* NoPrefix */ + }, + "Types of string indexer of types '{0}' and '{1}' are not identical.": { + "code": 4033, + "category": 3 /* NoPrefix */ + }, + "Types of number indexer of types '{0}' and '{1}' are not identical.": { + "code": 4034, + "category": 3 /* NoPrefix */ + }, + "Type of number indexer in type '{0}' is not a subtype of string indexer type in type '{1}'.{NL}{2}": { + "code": 4035, + "category": 3 /* NoPrefix */ + }, + "Type of property '{0}' in type '{1}' is not a subtype of string indexer type in type '{2}'.{NL}{3}": { + "code": 4036, + "category": 3 /* NoPrefix */ + }, + "Type of property '{0}' in type '{1}' is not a subtype of number indexer type in type '{2}'.{NL}{3}": { + "code": 4037, + "category": 3 /* NoPrefix */ + }, + "Current host does not support '{0}' option.": { + "code": 5001, + "category": 1 /* Error */ + }, + "ECMAScript target version '{0}' not supported. Specify a valid target version: '{1}' (default), or '{2}'": { + "code": 5002, + "category": 1 /* Error */ + }, + "Module code generation '{0}' not supported.": { + "code": 5003, + "category": 1 /* Error */ + }, + "Could not find file: '{0}'.": { + "code": 5004, + "category": 1 /* Error */ + }, + "A file cannot have a reference to itself.": { + "code": 5006, + "category": 1 /* Error */ + }, + "Cannot resolve referenced file: '{0}'.": { + "code": 5007, + "category": 1 /* Error */ + }, + "Cannot find the common subdirectory path for the input files.": { + "code": 5009, + "category": 1 /* Error */ + }, + "Emit Error: {0}.": { + "code": 5011, + "category": 1 /* Error */ + }, + "Cannot read file '{0}': {1}": { + "code": 5012, + "category": 1 /* Error */ + }, + "Unsupported file encoding.": { + "code": 5013, + "category": 3 /* NoPrefix */ + }, + "Locale must be of the form or -. For example '{0}' or '{1}'.": { + "code": 5014, + "category": 1 /* Error */ + }, + "Unsupported locale: '{0}'.": { + "code": 5015, + "category": 1 /* Error */ + }, + "Execution Failed.{NL}": { + "code": 5016, + "category": 1 /* Error */ + }, + "Invalid call to 'up'": { + "code": 5019, + "category": 1 /* Error */ + }, + "Invalid call to 'down'": { + "code": 5020, + "category": 1 /* Error */ + }, + "Base64 value '{0}' finished with a continuation bit.": { + "code": 5021, + "category": 1 /* Error */ + }, + "Unknown option '{0}'": { + "code": 5023, + "category": 1 /* Error */ + }, + "Expected {0} arguments to message, got {1} instead.": { + "code": 5024, + "category": 1 /* Error */ + }, + "Expected the message '{0}' to have {1} arguments, but it had {2}": { + "code": 5025, + "category": 1 /* Error */ + }, + "Could not delete file '{0}'": { + "code": 5034, + "category": 1 /* Error */ + }, + "Could not create directory '{0}'": { + "code": 5035, + "category": 1 /* Error */ + }, + "Error while executing file '{0}': ": { + "code": 5036, + "category": 1 /* Error */ + }, + "Cannot compile external modules unless the '--module' flag is provided.": { + "code": 5037, + "category": 1 /* Error */ + }, + "Option mapRoot cannot be specified without specifying sourcemap option.": { + "code": 5038, + "category": 1 /* Error */ + }, + "Option sourceRoot cannot be specified without specifying sourcemap option.": { + "code": 5039, + "category": 1 /* Error */ + }, + "Options mapRoot and sourceRoot cannot be specified without specifying sourcemap option.": { + "code": 5040, + "category": 1 /* Error */ + }, + "Option '{0}' specified without '{1}'": { + "code": 5041, + "category": 1 /* Error */ + }, + "'codepage' option not supported on current platform.": { + "code": 5042, + "category": 1 /* Error */ + }, + "Concatenate and emit output to single file.": { + "code": 6001, + "category": 2 /* Message */ + }, + "Generates corresponding {0} file.": { + "code": 6002, + "category": 2 /* Message */ + }, + "Specifies the location where debugger should locate map files instead of generated locations.": { + "code": 6003, + "category": 2 /* Message */ + }, + "Specifies the location where debugger should locate TypeScript files instead of source locations.": { + "code": 6004, + "category": 2 /* Message */ + }, + "Watch input files.": { + "code": 6005, + "category": 2 /* Message */ + }, + "Redirect output structure to the directory.": { + "code": 6006, + "category": 2 /* Message */ + }, + "Do not emit comments to output.": { + "code": 6009, + "category": 2 /* Message */ + }, + "Skip resolution and preprocessing.": { + "code": 6010, + "category": 2 /* Message */ + }, + "Specify ECMAScript target version: '{0}' (default), or '{1}'": { + "code": 6015, + "category": 2 /* Message */ + }, + "Specify module code generation: '{0}' or '{1}'": { + "code": 6016, + "category": 2 /* Message */ + }, + "Print this message.": { + "code": 6017, + "category": 2 /* Message */ + }, + "Print the compiler's version: {0}": { + "code": 6019, + "category": 2 /* Message */ + }, + "Allow use of deprecated '{0}' keyword when referencing an external module.": { + "code": 6021, + "category": 2 /* Message */ + }, + "Specify locale for errors and messages. For example '{0}' or '{1}'": { + "code": 6022, + "category": 2 /* Message */ + }, + "Syntax: {0}": { + "code": 6023, + "category": 2 /* Message */ + }, + "options": { + "code": 6024, + "category": 2 /* Message */ + }, + "file1": { + "code": 6025, + "category": 2 /* Message */ + }, + "Examples:": { + "code": 6026, + "category": 2 /* Message */ + }, + "Options:": { + "code": 6027, + "category": 2 /* Message */ + }, + "Insert command line options and files from a file.": { + "code": 6030, + "category": 2 /* Message */ + }, + "Version {0}": { + "code": 6029, + "category": 2 /* Message */ + }, + "Use the '{0}' flag to see options.": { + "code": 6031, + "category": 2 /* Message */ + }, + "{NL}Recompiling ({0}):": { + "code": 6032, + "category": 2 /* Message */ + }, + "STRING": { + "code": 6033, + "category": 2 /* Message */ + }, + "KIND": { + "code": 6034, + "category": 2 /* Message */ + }, + "file2": { + "code": 6035, + "category": 2 /* Message */ + }, + "VERSION": { + "code": 6036, + "category": 2 /* Message */ + }, + "LOCATION": { + "code": 6037, + "category": 2 /* Message */ + }, + "DIRECTORY": { + "code": 6038, + "category": 2 /* Message */ + }, + "NUMBER": { + "code": 6039, + "category": 2 /* Message */ + }, + "Specify the codepage to use when opening source files.": { + "code": 6040, + "category": 2 /* Message */ + }, + "This version of the Javascript runtime does not support the '{0}' function.": { + "code": 7000, + "category": 1 /* Error */ + }, + "Unknown rule.": { + "code": 7002, + "category": 1 /* Error */ + }, + "Invalid line number ({0})": { + "code": 7003, + "category": 1 /* Error */ + }, + "Warn on expressions and declarations with an implied 'any' type.": { + "code": 7004, + "category": 2 /* Message */ + }, + "Variable '{0}' implicitly has an 'any' type.": { + "code": 7005, + "category": 1 /* Error */ + }, + "Parameter '{0}' of '{1}' implicitly has an 'any' type.": { + "code": 7006, + "category": 1 /* Error */ + }, + "Parameter '{0}' of function type implicitly has an 'any' type.": { + "code": 7007, + "category": 1 /* Error */ + }, + "Member '{0}' of object type implicitly has an 'any' type.": { + "code": 7008, + "category": 1 /* Error */ + }, + "'new' expression, which lacks a constructor signature, implicitly has an 'any' type.": { + "code": 7009, + "category": 1 /* Error */ + }, + "'{0}', which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7010, + "category": 1 /* Error */ + }, + "Function expression, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7011, + "category": 1 /* Error */ + }, + "Parameter '{0}' of lambda function implicitly has an 'any' type.": { + "code": 7012, + "category": 1 /* Error */ + }, + "Constructor signature, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7013, + "category": 1 /* Error */ + }, + "Lambda Function, which lacks return-type annotation, implicitly has an 'any' return type.": { + "code": 7014, + "category": 1 /* Error */ + }, + "Array Literal implicitly has an 'any' type from widening.": { + "code": 7015, + "category": 1 /* Error */ + }, + "'{0}', which lacks 'get' accessor and parameter type annotation on 'set' accessor, implicitly has an 'any' type.": { + "code": 7016, + "category": 1 /* Error */ + } + }; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (CharacterCodes) { + CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter"; + CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter"; + + CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed"; + CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn"; + CharacterCodes[CharacterCodes["lineSeparator"] = 0x2028] = "lineSeparator"; + CharacterCodes[CharacterCodes["paragraphSeparator"] = 0x2029] = "paragraphSeparator"; + + CharacterCodes[CharacterCodes["nextLine"] = 0x0085] = "nextLine"; + + CharacterCodes[CharacterCodes["space"] = 0x0020] = "space"; + CharacterCodes[CharacterCodes["nonBreakingSpace"] = 0x00A0] = "nonBreakingSpace"; + CharacterCodes[CharacterCodes["enQuad"] = 0x2000] = "enQuad"; + CharacterCodes[CharacterCodes["emQuad"] = 0x2001] = "emQuad"; + CharacterCodes[CharacterCodes["enSpace"] = 0x2002] = "enSpace"; + CharacterCodes[CharacterCodes["emSpace"] = 0x2003] = "emSpace"; + CharacterCodes[CharacterCodes["threePerEmSpace"] = 0x2004] = "threePerEmSpace"; + CharacterCodes[CharacterCodes["fourPerEmSpace"] = 0x2005] = "fourPerEmSpace"; + CharacterCodes[CharacterCodes["sixPerEmSpace"] = 0x2006] = "sixPerEmSpace"; + CharacterCodes[CharacterCodes["figureSpace"] = 0x2007] = "figureSpace"; + CharacterCodes[CharacterCodes["punctuationSpace"] = 0x2008] = "punctuationSpace"; + CharacterCodes[CharacterCodes["thinSpace"] = 0x2009] = "thinSpace"; + CharacterCodes[CharacterCodes["hairSpace"] = 0x200A] = "hairSpace"; + CharacterCodes[CharacterCodes["zeroWidthSpace"] = 0x200B] = "zeroWidthSpace"; + CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 0x202F] = "narrowNoBreakSpace"; + CharacterCodes[CharacterCodes["ideographicSpace"] = 0x3000] = "ideographicSpace"; + + CharacterCodes[CharacterCodes["_"] = 95] = "_"; + CharacterCodes[CharacterCodes["$"] = 36] = "$"; + + CharacterCodes[CharacterCodes["_0"] = 48] = "_0"; + CharacterCodes[CharacterCodes["_7"] = 55] = "_7"; + CharacterCodes[CharacterCodes["_9"] = 57] = "_9"; + + CharacterCodes[CharacterCodes["a"] = 97] = "a"; + CharacterCodes[CharacterCodes["b"] = 98] = "b"; + CharacterCodes[CharacterCodes["c"] = 99] = "c"; + CharacterCodes[CharacterCodes["d"] = 100] = "d"; + CharacterCodes[CharacterCodes["e"] = 101] = "e"; + CharacterCodes[CharacterCodes["f"] = 102] = "f"; + CharacterCodes[CharacterCodes["g"] = 103] = "g"; + CharacterCodes[CharacterCodes["h"] = 104] = "h"; + CharacterCodes[CharacterCodes["i"] = 105] = "i"; + CharacterCodes[CharacterCodes["k"] = 107] = "k"; + CharacterCodes[CharacterCodes["l"] = 108] = "l"; + CharacterCodes[CharacterCodes["m"] = 109] = "m"; + CharacterCodes[CharacterCodes["n"] = 110] = "n"; + CharacterCodes[CharacterCodes["o"] = 111] = "o"; + CharacterCodes[CharacterCodes["p"] = 112] = "p"; + CharacterCodes[CharacterCodes["q"] = 113] = "q"; + CharacterCodes[CharacterCodes["r"] = 114] = "r"; + CharacterCodes[CharacterCodes["s"] = 115] = "s"; + CharacterCodes[CharacterCodes["t"] = 116] = "t"; + CharacterCodes[CharacterCodes["u"] = 117] = "u"; + CharacterCodes[CharacterCodes["v"] = 118] = "v"; + CharacterCodes[CharacterCodes["w"] = 119] = "w"; + CharacterCodes[CharacterCodes["x"] = 120] = "x"; + CharacterCodes[CharacterCodes["y"] = 121] = "y"; + CharacterCodes[CharacterCodes["z"] = 122] = "z"; + + CharacterCodes[CharacterCodes["A"] = 65] = "A"; + CharacterCodes[CharacterCodes["E"] = 69] = "E"; + CharacterCodes[CharacterCodes["F"] = 70] = "F"; + CharacterCodes[CharacterCodes["X"] = 88] = "X"; + CharacterCodes[CharacterCodes["Z"] = 90] = "Z"; + + CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand"; + CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk"; + CharacterCodes[CharacterCodes["at"] = 64] = "at"; + CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash"; + CharacterCodes[CharacterCodes["bar"] = 124] = "bar"; + CharacterCodes[CharacterCodes["caret"] = 94] = "caret"; + CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace"; + CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket"; + CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen"; + CharacterCodes[CharacterCodes["colon"] = 58] = "colon"; + CharacterCodes[CharacterCodes["comma"] = 44] = "comma"; + CharacterCodes[CharacterCodes["dot"] = 46] = "dot"; + CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote"; + CharacterCodes[CharacterCodes["equals"] = 61] = "equals"; + CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation"; + CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan"; + CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan"; + CharacterCodes[CharacterCodes["minus"] = 45] = "minus"; + CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace"; + CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket"; + CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen"; + CharacterCodes[CharacterCodes["percent"] = 37] = "percent"; + CharacterCodes[CharacterCodes["plus"] = 43] = "plus"; + CharacterCodes[CharacterCodes["question"] = 63] = "question"; + CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon"; + CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote"; + CharacterCodes[CharacterCodes["slash"] = 47] = "slash"; + CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde"; + + CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace"; + CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed"; + CharacterCodes[CharacterCodes["byteOrderMark"] = 0xFEFF] = "byteOrderMark"; + CharacterCodes[CharacterCodes["tab"] = 9] = "tab"; + CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab"; + })(TypeScript.CharacterCodes || (TypeScript.CharacterCodes = {})); + var CharacterCodes = TypeScript.CharacterCodes; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + + + (function (ScriptSnapshot) { + var StringScriptSnapshot = (function () { + function StringScriptSnapshot(text) { + this.text = text; + this._lineStartPositions = null; + } + StringScriptSnapshot.prototype.getText = function (start, end) { + return this.text.substring(start, end); + }; + + StringScriptSnapshot.prototype.getLength = function () { + return this.text.length; + }; + + StringScriptSnapshot.prototype.getLineStartPositions = function () { + if (!this._lineStartPositions) { + this._lineStartPositions = TypeScript.TextUtilities.parseLineStarts(this.text); + } + + return this._lineStartPositions; + }; + + StringScriptSnapshot.prototype.getTextChangeRangeSinceVersion = function (scriptVersion) { + throw TypeScript.Errors.notYetImplemented(); + }; + return StringScriptSnapshot; + })(); + + function fromString(text) { + return new StringScriptSnapshot(text); + } + ScriptSnapshot.fromString = fromString; + })(TypeScript.ScriptSnapshot || (TypeScript.ScriptSnapshot = {})); + var ScriptSnapshot = TypeScript.ScriptSnapshot; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (LineMap1) { + function fromSimpleText(text) { + return new TypeScript.LineMap(function () { + return TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) { + return text.charCodeAt(index); + }, length: text.length() }); + }, text.length()); + } + LineMap1.fromSimpleText = fromSimpleText; + + function fromScriptSnapshot(scriptSnapshot) { + return new TypeScript.LineMap(function () { + return scriptSnapshot.getLineStartPositions(); + }, scriptSnapshot.getLength()); + } + LineMap1.fromScriptSnapshot = fromScriptSnapshot; + + function fromString(text) { + return new TypeScript.LineMap(function () { + return TypeScript.TextUtilities.parseLineStarts(text); + }, text.length); + } + LineMap1.fromString = fromString; + })(TypeScript.LineMap1 || (TypeScript.LineMap1 = {})); + var LineMap1 = TypeScript.LineMap1; +})(TypeScript || (TypeScript = {})); +var __extends = this.__extends || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + __.prototype = b.prototype; + d.prototype = new __(); +}; +var TypeScript; +(function (TypeScript) { + (function (TextFactory) { + function getStartAndLengthOfLineBreakEndingAt(text, index, info) { + var c = text.charCodeAt(index); + if (c === 10 /* lineFeed */) { + if (index > 0 && text.charCodeAt(index - 1) === 13 /* carriageReturn */) { + info.startPosition = index - 1; + info.length = 2; + } else { + info.startPosition = index; + info.length = 1; + } + } else if (TypeScript.TextUtilities.isAnyLineBreakCharacter(c)) { + info.startPosition = index; + info.length = 1; + } else { + info.startPosition = index + 1; + info.length = 0; + } + } + + var LinebreakInfo = (function () { + function LinebreakInfo(startPosition, length) { + this.startPosition = startPosition; + this.length = length; + } + return LinebreakInfo; + })(); + + var TextLine = (function () { + function TextLine(text, body, lineBreakLength, lineNumber) { + this._text = null; + this._textSpan = null; + if (text === null) { + throw TypeScript.Errors.argumentNull('text'); + } + TypeScript.Debug.assert(lineBreakLength >= 0); + TypeScript.Debug.assert(lineNumber >= 0); + this._text = text; + this._textSpan = body; + this._lineBreakLength = lineBreakLength; + this._lineNumber = lineNumber; + } + TextLine.prototype.start = function () { + return this._textSpan.start(); + }; + + TextLine.prototype.end = function () { + return this._textSpan.end(); + }; + + TextLine.prototype.endIncludingLineBreak = function () { + return this.end() + this._lineBreakLength; + }; + + TextLine.prototype.extent = function () { + return this._textSpan; + }; + + TextLine.prototype.extentIncludingLineBreak = function () { + return TypeScript.TextSpan.fromBounds(this.start(), this.endIncludingLineBreak()); + }; + + TextLine.prototype.toString = function () { + return this._text.toString(this._textSpan); + }; + + TextLine.prototype.lineNumber = function () { + return this._lineNumber; + }; + return TextLine; + })(); + + var TextBase = (function () { + function TextBase() { + this.linebreakInfo = new LinebreakInfo(0, 0); + this.lastLineFoundForPosition = null; + } + TextBase.prototype.length = function () { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.charCodeAt = function (position) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.checkSubSpan = function (span) { + if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("span"); + } + }; + + TextBase.prototype.toString = function (span) { + if (typeof span === "undefined") { span = null; } + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SubText(this, span); + }; + + TextBase.prototype.substr = function (start, length, intern) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.lineCount = function () { + return this._lineStarts().length; + }; + + TextBase.prototype.lines = function () { + var lines = []; + + var length = this.lineCount(); + for (var i = 0; i < length; ++i) { + lines[i] = this.getLineFromLineNumber(i); + } + + return lines; + }; + + TextBase.prototype.lineMap = function () { + var _this = this; + return new TypeScript.LineMap(function () { + return _this._lineStarts(); + }, this.length()); + }; + + TextBase.prototype._lineStarts = function () { + throw TypeScript.Errors.abstract(); + }; + + TextBase.prototype.getLineFromLineNumber = function (lineNumber) { + var lineStarts = this._lineStarts(); + + if (lineNumber < 0 || lineNumber >= lineStarts.length) { + throw TypeScript.Errors.argumentOutOfRange("lineNumber"); + } + + var first = lineStarts[lineNumber]; + if (lineNumber === lineStarts.length - 1) { + return new TextLine(this, new TypeScript.TextSpan(first, this.length() - first), 0, lineNumber); + } else { + getStartAndLengthOfLineBreakEndingAt(this, lineStarts[lineNumber + 1] - 1, this.linebreakInfo); + return new TextLine(this, new TypeScript.TextSpan(first, this.linebreakInfo.startPosition - first), this.linebreakInfo.length, lineNumber); + } + }; + + TextBase.prototype.getLineFromPosition = function (position) { + var lastFound = this.lastLineFoundForPosition; + if (lastFound !== null && lastFound.start() <= position && lastFound.endIncludingLineBreak() > position) { + return lastFound; + } + + var lineNumber = this.getLineNumberFromPosition(position); + + var result = this.getLineFromLineNumber(lineNumber); + this.lastLineFoundForPosition = result; + return result; + }; + + TextBase.prototype.getLineNumberFromPosition = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + if (position === this.length()) { + return this.lineCount() - 1; + } + + var lineNumber = TypeScript.ArrayUtilities.binarySearch(this._lineStarts(), position); + if (lineNumber < 0) { + lineNumber = (~lineNumber) - 1; + } + + return lineNumber; + }; + + TextBase.prototype.getLinePosition = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var lineNumber = this.getLineNumberFromPosition(position); + + return new TypeScript.LineAndCharacter(lineNumber, position - this._lineStarts()[lineNumber]); + }; + return TextBase; + })(); + + var SubText = (function (_super) { + __extends(SubText, _super); + function SubText(text, span) { + _super.call(this); + this._lazyLineStarts = null; + + if (text === null) { + throw TypeScript.Errors.argumentNull("text"); + } + + if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) { + throw TypeScript.Errors.argument("span"); + } + + this.text = text; + this.span = span; + } + SubText.prototype.length = function () { + return this.span.length(); + }; + + SubText.prototype.charCodeAt = function (position) { + if (position < 0 || position > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + return this.text.charCodeAt(this.span.start() + position); + }; + + SubText.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SubText(this.text, this.getCompositeSpan(span.start(), span.length())); + }; + + SubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var span = this.getCompositeSpan(sourceIndex, count); + this.text.copyTo(span.start(), destination, destinationIndex, span.length()); + }; + + SubText.prototype.substr = function (start, length, intern) { + var startInOriginalText = this.span.start() + start; + return this.text.substr(startInOriginalText, length, intern); + }; + + SubText.prototype.getCompositeSpan = function (start, length) { + var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start); + var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length); + return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart); + }; + + SubText.prototype._lineStarts = function () { + var _this = this; + if (!this._lazyLineStarts) { + this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts({ charCodeAt: function (index) { + return _this.charCodeAt(index); + }, length: this.length() }); + } + + return this._lazyLineStarts; + }; + return SubText; + })(TextBase); + + var StringText = (function (_super) { + __extends(StringText, _super); + function StringText(data) { + _super.call(this); + this.source = null; + this._lazyLineStarts = null; + + if (data === null) { + throw TypeScript.Errors.argumentNull("data"); + } + + this.source = data; + } + StringText.prototype.length = function () { + return this.source.length; + }; + + StringText.prototype.charCodeAt = function (position) { + if (position < 0 || position >= this.source.length) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + return this.source.charCodeAt(position); + }; + + StringText.prototype.substr = function (start, length, intern) { + return this.source.substr(start, length); + }; + + StringText.prototype.toString = function (span) { + if (typeof span === "undefined") { span = null; } + if (span === null) { + span = new TypeScript.TextSpan(0, this.length()); + } + + this.checkSubSpan(span); + + if (span.start() === 0 && span.length() === this.length()) { + return this.source; + } + + return this.source.substr(span.start(), span.length()); + }; + + StringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + TypeScript.StringUtilities.copyTo(this.source, sourceIndex, destination, destinationIndex, count); + }; + + StringText.prototype._lineStarts = function () { + if (this._lazyLineStarts === null) { + this._lazyLineStarts = TypeScript.TextUtilities.parseLineStarts(this.source); + } + + return this._lazyLineStarts; + }; + return StringText; + })(TextBase); + + function createText(value) { + return new StringText(value); + } + TextFactory.createText = createText; + })(TypeScript.TextFactory || (TypeScript.TextFactory = {})); + var TextFactory = TypeScript.TextFactory; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (SimpleText) { + var SimpleSubText = (function () { + function SimpleSubText(text, span) { + this.text = null; + this.span = null; + if (text === null) { + throw TypeScript.Errors.argumentNull("text"); + } + + if (span.start() < 0 || span.start() >= text.length() || span.end() < 0 || span.end() > text.length()) { + throw TypeScript.Errors.argument("span"); + } + + this.text = text; + this.span = span; + } + SimpleSubText.prototype.checkSubSpan = function (span) { + if (span.start() < 0 || span.start() > this.length() || span.end() > this.length()) { + throw TypeScript.Errors.argumentOutOfRange("span"); + } + }; + + SimpleSubText.prototype.checkSubPosition = function (position) { + if (position < 0 || position >= this.length()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + }; + + SimpleSubText.prototype.length = function () { + return this.span.length(); + }; + + SimpleSubText.prototype.subText = function (span) { + this.checkSubSpan(span); + + return new SimpleSubText(this.text, this.getCompositeSpan(span.start(), span.length())); + }; + + SimpleSubText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var span = this.getCompositeSpan(sourceIndex, count); + this.text.copyTo(span.start(), destination, destinationIndex, span.length()); + }; + + SimpleSubText.prototype.substr = function (start, length, intern) { + var span = this.getCompositeSpan(start, length); + return this.text.substr(span.start(), span.length(), intern); + }; + + SimpleSubText.prototype.getCompositeSpan = function (start, length) { + var compositeStart = TypeScript.MathPrototype.min(this.text.length(), this.span.start() + start); + var compositeEnd = TypeScript.MathPrototype.min(this.text.length(), compositeStart + length); + return new TypeScript.TextSpan(compositeStart, compositeEnd - compositeStart); + }; + + SimpleSubText.prototype.charCodeAt = function (index) { + this.checkSubPosition(index); + return this.text.charCodeAt(this.span.start() + index); + }; + + SimpleSubText.prototype.lineMap = function () { + return TypeScript.LineMap1.fromSimpleText(this); + }; + return SimpleSubText; + })(); + + var SimpleStringText = (function () { + function SimpleStringText(value) { + this.value = value; + this._lineMap = null; + } + SimpleStringText.prototype.length = function () { + return this.value.length; + }; + + SimpleStringText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + TypeScript.StringUtilities.copyTo(this.value, sourceIndex, destination, destinationIndex, count); + }; + + SimpleStringText.prototype.substr = function (start, length, intern) { + if (intern) { + var array = length <= SimpleStringText.charArray.length ? SimpleStringText.charArray : TypeScript.ArrayUtilities.createArray(length, 0); + this.copyTo(start, array, 0, length); + return TypeScript.Collections.DefaultStringTable.addCharArray(array, 0, length); + } + + return this.value.substr(start, length); + }; + + SimpleStringText.prototype.subText = function (span) { + return new SimpleSubText(this, span); + }; + + SimpleStringText.prototype.charCodeAt = function (index) { + return this.value.charCodeAt(index); + }; + + SimpleStringText.prototype.lineMap = function () { + if (!this._lineMap) { + this._lineMap = TypeScript.LineMap1.fromString(this.value); + } + + return this._lineMap; + }; + SimpleStringText.charArray = TypeScript.ArrayUtilities.createArray(1024, 0); + return SimpleStringText; + })(); + + var SimpleScriptSnapshotText = (function () { + function SimpleScriptSnapshotText(scriptSnapshot) { + this.scriptSnapshot = scriptSnapshot; + } + SimpleScriptSnapshotText.prototype.charCodeAt = function (index) { + return this.scriptSnapshot.getText(index, index + 1).charCodeAt(0); + }; + + SimpleScriptSnapshotText.prototype.length = function () { + return this.scriptSnapshot.getLength(); + }; + + SimpleScriptSnapshotText.prototype.copyTo = function (sourceIndex, destination, destinationIndex, count) { + var text = this.scriptSnapshot.getText(sourceIndex, sourceIndex + count); + TypeScript.StringUtilities.copyTo(text, 0, destination, destinationIndex, count); + }; + + SimpleScriptSnapshotText.prototype.substr = function (start, length, intern) { + return this.scriptSnapshot.getText(start, start + length); + }; + + SimpleScriptSnapshotText.prototype.subText = function (span) { + return new SimpleSubText(this, span); + }; + + SimpleScriptSnapshotText.prototype.lineMap = function () { + var _this = this; + return new TypeScript.LineMap(function () { + return _this.scriptSnapshot.getLineStartPositions(); + }, this.length()); + }; + return SimpleScriptSnapshotText; + })(); + + function fromString(value) { + return new SimpleStringText(value); + } + SimpleText.fromString = fromString; + + function fromScriptSnapshot(scriptSnapshot) { + return new SimpleScriptSnapshotText(scriptSnapshot); + } + SimpleText.fromScriptSnapshot = fromScriptSnapshot; + })(TypeScript.SimpleText || (TypeScript.SimpleText = {})); + var SimpleText = TypeScript.SimpleText; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (TextUtilities) { + function parseLineStarts(text) { + var length = text.length; + + if (0 === length) { + var result = new Array(); + result.push(0); + return result; + } + + var position = 0; + var index = 0; + var arrayBuilder = new Array(); + var lineNumber = 0; + + while (index < length) { + var c = text.charCodeAt(index); + var lineBreakLength; + + if (c > 13 /* carriageReturn */ && c <= 127) { + index++; + continue; + } else if (c === 13 /* carriageReturn */ && index + 1 < length && text.charCodeAt(index + 1) === 10 /* lineFeed */) { + lineBreakLength = 2; + } else if (c === 10 /* lineFeed */) { + lineBreakLength = 1; + } else { + lineBreakLength = TextUtilities.getLengthOfLineBreak(text, index); + } + + if (0 === lineBreakLength) { + index++; + } else { + arrayBuilder.push(position); + index += lineBreakLength; + position = index; + lineNumber++; + } + } + + arrayBuilder.push(position); + + return arrayBuilder; + } + TextUtilities.parseLineStarts = parseLineStarts; + + function getLengthOfLineBreakSlow(text, index, c) { + if (c === 13 /* carriageReturn */) { + var next = index + 1; + return (next < text.length) && 10 /* lineFeed */ === text.charCodeAt(next) ? 2 : 1; + } else if (isAnyLineBreakCharacter(c)) { + return 1; + } else { + return 0; + } + } + TextUtilities.getLengthOfLineBreakSlow = getLengthOfLineBreakSlow; + + function getLengthOfLineBreak(text, index) { + var c = text.charCodeAt(index); + + if (c > 13 /* carriageReturn */ && c <= 127) { + return 0; + } + + return getLengthOfLineBreakSlow(text, index, c); + } + TextUtilities.getLengthOfLineBreak = getLengthOfLineBreak; + + function isAnyLineBreakCharacter(c) { + return c === 10 /* lineFeed */ || c === 13 /* carriageReturn */ || c === 133 /* nextLine */ || c === 8232 /* lineSeparator */ || c === 8233 /* paragraphSeparator */; + } + TextUtilities.isAnyLineBreakCharacter = isAnyLineBreakCharacter; + })(TypeScript.TextUtilities || (TypeScript.TextUtilities = {})); + var TextUtilities = TypeScript.TextUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextSpan = (function () { + function TextSpan(start, length) { + if (start < 0) { + TypeScript.Errors.argument("start"); + } + + if (length < 0) { + TypeScript.Errors.argument("length"); + } + + this._start = start; + this._length = length; + } + TextSpan.prototype.start = function () { + return this._start; + }; + + TextSpan.prototype.length = function () { + return this._length; + }; + + TextSpan.prototype.end = function () { + return this._start + this._length; + }; + + TextSpan.prototype.isEmpty = function () { + return this._length === 0; + }; + + TextSpan.prototype.containsPosition = function (position) { + return position >= this._start && position < this.end(); + }; + + TextSpan.prototype.containsTextSpan = function (span) { + return span._start >= this._start && span.end() <= this.end(); + }; + + TextSpan.prototype.overlapsWith = function (span) { + var overlapStart = TypeScript.MathPrototype.max(this._start, span._start); + var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + return overlapStart < overlapEnd; + }; + + TextSpan.prototype.overlap = function (span) { + var overlapStart = TypeScript.MathPrototype.max(this._start, span._start); + var overlapEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + if (overlapStart < overlapEnd) { + return TextSpan.fromBounds(overlapStart, overlapEnd); + } + + return null; + }; + + TextSpan.prototype.intersectsWithTextSpan = function (span) { + return span._start <= this.end() && span.end() >= this._start; + }; + + TextSpan.prototype.intersectsWith = function (start, length) { + var end = start + length; + return start <= this.end() && end >= this._start; + }; + + TextSpan.prototype.intersectsWithPosition = function (position) { + return position <= this.end() && position >= this._start; + }; + + TextSpan.prototype.intersection = function (span) { + var intersectStart = TypeScript.MathPrototype.max(this._start, span._start); + var intersectEnd = TypeScript.MathPrototype.min(this.end(), span.end()); + + if (intersectStart <= intersectEnd) { + return TextSpan.fromBounds(intersectStart, intersectEnd); + } + + return null; + }; + + TextSpan.fromBounds = function (start, end) { + TypeScript.Debug.assert(start >= 0); + TypeScript.Debug.assert(end - start >= 0); + return new TextSpan(start, end - start); + }; + return TextSpan; + })(); + TypeScript.TextSpan = TextSpan; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextChangeRange = (function () { + function TextChangeRange(span, newLength) { + if (newLength < 0) { + throw TypeScript.Errors.argumentOutOfRange("newLength"); + } + + this._span = span; + this._newLength = newLength; + } + TextChangeRange.prototype.span = function () { + return this._span; + }; + + TextChangeRange.prototype.newLength = function () { + return this._newLength; + }; + + TextChangeRange.prototype.newSpan = function () { + return new TypeScript.TextSpan(this.span().start(), this.newLength()); + }; + + TextChangeRange.prototype.isUnchanged = function () { + return this.span().isEmpty() && this.newLength() === 0; + }; + + TextChangeRange.collapseChangesFromSingleVersion = function (changes) { + var diff = 0; + var start = 1073741823 /* Max31BitInteger */; + var end = 0; + + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + diff += change.newLength() - change.span().length(); + + if (change.span().start() < start) { + start = change.span().start(); + } + + if (change.span().end() > end) { + end = change.span().end(); + } + } + + if (start > end) { + return null; + } + + var combined = TypeScript.TextSpan.fromBounds(start, end); + var newLen = combined.length() + diff; + + return new TextChangeRange(combined, newLen); + }; + + TextChangeRange.collapseChangesAcrossMultipleVersions = function (changes) { + if (changes.length === 0) { + return TextChangeRange.unchanged; + } + + if (changes.length === 1) { + return changes[0]; + } + + var change0 = changes[0]; + + var oldStartN = change0.span().start(); + var oldEndN = change0.span().end(); + var newEndN = oldStartN + change0.newLength(); + + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + + var oldStart2 = nextChange.span().start(); + var oldEnd2 = nextChange.span().end(); + var newEnd2 = oldStart2 + nextChange.newLength(); + + oldStartN = TypeScript.MathPrototype.min(oldStart1, oldStart2); + oldEndN = TypeScript.MathPrototype.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = TypeScript.MathPrototype.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + + return new TextChangeRange(TypeScript.TextSpan.fromBounds(oldStartN, oldEndN), newEndN - oldStartN); + }; + TextChangeRange.unchanged = new TextChangeRange(new TypeScript.TextSpan(0, 0), 0); + return TextChangeRange; + })(); + TypeScript.TextChangeRange = TextChangeRange; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CharacterInfo = (function () { + function CharacterInfo() { + } + CharacterInfo.isDecimalDigit = function (c) { + return c >= 48 /* _0 */ && c <= 57 /* _9 */; + }; + CharacterInfo.isOctalDigit = function (c) { + return c >= 48 /* _0 */ && c <= 55 /* _7 */; + }; + + CharacterInfo.isHexDigit = function (c) { + return CharacterInfo.isDecimalDigit(c) || (c >= 65 /* A */ && c <= 70 /* F */) || (c >= 97 /* a */ && c <= 102 /* f */); + }; + + CharacterInfo.hexValue = function (c) { + return CharacterInfo.isDecimalDigit(c) ? (c - 48 /* _0 */) : (c >= 65 /* A */ && c <= 70 /* F */) ? c - 65 /* A */ + 10 : c - 97 /* a */ + 10; + }; + + CharacterInfo.isWhitespace = function (ch) { + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + return true; + } + + return false; + }; + + CharacterInfo.isLineTerminator = function (ch) { + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + return true; + } + + return false; + }; + return CharacterInfo; + })(); + TypeScript.CharacterInfo = CharacterInfo; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxConstants) { + SyntaxConstants[SyntaxConstants["TriviaNewLineMask"] = 0x00000001] = "TriviaNewLineMask"; + SyntaxConstants[SyntaxConstants["TriviaCommentMask"] = 0x00000002] = "TriviaCommentMask"; + SyntaxConstants[SyntaxConstants["TriviaFullWidthShift"] = 2] = "TriviaFullWidthShift"; + + SyntaxConstants[SyntaxConstants["NodeDataComputed"] = 0x00000001] = "NodeDataComputed"; + SyntaxConstants[SyntaxConstants["NodeIncrementallyUnusableMask"] = 0x00000002] = "NodeIncrementallyUnusableMask"; + SyntaxConstants[SyntaxConstants["NodeParsedInStrictModeMask"] = 0x00000004] = "NodeParsedInStrictModeMask"; + SyntaxConstants[SyntaxConstants["NodeFullWidthShift"] = 3] = "NodeFullWidthShift"; + + SyntaxConstants[SyntaxConstants["IsVariableWidthKeyword"] = 1 << 31] = "IsVariableWidthKeyword"; + })(TypeScript.SyntaxConstants || (TypeScript.SyntaxConstants = {})); + var SyntaxConstants = TypeScript.SyntaxConstants; +})(TypeScript || (TypeScript = {})); +var FormattingOptions = (function () { + function FormattingOptions(useTabs, spacesPerTab, indentSpaces, newLineCharacter) { + this.useTabs = useTabs; + this.spacesPerTab = spacesPerTab; + this.indentSpaces = indentSpaces; + this.newLineCharacter = newLineCharacter; + } + FormattingOptions.defaultOptions = new FormattingOptions(false, 4, 4, "\r\n"); + return FormattingOptions; +})(); +var TypeScript; +(function (TypeScript) { + (function (Indentation) { + function columnForEndOfToken(token, syntaxInformationMap, options) { + return columnForStartOfToken(token, syntaxInformationMap, options) + token.width(); + } + Indentation.columnForEndOfToken = columnForEndOfToken; + + function columnForStartOfToken(token, syntaxInformationMap, options) { + var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token); + var leadingTextInReverse = []; + + var current = token; + while (current !== firstTokenInLine) { + current = syntaxInformationMap.previousToken(current); + + if (current === firstTokenInLine) { + leadingTextInReverse.push(current.trailingTrivia().fullText()); + leadingTextInReverse.push(current.text()); + } else { + leadingTextInReverse.push(current.fullText()); + } + } + + collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse); + + return columnForLeadingTextInReverse(leadingTextInReverse, options); + } + Indentation.columnForStartOfToken = columnForStartOfToken; + + function columnForStartOfFirstTokenInLineContainingToken(token, syntaxInformationMap, options) { + var firstTokenInLine = syntaxInformationMap.firstTokenInLineContainingToken(token); + var leadingTextInReverse = []; + + collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse); + + return columnForLeadingTextInReverse(leadingTextInReverse, options); + } + Indentation.columnForStartOfFirstTokenInLineContainingToken = columnForStartOfFirstTokenInLineContainingToken; + + function collectLeadingTriviaTextToStartOfLine(firstTokenInLine, leadingTextInReverse) { + var leadingTrivia = firstTokenInLine.leadingTrivia(); + + for (var i = leadingTrivia.count() - 1; i >= 0; i--) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + if (trivia.kind() === 5 /* NewLineTrivia */) { + break; + } + + if (trivia.kind() === 6 /* MultiLineCommentTrivia */) { + var lineSegments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + leadingTextInReverse.push(TypeScript.ArrayUtilities.last(lineSegments)); + + if (lineSegments.length > 0) { + break; + } + } + + leadingTextInReverse.push(trivia.fullText()); + } + } + + function columnForLeadingTextInReverse(leadingTextInReverse, options) { + var column = 0; + + for (var i = leadingTextInReverse.length - 1; i >= 0; i--) { + var text = leadingTextInReverse[i]; + column = columnForPositionInStringWorker(text, text.length, column, options); + } + + return column; + } + + function columnForPositionInString(input, position, options) { + return columnForPositionInStringWorker(input, position, 0, options); + } + Indentation.columnForPositionInString = columnForPositionInString; + + function columnForPositionInStringWorker(input, position, startColumn, options) { + var column = startColumn; + var spacesPerTab = options.spacesPerTab; + + for (var j = 0; j < position; j++) { + var ch = input.charCodeAt(j); + + if (ch === 9 /* tab */) { + column += spacesPerTab - column % spacesPerTab; + } else { + column++; + } + } + + return column; + } + + function indentationString(column, options) { + var numberOfTabs = 0; + var numberOfSpaces = TypeScript.MathPrototype.max(0, column); + + if (options.useTabs) { + numberOfTabs = Math.floor(column / options.spacesPerTab); + numberOfSpaces -= numberOfTabs * options.spacesPerTab; + } + + return TypeScript.StringUtilities.repeat('\t', numberOfTabs) + TypeScript.StringUtilities.repeat(' ', numberOfSpaces); + } + Indentation.indentationString = indentationString; + + function indentationTrivia(column, options) { + return TypeScript.Syntax.whitespace(this.indentationString(column, options)); + } + Indentation.indentationTrivia = indentationTrivia; + + function firstNonWhitespacePosition(value) { + for (var i = 0; i < value.length; i++) { + var ch = value.charCodeAt(i); + if (!TypeScript.CharacterInfo.isWhitespace(ch)) { + return i; + } + } + + return value.length; + } + Indentation.firstNonWhitespacePosition = firstNonWhitespacePosition; + })(TypeScript.Indentation || (TypeScript.Indentation = {})); + var Indentation = TypeScript.Indentation; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (LanguageVersion) { + LanguageVersion[LanguageVersion["EcmaScript3"] = 0] = "EcmaScript3"; + LanguageVersion[LanguageVersion["EcmaScript5"] = 1] = "EcmaScript5"; + })(TypeScript.LanguageVersion || (TypeScript.LanguageVersion = {})); + var LanguageVersion = TypeScript.LanguageVersion; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ParseOptions = (function () { + function ParseOptions(languageVersion, allowAutomaticSemicolonInsertion) { + this._languageVersion = languageVersion; + this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion; + } + ParseOptions.prototype.toJSON = function (key) { + return { allowAutomaticSemicolonInsertion: this._allowAutomaticSemicolonInsertion }; + }; + + ParseOptions.prototype.languageVersion = function () { + return this._languageVersion; + }; + + ParseOptions.prototype.allowAutomaticSemicolonInsertion = function () { + return this._allowAutomaticSemicolonInsertion; + }; + return ParseOptions; + })(); + TypeScript.ParseOptions = ParseOptions; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PositionedElement = (function () { + function PositionedElement(parent, element, fullStart) { + this._parent = parent; + this._element = element; + this._fullStart = fullStart; + } + PositionedElement.create = function (parent, element, fullStart) { + if (element === null) { + return null; + } + + if (element.isNode()) { + return new PositionedNode(parent, element, fullStart); + } else if (element.isToken()) { + return new PositionedToken(parent, element, fullStart); + } else if (element.isList()) { + return new PositionedList(parent, element, fullStart); + } else if (element.isSeparatedList()) { + return new PositionedSeparatedList(parent, element, fullStart); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + PositionedElement.prototype.parent = function () { + return this._parent; + }; + + PositionedElement.prototype.parentElement = function () { + return this._parent && this._parent._element; + }; + + PositionedElement.prototype.element = function () { + return this._element; + }; + + PositionedElement.prototype.kind = function () { + return this.element().kind(); + }; + + PositionedElement.prototype.childIndex = function (child) { + return TypeScript.Syntax.childIndex(this.element(), child); + }; + + PositionedElement.prototype.childCount = function () { + return this.element().childCount(); + }; + + PositionedElement.prototype.childAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + return PositionedElement.create(this, this.element().childAt(index), this.fullStart() + offset); + }; + + PositionedElement.prototype.childStart = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return this.fullStart() + offset + child.leadingTriviaWidth(); + }; + + PositionedElement.prototype.childEnd = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return this.fullStart() + offset + child.leadingTriviaWidth() + child.width(); + }; + + PositionedElement.prototype.childStartAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + var child = this.element().childAt(index); + return this.fullStart() + offset + child.leadingTriviaWidth(); + }; + + PositionedElement.prototype.childEndAt = function (index) { + var offset = TypeScript.Syntax.childOffsetAt(this.element(), index); + var child = this.element().childAt(index); + return this.fullStart() + offset + child.leadingTriviaWidth() + child.width(); + }; + + PositionedElement.prototype.getPositionedChild = function (child) { + var offset = TypeScript.Syntax.childOffset(this.element(), child); + return PositionedElement.create(this, child, this.fullStart() + offset); + }; + + PositionedElement.prototype.fullStart = function () { + return this._fullStart; + }; + + PositionedElement.prototype.fullEnd = function () { + return this.fullStart() + this.element().fullWidth(); + }; + + PositionedElement.prototype.fullWidth = function () { + return this.element().fullWidth(); + }; + + PositionedElement.prototype.start = function () { + return this.fullStart() + this.element().leadingTriviaWidth(); + }; + + PositionedElement.prototype.end = function () { + return this.fullStart() + this.element().leadingTriviaWidth() + this.element().width(); + }; + + PositionedElement.prototype.root = function () { + var current = this; + while (current.parent() !== null) { + current = current.parent(); + } + + return current; + }; + + PositionedElement.prototype.containingNode = function () { + var current = this.parent(); + + while (current !== null && !current.element().isNode()) { + current = current.parent(); + } + + return current; + }; + return PositionedElement; + })(); + TypeScript.PositionedElement = PositionedElement; + + var PositionedNodeOrToken = (function (_super) { + __extends(PositionedNodeOrToken, _super); + function PositionedNodeOrToken(parent, nodeOrToken, fullStart) { + _super.call(this, parent, nodeOrToken, fullStart); + } + PositionedNodeOrToken.prototype.nodeOrToken = function () { + return this.element(); + }; + return PositionedNodeOrToken; + })(PositionedElement); + TypeScript.PositionedNodeOrToken = PositionedNodeOrToken; + + var PositionedNode = (function (_super) { + __extends(PositionedNode, _super); + function PositionedNode(parent, node, fullStart) { + _super.call(this, parent, node, fullStart); + } + PositionedNode.prototype.node = function () { + return this.element(); + }; + return PositionedNode; + })(PositionedNodeOrToken); + TypeScript.PositionedNode = PositionedNode; + + var PositionedToken = (function (_super) { + __extends(PositionedToken, _super); + function PositionedToken(parent, token, fullStart) { + _super.call(this, parent, token, fullStart); + } + PositionedToken.prototype.token = function () { + return this.element(); + }; + + PositionedToken.prototype.previousToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var triviaList = this.token().leadingTrivia(); + if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) { + var currentTriviaEndPosition = this.start(); + for (var i = triviaList.count() - 1; i >= 0; i--) { + var trivia = triviaList.syntaxTriviaAt(i); + if (trivia.isSkippedToken()) { + return new PositionedSkippedToken(this, trivia.skippedToken(), currentTriviaEndPosition - trivia.fullWidth()); + } + + currentTriviaEndPosition -= trivia.fullWidth(); + } + } + + var start = this.fullStart(); + if (start === 0) { + return null; + } + + return this.root().node().findToken(start - 1, includeSkippedTokens); + }; + + PositionedToken.prototype.nextToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + if (this.token().tokenKind === 10 /* EndOfFileToken */) { + return null; + } + + var triviaList = this.token().trailingTrivia(); + if (includeSkippedTokens && triviaList && triviaList.hasSkippedToken()) { + var fullStart = this.end(); + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + if (trivia.isSkippedToken()) { + return new PositionedSkippedToken(this, trivia.skippedToken(), fullStart); + } + + fullStart += trivia.fullWidth(); + } + } + + return this.root().node().findToken(this.fullEnd(), includeSkippedTokens); + }; + return PositionedToken; + })(PositionedNodeOrToken); + TypeScript.PositionedToken = PositionedToken; + + var PositionedList = (function (_super) { + __extends(PositionedList, _super); + function PositionedList(parent, list, fullStart) { + _super.call(this, parent, list, fullStart); + } + PositionedList.prototype.list = function () { + return this.element(); + }; + return PositionedList; + })(PositionedElement); + TypeScript.PositionedList = PositionedList; + + var PositionedSeparatedList = (function (_super) { + __extends(PositionedSeparatedList, _super); + function PositionedSeparatedList(parent, list, fullStart) { + _super.call(this, parent, list, fullStart); + } + PositionedSeparatedList.prototype.list = function () { + return this.element(); + }; + return PositionedSeparatedList; + })(PositionedElement); + TypeScript.PositionedSeparatedList = PositionedSeparatedList; + + var PositionedSkippedToken = (function (_super) { + __extends(PositionedSkippedToken, _super); + function PositionedSkippedToken(parentToken, token, fullStart) { + _super.call(this, parentToken.parent(), token, fullStart); + this._parentToken = parentToken; + } + PositionedSkippedToken.prototype.parentToken = function () { + return this._parentToken; + }; + + PositionedSkippedToken.prototype.previousToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var start = this.fullStart(); + + if (includeSkippedTokens) { + var previousToken; + + if (start >= this.parentToken().end()) { + previousToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), start - 1); + + if (previousToken) { + return previousToken; + } + + return this.parentToken(); + } else { + previousToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), start - 1); + + if (previousToken) { + return previousToken; + } + } + } + + var start = this.parentToken().fullStart(); + if (start === 0) { + return null; + } + + return this.root().node().findToken(start - 1, includeSkippedTokens); + }; + + PositionedSkippedToken.prototype.nextToken = function (includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + if (this.token().tokenKind === 10 /* EndOfFileToken */) { + return null; + } + + if (includeSkippedTokens) { + var end = this.end(); + var nextToken; + + if (end <= this.parentToken().start()) { + nextToken = TypeScript.Syntax.findSkippedTokenInLeadingTriviaList(this.parentToken(), end); + + if (nextToken) { + return nextToken; + } + + return this.parentToken(); + } else { + nextToken = TypeScript.Syntax.findSkippedTokenInTrailingTriviaList(this.parentToken(), end); + + if (nextToken) { + return nextToken; + } + } + } + + return this.root().node().findToken(this.parentToken().fullEnd(), includeSkippedTokens); + }; + return PositionedSkippedToken; + })(PositionedToken); + TypeScript.PositionedSkippedToken = PositionedSkippedToken; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxKind) { + SyntaxKind[SyntaxKind["None"] = 0] = "None"; + SyntaxKind[SyntaxKind["List"] = 1] = "List"; + SyntaxKind[SyntaxKind["SeparatedList"] = 2] = "SeparatedList"; + SyntaxKind[SyntaxKind["TriviaList"] = 3] = "TriviaList"; + + SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 4] = "WhitespaceTrivia"; + SyntaxKind[SyntaxKind["NewLineTrivia"] = 5] = "NewLineTrivia"; + SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 6] = "MultiLineCommentTrivia"; + SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 7] = "SingleLineCommentTrivia"; + SyntaxKind[SyntaxKind["SkippedTokenTrivia"] = 8] = "SkippedTokenTrivia"; + + SyntaxKind[SyntaxKind["ErrorToken"] = 9] = "ErrorToken"; + SyntaxKind[SyntaxKind["EndOfFileToken"] = 10] = "EndOfFileToken"; + + SyntaxKind[SyntaxKind["IdentifierName"] = 11] = "IdentifierName"; + + SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 12] = "RegularExpressionLiteral"; + SyntaxKind[SyntaxKind["NumericLiteral"] = 13] = "NumericLiteral"; + SyntaxKind[SyntaxKind["StringLiteral"] = 14] = "StringLiteral"; + + SyntaxKind[SyntaxKind["BreakKeyword"] = 15] = "BreakKeyword"; + SyntaxKind[SyntaxKind["CaseKeyword"] = 16] = "CaseKeyword"; + SyntaxKind[SyntaxKind["CatchKeyword"] = 17] = "CatchKeyword"; + SyntaxKind[SyntaxKind["ContinueKeyword"] = 18] = "ContinueKeyword"; + SyntaxKind[SyntaxKind["DebuggerKeyword"] = 19] = "DebuggerKeyword"; + SyntaxKind[SyntaxKind["DefaultKeyword"] = 20] = "DefaultKeyword"; + SyntaxKind[SyntaxKind["DeleteKeyword"] = 21] = "DeleteKeyword"; + SyntaxKind[SyntaxKind["DoKeyword"] = 22] = "DoKeyword"; + SyntaxKind[SyntaxKind["ElseKeyword"] = 23] = "ElseKeyword"; + SyntaxKind[SyntaxKind["FalseKeyword"] = 24] = "FalseKeyword"; + SyntaxKind[SyntaxKind["FinallyKeyword"] = 25] = "FinallyKeyword"; + SyntaxKind[SyntaxKind["ForKeyword"] = 26] = "ForKeyword"; + SyntaxKind[SyntaxKind["FunctionKeyword"] = 27] = "FunctionKeyword"; + SyntaxKind[SyntaxKind["IfKeyword"] = 28] = "IfKeyword"; + SyntaxKind[SyntaxKind["InKeyword"] = 29] = "InKeyword"; + SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 30] = "InstanceOfKeyword"; + SyntaxKind[SyntaxKind["NewKeyword"] = 31] = "NewKeyword"; + SyntaxKind[SyntaxKind["NullKeyword"] = 32] = "NullKeyword"; + SyntaxKind[SyntaxKind["ReturnKeyword"] = 33] = "ReturnKeyword"; + SyntaxKind[SyntaxKind["SwitchKeyword"] = 34] = "SwitchKeyword"; + SyntaxKind[SyntaxKind["ThisKeyword"] = 35] = "ThisKeyword"; + SyntaxKind[SyntaxKind["ThrowKeyword"] = 36] = "ThrowKeyword"; + SyntaxKind[SyntaxKind["TrueKeyword"] = 37] = "TrueKeyword"; + SyntaxKind[SyntaxKind["TryKeyword"] = 38] = "TryKeyword"; + SyntaxKind[SyntaxKind["TypeOfKeyword"] = 39] = "TypeOfKeyword"; + SyntaxKind[SyntaxKind["VarKeyword"] = 40] = "VarKeyword"; + SyntaxKind[SyntaxKind["VoidKeyword"] = 41] = "VoidKeyword"; + SyntaxKind[SyntaxKind["WhileKeyword"] = 42] = "WhileKeyword"; + SyntaxKind[SyntaxKind["WithKeyword"] = 43] = "WithKeyword"; + + SyntaxKind[SyntaxKind["ClassKeyword"] = 44] = "ClassKeyword"; + SyntaxKind[SyntaxKind["ConstKeyword"] = 45] = "ConstKeyword"; + SyntaxKind[SyntaxKind["EnumKeyword"] = 46] = "EnumKeyword"; + SyntaxKind[SyntaxKind["ExportKeyword"] = 47] = "ExportKeyword"; + SyntaxKind[SyntaxKind["ExtendsKeyword"] = 48] = "ExtendsKeyword"; + SyntaxKind[SyntaxKind["ImportKeyword"] = 49] = "ImportKeyword"; + SyntaxKind[SyntaxKind["SuperKeyword"] = 50] = "SuperKeyword"; + + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 51] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 52] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 53] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 54] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 55] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 56] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 57] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 58] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 59] = "YieldKeyword"; + + SyntaxKind[SyntaxKind["AnyKeyword"] = 60] = "AnyKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 61] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 62] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 63] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 64] = "GetKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 65] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 66] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 67] = "NumberKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 68] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 69] = "StringKeyword"; + + SyntaxKind[SyntaxKind["OpenBraceToken"] = 70] = "OpenBraceToken"; + SyntaxKind[SyntaxKind["CloseBraceToken"] = 71] = "CloseBraceToken"; + SyntaxKind[SyntaxKind["OpenParenToken"] = 72] = "OpenParenToken"; + SyntaxKind[SyntaxKind["CloseParenToken"] = 73] = "CloseParenToken"; + SyntaxKind[SyntaxKind["OpenBracketToken"] = 74] = "OpenBracketToken"; + SyntaxKind[SyntaxKind["CloseBracketToken"] = 75] = "CloseBracketToken"; + SyntaxKind[SyntaxKind["DotToken"] = 76] = "DotToken"; + SyntaxKind[SyntaxKind["DotDotDotToken"] = 77] = "DotDotDotToken"; + SyntaxKind[SyntaxKind["SemicolonToken"] = 78] = "SemicolonToken"; + SyntaxKind[SyntaxKind["CommaToken"] = 79] = "CommaToken"; + SyntaxKind[SyntaxKind["LessThanToken"] = 80] = "LessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanToken"] = 81] = "GreaterThanToken"; + SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 82] = "LessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 83] = "GreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 84] = "EqualsEqualsToken"; + SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 85] = "EqualsGreaterThanToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 86] = "ExclamationEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 87] = "EqualsEqualsEqualsToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 88] = "ExclamationEqualsEqualsToken"; + SyntaxKind[SyntaxKind["PlusToken"] = 89] = "PlusToken"; + SyntaxKind[SyntaxKind["MinusToken"] = 90] = "MinusToken"; + SyntaxKind[SyntaxKind["AsteriskToken"] = 91] = "AsteriskToken"; + SyntaxKind[SyntaxKind["PercentToken"] = 92] = "PercentToken"; + SyntaxKind[SyntaxKind["PlusPlusToken"] = 93] = "PlusPlusToken"; + SyntaxKind[SyntaxKind["MinusMinusToken"] = 94] = "MinusMinusToken"; + SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 95] = "LessThanLessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 96] = "GreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 97] = "GreaterThanGreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["AmpersandToken"] = 98] = "AmpersandToken"; + SyntaxKind[SyntaxKind["BarToken"] = 99] = "BarToken"; + SyntaxKind[SyntaxKind["CaretToken"] = 100] = "CaretToken"; + SyntaxKind[SyntaxKind["ExclamationToken"] = 101] = "ExclamationToken"; + SyntaxKind[SyntaxKind["TildeToken"] = 102] = "TildeToken"; + SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 103] = "AmpersandAmpersandToken"; + SyntaxKind[SyntaxKind["BarBarToken"] = 104] = "BarBarToken"; + SyntaxKind[SyntaxKind["QuestionToken"] = 105] = "QuestionToken"; + SyntaxKind[SyntaxKind["ColonToken"] = 106] = "ColonToken"; + SyntaxKind[SyntaxKind["EqualsToken"] = 107] = "EqualsToken"; + SyntaxKind[SyntaxKind["PlusEqualsToken"] = 108] = "PlusEqualsToken"; + SyntaxKind[SyntaxKind["MinusEqualsToken"] = 109] = "MinusEqualsToken"; + SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 110] = "AsteriskEqualsToken"; + SyntaxKind[SyntaxKind["PercentEqualsToken"] = 111] = "PercentEqualsToken"; + SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 112] = "LessThanLessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 113] = "GreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 114] = "GreaterThanGreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 115] = "AmpersandEqualsToken"; + SyntaxKind[SyntaxKind["BarEqualsToken"] = 116] = "BarEqualsToken"; + SyntaxKind[SyntaxKind["CaretEqualsToken"] = 117] = "CaretEqualsToken"; + SyntaxKind[SyntaxKind["SlashToken"] = 118] = "SlashToken"; + SyntaxKind[SyntaxKind["SlashEqualsToken"] = 119] = "SlashEqualsToken"; + + SyntaxKind[SyntaxKind["SourceUnit"] = 120] = "SourceUnit"; + + SyntaxKind[SyntaxKind["QualifiedName"] = 121] = "QualifiedName"; + + SyntaxKind[SyntaxKind["ObjectType"] = 122] = "ObjectType"; + SyntaxKind[SyntaxKind["FunctionType"] = 123] = "FunctionType"; + SyntaxKind[SyntaxKind["ArrayType"] = 124] = "ArrayType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 125] = "ConstructorType"; + SyntaxKind[SyntaxKind["GenericType"] = 126] = "GenericType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 127] = "TypeQuery"; + + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 128] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 129] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 130] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 131] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 132] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 133] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 134] = "ExportAssignment"; + + SyntaxKind[SyntaxKind["MemberFunctionDeclaration"] = 135] = "MemberFunctionDeclaration"; + SyntaxKind[SyntaxKind["MemberVariableDeclaration"] = 136] = "MemberVariableDeclaration"; + SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 137] = "ConstructorDeclaration"; + SyntaxKind[SyntaxKind["IndexMemberDeclaration"] = 138] = "IndexMemberDeclaration"; + + SyntaxKind[SyntaxKind["GetAccessor"] = 139] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 140] = "SetAccessor"; + + SyntaxKind[SyntaxKind["PropertySignature"] = 141] = "PropertySignature"; + SyntaxKind[SyntaxKind["CallSignature"] = 142] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 143] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 144] = "IndexSignature"; + SyntaxKind[SyntaxKind["MethodSignature"] = 145] = "MethodSignature"; + + SyntaxKind[SyntaxKind["Block"] = 146] = "Block"; + SyntaxKind[SyntaxKind["IfStatement"] = 147] = "IfStatement"; + SyntaxKind[SyntaxKind["VariableStatement"] = 148] = "VariableStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 149] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 150] = "ReturnStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 151] = "SwitchStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 152] = "BreakStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 153] = "ContinueStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 154] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 155] = "ForInStatement"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 156] = "EmptyStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 157] = "ThrowStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 158] = "WhileStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 159] = "TryStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 160] = "LabeledStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 161] = "DoStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 162] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 163] = "WithStatement"; + + SyntaxKind[SyntaxKind["PlusExpression"] = 164] = "PlusExpression"; + SyntaxKind[SyntaxKind["NegateExpression"] = 165] = "NegateExpression"; + SyntaxKind[SyntaxKind["BitwiseNotExpression"] = 166] = "BitwiseNotExpression"; + SyntaxKind[SyntaxKind["LogicalNotExpression"] = 167] = "LogicalNotExpression"; + SyntaxKind[SyntaxKind["PreIncrementExpression"] = 168] = "PreIncrementExpression"; + SyntaxKind[SyntaxKind["PreDecrementExpression"] = 169] = "PreDecrementExpression"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 170] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 171] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 172] = "VoidExpression"; + SyntaxKind[SyntaxKind["CommaExpression"] = 173] = "CommaExpression"; + SyntaxKind[SyntaxKind["AssignmentExpression"] = 174] = "AssignmentExpression"; + SyntaxKind[SyntaxKind["AddAssignmentExpression"] = 175] = "AddAssignmentExpression"; + SyntaxKind[SyntaxKind["SubtractAssignmentExpression"] = 176] = "SubtractAssignmentExpression"; + SyntaxKind[SyntaxKind["MultiplyAssignmentExpression"] = 177] = "MultiplyAssignmentExpression"; + SyntaxKind[SyntaxKind["DivideAssignmentExpression"] = 178] = "DivideAssignmentExpression"; + SyntaxKind[SyntaxKind["ModuloAssignmentExpression"] = 179] = "ModuloAssignmentExpression"; + SyntaxKind[SyntaxKind["AndAssignmentExpression"] = 180] = "AndAssignmentExpression"; + SyntaxKind[SyntaxKind["ExclusiveOrAssignmentExpression"] = 181] = "ExclusiveOrAssignmentExpression"; + SyntaxKind[SyntaxKind["OrAssignmentExpression"] = 182] = "OrAssignmentExpression"; + SyntaxKind[SyntaxKind["LeftShiftAssignmentExpression"] = 183] = "LeftShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["SignedRightShiftAssignmentExpression"] = 184] = "SignedRightShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["UnsignedRightShiftAssignmentExpression"] = 185] = "UnsignedRightShiftAssignmentExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 186] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["LogicalOrExpression"] = 187] = "LogicalOrExpression"; + SyntaxKind[SyntaxKind["LogicalAndExpression"] = 188] = "LogicalAndExpression"; + SyntaxKind[SyntaxKind["BitwiseOrExpression"] = 189] = "BitwiseOrExpression"; + SyntaxKind[SyntaxKind["BitwiseExclusiveOrExpression"] = 190] = "BitwiseExclusiveOrExpression"; + SyntaxKind[SyntaxKind["BitwiseAndExpression"] = 191] = "BitwiseAndExpression"; + SyntaxKind[SyntaxKind["EqualsWithTypeConversionExpression"] = 192] = "EqualsWithTypeConversionExpression"; + SyntaxKind[SyntaxKind["NotEqualsWithTypeConversionExpression"] = 193] = "NotEqualsWithTypeConversionExpression"; + SyntaxKind[SyntaxKind["EqualsExpression"] = 194] = "EqualsExpression"; + SyntaxKind[SyntaxKind["NotEqualsExpression"] = 195] = "NotEqualsExpression"; + SyntaxKind[SyntaxKind["LessThanExpression"] = 196] = "LessThanExpression"; + SyntaxKind[SyntaxKind["GreaterThanExpression"] = 197] = "GreaterThanExpression"; + SyntaxKind[SyntaxKind["LessThanOrEqualExpression"] = 198] = "LessThanOrEqualExpression"; + SyntaxKind[SyntaxKind["GreaterThanOrEqualExpression"] = 199] = "GreaterThanOrEqualExpression"; + SyntaxKind[SyntaxKind["InstanceOfExpression"] = 200] = "InstanceOfExpression"; + SyntaxKind[SyntaxKind["InExpression"] = 201] = "InExpression"; + SyntaxKind[SyntaxKind["LeftShiftExpression"] = 202] = "LeftShiftExpression"; + SyntaxKind[SyntaxKind["SignedRightShiftExpression"] = 203] = "SignedRightShiftExpression"; + SyntaxKind[SyntaxKind["UnsignedRightShiftExpression"] = 204] = "UnsignedRightShiftExpression"; + SyntaxKind[SyntaxKind["MultiplyExpression"] = 205] = "MultiplyExpression"; + SyntaxKind[SyntaxKind["DivideExpression"] = 206] = "DivideExpression"; + SyntaxKind[SyntaxKind["ModuloExpression"] = 207] = "ModuloExpression"; + SyntaxKind[SyntaxKind["AddExpression"] = 208] = "AddExpression"; + SyntaxKind[SyntaxKind["SubtractExpression"] = 209] = "SubtractExpression"; + SyntaxKind[SyntaxKind["PostIncrementExpression"] = 210] = "PostIncrementExpression"; + SyntaxKind[SyntaxKind["PostDecrementExpression"] = 211] = "PostDecrementExpression"; + SyntaxKind[SyntaxKind["MemberAccessExpression"] = 212] = "MemberAccessExpression"; + SyntaxKind[SyntaxKind["InvocationExpression"] = 213] = "InvocationExpression"; + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 214] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 215] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectCreationExpression"] = 216] = "ObjectCreationExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 217] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["ParenthesizedArrowFunctionExpression"] = 218] = "ParenthesizedArrowFunctionExpression"; + SyntaxKind[SyntaxKind["SimpleArrowFunctionExpression"] = 219] = "SimpleArrowFunctionExpression"; + SyntaxKind[SyntaxKind["CastExpression"] = 220] = "CastExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 221] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 222] = "FunctionExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 223] = "OmittedExpression"; + + SyntaxKind[SyntaxKind["VariableDeclaration"] = 224] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarator"] = 225] = "VariableDeclarator"; + + SyntaxKind[SyntaxKind["ArgumentList"] = 226] = "ArgumentList"; + SyntaxKind[SyntaxKind["ParameterList"] = 227] = "ParameterList"; + SyntaxKind[SyntaxKind["TypeArgumentList"] = 228] = "TypeArgumentList"; + SyntaxKind[SyntaxKind["TypeParameterList"] = 229] = "TypeParameterList"; + + SyntaxKind[SyntaxKind["ExtendsHeritageClause"] = 230] = "ExtendsHeritageClause"; + SyntaxKind[SyntaxKind["ImplementsHeritageClause"] = 231] = "ImplementsHeritageClause"; + SyntaxKind[SyntaxKind["EqualsValueClause"] = 232] = "EqualsValueClause"; + SyntaxKind[SyntaxKind["CaseSwitchClause"] = 233] = "CaseSwitchClause"; + SyntaxKind[SyntaxKind["DefaultSwitchClause"] = 234] = "DefaultSwitchClause"; + SyntaxKind[SyntaxKind["ElseClause"] = 235] = "ElseClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 236] = "CatchClause"; + SyntaxKind[SyntaxKind["FinallyClause"] = 237] = "FinallyClause"; + + SyntaxKind[SyntaxKind["TypeParameter"] = 238] = "TypeParameter"; + SyntaxKind[SyntaxKind["Constraint"] = 239] = "Constraint"; + + SyntaxKind[SyntaxKind["SimplePropertyAssignment"] = 240] = "SimplePropertyAssignment"; + + SyntaxKind[SyntaxKind["FunctionPropertyAssignment"] = 241] = "FunctionPropertyAssignment"; + + SyntaxKind[SyntaxKind["Parameter"] = 242] = "Parameter"; + SyntaxKind[SyntaxKind["EnumElement"] = 243] = "EnumElement"; + SyntaxKind[SyntaxKind["TypeAnnotation"] = 244] = "TypeAnnotation"; + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 245] = "ExternalModuleReference"; + SyntaxKind[SyntaxKind["ModuleNameModuleReference"] = 246] = "ModuleNameModuleReference"; + SyntaxKind[SyntaxKind["Last"] = SyntaxKind.ModuleNameModuleReference] = "Last"; + + SyntaxKind[SyntaxKind["FirstStandardKeyword"] = SyntaxKind.BreakKeyword] = "FirstStandardKeyword"; + SyntaxKind[SyntaxKind["LastStandardKeyword"] = SyntaxKind.WithKeyword] = "LastStandardKeyword"; + + SyntaxKind[SyntaxKind["FirstFutureReservedKeyword"] = SyntaxKind.ClassKeyword] = "FirstFutureReservedKeyword"; + SyntaxKind[SyntaxKind["LastFutureReservedKeyword"] = SyntaxKind.SuperKeyword] = "LastFutureReservedKeyword"; + + SyntaxKind[SyntaxKind["FirstFutureReservedStrictKeyword"] = SyntaxKind.ImplementsKeyword] = "FirstFutureReservedStrictKeyword"; + SyntaxKind[SyntaxKind["LastFutureReservedStrictKeyword"] = SyntaxKind.YieldKeyword] = "LastFutureReservedStrictKeyword"; + + SyntaxKind[SyntaxKind["FirstTypeScriptKeyword"] = SyntaxKind.AnyKeyword] = "FirstTypeScriptKeyword"; + SyntaxKind[SyntaxKind["LastTypeScriptKeyword"] = SyntaxKind.StringKeyword] = "LastTypeScriptKeyword"; + + SyntaxKind[SyntaxKind["FirstKeyword"] = SyntaxKind.FirstStandardKeyword] = "FirstKeyword"; + SyntaxKind[SyntaxKind["LastKeyword"] = SyntaxKind.LastTypeScriptKeyword] = "LastKeyword"; + + SyntaxKind[SyntaxKind["FirstToken"] = SyntaxKind.ErrorToken] = "FirstToken"; + SyntaxKind[SyntaxKind["LastToken"] = SyntaxKind.SlashEqualsToken] = "LastToken"; + + SyntaxKind[SyntaxKind["FirstPunctuation"] = SyntaxKind.OpenBraceToken] = "FirstPunctuation"; + SyntaxKind[SyntaxKind["LastPunctuation"] = SyntaxKind.SlashEqualsToken] = "LastPunctuation"; + + SyntaxKind[SyntaxKind["FirstFixedWidth"] = SyntaxKind.FirstKeyword] = "FirstFixedWidth"; + SyntaxKind[SyntaxKind["LastFixedWidth"] = SyntaxKind.LastPunctuation] = "LastFixedWidth"; + + SyntaxKind[SyntaxKind["FirstTrivia"] = SyntaxKind.WhitespaceTrivia] = "FirstTrivia"; + SyntaxKind[SyntaxKind["LastTrivia"] = SyntaxKind.SkippedTokenTrivia] = "LastTrivia"; + })(TypeScript.SyntaxKind || (TypeScript.SyntaxKind = {})); + var SyntaxKind = TypeScript.SyntaxKind; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxFacts) { + var textToKeywordKind = { + "any": 60 /* AnyKeyword */, + "boolean": 61 /* BooleanKeyword */, + "break": 15 /* BreakKeyword */, + "case": 16 /* CaseKeyword */, + "catch": 17 /* CatchKeyword */, + "class": 44 /* ClassKeyword */, + "continue": 18 /* ContinueKeyword */, + "const": 45 /* ConstKeyword */, + "constructor": 62 /* ConstructorKeyword */, + "debugger": 19 /* DebuggerKeyword */, + "declare": 63 /* DeclareKeyword */, + "default": 20 /* DefaultKeyword */, + "delete": 21 /* DeleteKeyword */, + "do": 22 /* DoKeyword */, + "else": 23 /* ElseKeyword */, + "enum": 46 /* EnumKeyword */, + "export": 47 /* ExportKeyword */, + "extends": 48 /* ExtendsKeyword */, + "false": 24 /* FalseKeyword */, + "finally": 25 /* FinallyKeyword */, + "for": 26 /* ForKeyword */, + "function": 27 /* FunctionKeyword */, + "get": 64 /* GetKeyword */, + "if": 28 /* IfKeyword */, + "implements": 51 /* ImplementsKeyword */, + "import": 49 /* ImportKeyword */, + "in": 29 /* InKeyword */, + "instanceof": 30 /* InstanceOfKeyword */, + "interface": 52 /* InterfaceKeyword */, + "let": 53 /* LetKeyword */, + "module": 65 /* ModuleKeyword */, + "new": 31 /* NewKeyword */, + "null": 32 /* NullKeyword */, + "number": 67 /* NumberKeyword */, + "package": 54 /* PackageKeyword */, + "private": 55 /* PrivateKeyword */, + "protected": 56 /* ProtectedKeyword */, + "public": 57 /* PublicKeyword */, + "require": 66 /* RequireKeyword */, + "return": 33 /* ReturnKeyword */, + "set": 68 /* SetKeyword */, + "static": 58 /* StaticKeyword */, + "string": 69 /* StringKeyword */, + "super": 50 /* SuperKeyword */, + "switch": 34 /* SwitchKeyword */, + "this": 35 /* ThisKeyword */, + "throw": 36 /* ThrowKeyword */, + "true": 37 /* TrueKeyword */, + "try": 38 /* TryKeyword */, + "typeof": 39 /* TypeOfKeyword */, + "var": 40 /* VarKeyword */, + "void": 41 /* VoidKeyword */, + "while": 42 /* WhileKeyword */, + "with": 43 /* WithKeyword */, + "yield": 59 /* YieldKeyword */, + "{": 70 /* OpenBraceToken */, + "}": 71 /* CloseBraceToken */, + "(": 72 /* OpenParenToken */, + ")": 73 /* CloseParenToken */, + "[": 74 /* OpenBracketToken */, + "]": 75 /* CloseBracketToken */, + ".": 76 /* DotToken */, + "...": 77 /* DotDotDotToken */, + ";": 78 /* SemicolonToken */, + ",": 79 /* CommaToken */, + "<": 80 /* LessThanToken */, + ">": 81 /* GreaterThanToken */, + "<=": 82 /* LessThanEqualsToken */, + ">=": 83 /* GreaterThanEqualsToken */, + "==": 84 /* EqualsEqualsToken */, + "=>": 85 /* EqualsGreaterThanToken */, + "!=": 86 /* ExclamationEqualsToken */, + "===": 87 /* EqualsEqualsEqualsToken */, + "!==": 88 /* ExclamationEqualsEqualsToken */, + "+": 89 /* PlusToken */, + "-": 90 /* MinusToken */, + "*": 91 /* AsteriskToken */, + "%": 92 /* PercentToken */, + "++": 93 /* PlusPlusToken */, + "--": 94 /* MinusMinusToken */, + "<<": 95 /* LessThanLessThanToken */, + ">>": 96 /* GreaterThanGreaterThanToken */, + ">>>": 97 /* GreaterThanGreaterThanGreaterThanToken */, + "&": 98 /* AmpersandToken */, + "|": 99 /* BarToken */, + "^": 100 /* CaretToken */, + "!": 101 /* ExclamationToken */, + "~": 102 /* TildeToken */, + "&&": 103 /* AmpersandAmpersandToken */, + "||": 104 /* BarBarToken */, + "?": 105 /* QuestionToken */, + ":": 106 /* ColonToken */, + "=": 107 /* EqualsToken */, + "+=": 108 /* PlusEqualsToken */, + "-=": 109 /* MinusEqualsToken */, + "*=": 110 /* AsteriskEqualsToken */, + "%=": 111 /* PercentEqualsToken */, + "<<=": 112 /* LessThanLessThanEqualsToken */, + ">>=": 113 /* GreaterThanGreaterThanEqualsToken */, + ">>>=": 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */, + "&=": 115 /* AmpersandEqualsToken */, + "|=": 116 /* BarEqualsToken */, + "^=": 117 /* CaretEqualsToken */, + "/": 118 /* SlashToken */, + "/=": 119 /* SlashEqualsToken */ + }; + + var kindToText = new Array(); + + for (var name in textToKeywordKind) { + if (textToKeywordKind.hasOwnProperty(name)) { + kindToText[textToKeywordKind[name]] = name; + } + } + + kindToText[62 /* ConstructorKeyword */] = "constructor"; + + function getTokenKind(text) { + if (textToKeywordKind.hasOwnProperty(text)) { + return textToKeywordKind[text]; + } + + return 0 /* None */; + } + SyntaxFacts.getTokenKind = getTokenKind; + + function getText(kind) { + var result = kindToText[kind]; + return result !== undefined ? result : null; + } + SyntaxFacts.getText = getText; + + function isTokenKind(kind) { + return kind >= 9 /* FirstToken */ && kind <= 119 /* LastToken */; + } + SyntaxFacts.isTokenKind = isTokenKind; + + function isAnyKeyword(kind) { + return kind >= 15 /* FirstKeyword */ && kind <= 69 /* LastKeyword */; + } + SyntaxFacts.isAnyKeyword = isAnyKeyword; + + function isStandardKeyword(kind) { + return kind >= 15 /* FirstStandardKeyword */ && kind <= 43 /* LastStandardKeyword */; + } + SyntaxFacts.isStandardKeyword = isStandardKeyword; + + function isFutureReservedKeyword(kind) { + return kind >= 44 /* FirstFutureReservedKeyword */ && kind <= 50 /* LastFutureReservedKeyword */; + } + SyntaxFacts.isFutureReservedKeyword = isFutureReservedKeyword; + + function isFutureReservedStrictKeyword(kind) { + return kind >= 51 /* FirstFutureReservedStrictKeyword */ && kind <= 59 /* LastFutureReservedStrictKeyword */; + } + SyntaxFacts.isFutureReservedStrictKeyword = isFutureReservedStrictKeyword; + + function isAnyPunctuation(kind) { + return kind >= 70 /* FirstPunctuation */ && kind <= 119 /* LastPunctuation */; + } + SyntaxFacts.isAnyPunctuation = isAnyPunctuation; + + function isPrefixUnaryExpressionOperatorToken(tokenKind) { + return getPrefixUnaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */; + } + SyntaxFacts.isPrefixUnaryExpressionOperatorToken = isPrefixUnaryExpressionOperatorToken; + + function isBinaryExpressionOperatorToken(tokenKind) { + return getBinaryExpressionFromOperatorToken(tokenKind) !== 0 /* None */; + } + SyntaxFacts.isBinaryExpressionOperatorToken = isBinaryExpressionOperatorToken; + + function getPrefixUnaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 89 /* PlusToken */: + return 164 /* PlusExpression */; + case 90 /* MinusToken */: + return 165 /* NegateExpression */; + case 102 /* TildeToken */: + return 166 /* BitwiseNotExpression */; + case 101 /* ExclamationToken */: + return 167 /* LogicalNotExpression */; + case 93 /* PlusPlusToken */: + return 168 /* PreIncrementExpression */; + case 94 /* MinusMinusToken */: + return 169 /* PreDecrementExpression */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken = getPrefixUnaryExpressionFromOperatorToken; + + function getPostfixUnaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 93 /* PlusPlusToken */: + return 210 /* PostIncrementExpression */; + case 94 /* MinusMinusToken */: + return 211 /* PostDecrementExpression */; + default: + return 0 /* None */; + } + } + SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken = getPostfixUnaryExpressionFromOperatorToken; + + function getBinaryExpressionFromOperatorToken(tokenKind) { + switch (tokenKind) { + case 91 /* AsteriskToken */: + return 205 /* MultiplyExpression */; + + case 118 /* SlashToken */: + return 206 /* DivideExpression */; + + case 92 /* PercentToken */: + return 207 /* ModuloExpression */; + + case 89 /* PlusToken */: + return 208 /* AddExpression */; + + case 90 /* MinusToken */: + return 209 /* SubtractExpression */; + + case 95 /* LessThanLessThanToken */: + return 202 /* LeftShiftExpression */; + + case 96 /* GreaterThanGreaterThanToken */: + return 203 /* SignedRightShiftExpression */; + + case 97 /* GreaterThanGreaterThanGreaterThanToken */: + return 204 /* UnsignedRightShiftExpression */; + + case 80 /* LessThanToken */: + return 196 /* LessThanExpression */; + + case 81 /* GreaterThanToken */: + return 197 /* GreaterThanExpression */; + + case 82 /* LessThanEqualsToken */: + return 198 /* LessThanOrEqualExpression */; + + case 83 /* GreaterThanEqualsToken */: + return 199 /* GreaterThanOrEqualExpression */; + + case 30 /* InstanceOfKeyword */: + return 200 /* InstanceOfExpression */; + + case 29 /* InKeyword */: + return 201 /* InExpression */; + + case 84 /* EqualsEqualsToken */: + return 192 /* EqualsWithTypeConversionExpression */; + + case 86 /* ExclamationEqualsToken */: + return 193 /* NotEqualsWithTypeConversionExpression */; + + case 87 /* EqualsEqualsEqualsToken */: + return 194 /* EqualsExpression */; + + case 88 /* ExclamationEqualsEqualsToken */: + return 195 /* NotEqualsExpression */; + + case 98 /* AmpersandToken */: + return 191 /* BitwiseAndExpression */; + + case 100 /* CaretToken */: + return 190 /* BitwiseExclusiveOrExpression */; + + case 99 /* BarToken */: + return 189 /* BitwiseOrExpression */; + + case 103 /* AmpersandAmpersandToken */: + return 188 /* LogicalAndExpression */; + + case 104 /* BarBarToken */: + return 187 /* LogicalOrExpression */; + + case 116 /* BarEqualsToken */: + return 182 /* OrAssignmentExpression */; + + case 115 /* AmpersandEqualsToken */: + return 180 /* AndAssignmentExpression */; + + case 117 /* CaretEqualsToken */: + return 181 /* ExclusiveOrAssignmentExpression */; + + case 112 /* LessThanLessThanEqualsToken */: + return 183 /* LeftShiftAssignmentExpression */; + + case 113 /* GreaterThanGreaterThanEqualsToken */: + return 184 /* SignedRightShiftAssignmentExpression */; + + case 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */: + return 185 /* UnsignedRightShiftAssignmentExpression */; + + case 108 /* PlusEqualsToken */: + return 175 /* AddAssignmentExpression */; + + case 109 /* MinusEqualsToken */: + return 176 /* SubtractAssignmentExpression */; + + case 110 /* AsteriskEqualsToken */: + return 177 /* MultiplyAssignmentExpression */; + + case 119 /* SlashEqualsToken */: + return 178 /* DivideAssignmentExpression */; + + case 111 /* PercentEqualsToken */: + return 179 /* ModuloAssignmentExpression */; + + case 107 /* EqualsToken */: + return 174 /* AssignmentExpression */; + + case 79 /* CommaToken */: + return 173 /* CommaExpression */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getBinaryExpressionFromOperatorToken = getBinaryExpressionFromOperatorToken; + + function getOperatorTokenFromBinaryExpression(tokenKind) { + switch (tokenKind) { + case 205 /* MultiplyExpression */: + return 91 /* AsteriskToken */; + + case 206 /* DivideExpression */: + return 118 /* SlashToken */; + + case 207 /* ModuloExpression */: + return 92 /* PercentToken */; + + case 208 /* AddExpression */: + return 89 /* PlusToken */; + + case 209 /* SubtractExpression */: + return 90 /* MinusToken */; + + case 202 /* LeftShiftExpression */: + return 95 /* LessThanLessThanToken */; + + case 203 /* SignedRightShiftExpression */: + return 96 /* GreaterThanGreaterThanToken */; + + case 204 /* UnsignedRightShiftExpression */: + return 97 /* GreaterThanGreaterThanGreaterThanToken */; + + case 196 /* LessThanExpression */: + return 80 /* LessThanToken */; + + case 197 /* GreaterThanExpression */: + return 81 /* GreaterThanToken */; + + case 198 /* LessThanOrEqualExpression */: + return 82 /* LessThanEqualsToken */; + + case 199 /* GreaterThanOrEqualExpression */: + return 83 /* GreaterThanEqualsToken */; + + case 200 /* InstanceOfExpression */: + return 30 /* InstanceOfKeyword */; + + case 201 /* InExpression */: + return 29 /* InKeyword */; + + case 192 /* EqualsWithTypeConversionExpression */: + return 84 /* EqualsEqualsToken */; + + case 193 /* NotEqualsWithTypeConversionExpression */: + return 86 /* ExclamationEqualsToken */; + + case 194 /* EqualsExpression */: + return 87 /* EqualsEqualsEqualsToken */; + + case 195 /* NotEqualsExpression */: + return 88 /* ExclamationEqualsEqualsToken */; + + case 191 /* BitwiseAndExpression */: + return 98 /* AmpersandToken */; + + case 190 /* BitwiseExclusiveOrExpression */: + return 100 /* CaretToken */; + + case 189 /* BitwiseOrExpression */: + return 99 /* BarToken */; + + case 188 /* LogicalAndExpression */: + return 103 /* AmpersandAmpersandToken */; + + case 187 /* LogicalOrExpression */: + return 104 /* BarBarToken */; + + case 182 /* OrAssignmentExpression */: + return 116 /* BarEqualsToken */; + + case 180 /* AndAssignmentExpression */: + return 115 /* AmpersandEqualsToken */; + + case 181 /* ExclusiveOrAssignmentExpression */: + return 117 /* CaretEqualsToken */; + + case 183 /* LeftShiftAssignmentExpression */: + return 112 /* LessThanLessThanEqualsToken */; + + case 184 /* SignedRightShiftAssignmentExpression */: + return 113 /* GreaterThanGreaterThanEqualsToken */; + + case 185 /* UnsignedRightShiftAssignmentExpression */: + return 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */; + + case 175 /* AddAssignmentExpression */: + return 108 /* PlusEqualsToken */; + + case 176 /* SubtractAssignmentExpression */: + return 109 /* MinusEqualsToken */; + + case 177 /* MultiplyAssignmentExpression */: + return 110 /* AsteriskEqualsToken */; + + case 178 /* DivideAssignmentExpression */: + return 119 /* SlashEqualsToken */; + + case 179 /* ModuloAssignmentExpression */: + return 111 /* PercentEqualsToken */; + + case 174 /* AssignmentExpression */: + return 107 /* EqualsToken */; + + case 173 /* CommaExpression */: + return 79 /* CommaToken */; + + default: + return 0 /* None */; + } + } + SyntaxFacts.getOperatorTokenFromBinaryExpression = getOperatorTokenFromBinaryExpression; + + function isAnyDivideToken(kind) { + switch (kind) { + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + return true; + default: + return false; + } + } + SyntaxFacts.isAnyDivideToken = isAnyDivideToken; + + function isAnyDivideOrRegularExpressionToken(kind) { + switch (kind) { + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + case 12 /* RegularExpressionLiteral */: + return true; + default: + return false; + } + } + SyntaxFacts.isAnyDivideOrRegularExpressionToken = isAnyDivideOrRegularExpressionToken; + })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {})); + var SyntaxFacts = TypeScript.SyntaxFacts; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var isKeywordStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isIdentifierStartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isIdentifierPartCharacter = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + var isNumericLiteralStart = TypeScript.ArrayUtilities.createArray(127 /* maxAsciiCharacter */, false); + + for (var character = 0; character < 127 /* maxAsciiCharacter */; character++) { + if (character >= 97 /* a */ && character <= 122 /* z */) { + isIdentifierStartCharacter[character] = true; + isIdentifierPartCharacter[character] = true; + } else if ((character >= 65 /* A */ && character <= 90 /* Z */) || character === 95 /* _ */ || character === 36 /* $ */) { + isIdentifierStartCharacter[character] = true; + isIdentifierPartCharacter[character] = true; + } else if (character >= 48 /* _0 */ && character <= 57 /* _9 */) { + isIdentifierPartCharacter[character] = true; + isNumericLiteralStart[character] = true; + } + } + + isNumericLiteralStart[46 /* dot */] = true; + + for (var keywordKind = 15 /* FirstKeyword */; keywordKind <= 69 /* LastKeyword */; keywordKind++) { + var keyword = TypeScript.SyntaxFacts.getText(keywordKind); + isKeywordStartCharacter[keyword.charCodeAt(0)] = true; + } + + var Scanner = (function () { + function Scanner(fileName, text, languageVersion, window) { + if (typeof window === "undefined") { window = TypeScript.ArrayUtilities.createArray(2048, 0); } + this.slidingWindow = new TypeScript.SlidingWindow(this, window, 0, text.length()); + this.fileName = fileName; + this.text = text; + this._languageVersion = languageVersion; + } + Scanner.prototype.languageVersion = function () { + return this._languageVersion; + }; + + Scanner.prototype.fetchMoreItems = function (argument, sourceIndex, window, destinationIndex, spaceAvailable) { + var charactersRemaining = this.text.length() - sourceIndex; + var amountToRead = TypeScript.MathPrototype.min(charactersRemaining, spaceAvailable); + this.text.copyTo(sourceIndex, window, destinationIndex, amountToRead); + return amountToRead; + }; + + Scanner.prototype.currentCharCode = function () { + return this.slidingWindow.currentItem(null); + }; + + Scanner.prototype.absoluteIndex = function () { + return this.slidingWindow.absoluteIndex(); + }; + + Scanner.prototype.setAbsoluteIndex = function (index) { + this.slidingWindow.setAbsoluteIndex(index); + }; + + Scanner.prototype.scan = function (diagnostics, allowRegularExpression) { + var diagnosticsLength = diagnostics.length; + var fullStart = this.slidingWindow.absoluteIndex(); + var leadingTriviaInfo = this.scanTriviaInfo(diagnostics, false); + + var start = this.slidingWindow.absoluteIndex(); + var kindAndFlags = this.scanSyntaxToken(diagnostics, allowRegularExpression); + var end = this.slidingWindow.absoluteIndex(); + + var trailingTriviaInfo = this.scanTriviaInfo(diagnostics, true); + + var isVariableWidthKeyword = (kindAndFlags & -2147483648 /* IsVariableWidthKeyword */) !== 0; + var kind = kindAndFlags & ~-2147483648 /* IsVariableWidthKeyword */; + + var token = this.createToken(fullStart, leadingTriviaInfo, start, kind, end, trailingTriviaInfo, isVariableWidthKeyword); + + return diagnosticsLength !== diagnostics.length ? TypeScript.Syntax.realizeToken(token) : token; + }; + + Scanner.prototype.createToken = function (fullStart, leadingTriviaInfo, start, kind, end, trailingTriviaInfo, isVariableWidthKeyword) { + if (!isVariableWidthKeyword && kind >= 15 /* FirstFixedWidth */) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.FixedWidthTokenWithNoTrivia(kind); + } else { + return new TypeScript.Syntax.FixedWidthTokenWithTrailingTrivia(this.text, fullStart, kind, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.FixedWidthTokenWithLeadingTrivia(this.text, fullStart, kind, leadingTriviaInfo); + } else { + return new TypeScript.Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia(this.text, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo); + } + } else { + var width = end - start; + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.VariableWidthTokenWithNoTrivia(this.text, fullStart, kind, width); + } else { + return new TypeScript.Syntax.VariableWidthTokenWithTrailingTrivia(this.text, fullStart, kind, width, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new TypeScript.Syntax.VariableWidthTokenWithLeadingTrivia(this.text, fullStart, kind, leadingTriviaInfo, width); + } else { + return new TypeScript.Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia(this.text, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo); + } + } + }; + + Scanner.scanTrivia = function (text, start, length, isTrailing) { + var scanner = new Scanner(null, text.subText(new TypeScript.TextSpan(start, length)), 1 /* EcmaScript5 */, Scanner.triviaWindow); + return scanner.scanTrivia(text, start, isTrailing); + }; + + Scanner.prototype.scanTrivia = function (underlyingText, underlyingTextStart, isTrailing) { + var trivia = new Array(); + + while (true) { + if (!this.slidingWindow.isAtEndOfSource()) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + trivia.push(this.scanWhitespaceTrivia(underlyingText, underlyingTextStart)); + continue; + + case 47 /* slash */: + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 47 /* slash */) { + trivia.push(this.scanSingleLineCommentTrivia(underlyingText, underlyingTextStart)); + continue; + } + + if (ch2 === 42 /* asterisk */) { + trivia.push(this.scanMultiLineCommentTrivia(underlyingText, underlyingTextStart)); + continue; + } + + throw TypeScript.Errors.invalidOperation(); + + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + trivia.push(this.scanLineTerminatorSequenceTrivia(ch)); + + if (!isTrailing) { + continue; + } + + break; + + default: + throw TypeScript.Errors.invalidOperation(); + } + } + + return TypeScript.Syntax.triviaList(trivia); + } + }; + + Scanner.prototype.scanTriviaInfo = function (diagnostics, isTrailing) { + var width = 0; + var hasCommentOrNewLine = 0; + + while (true) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + this.slidingWindow.moveToNextItem(); + width++; + continue; + + case 47 /* slash */: + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 47 /* slash */) { + hasCommentOrNewLine |= 2 /* TriviaCommentMask */; + width += this.scanSingleLineCommentTriviaLength(); + continue; + } + + if (ch2 === 42 /* asterisk */) { + hasCommentOrNewLine |= 2 /* TriviaCommentMask */; + width += this.scanMultiLineCommentTriviaLength(diagnostics); + continue; + } + + break; + + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + hasCommentOrNewLine |= 1 /* TriviaNewLineMask */; + width += this.scanLineTerminatorSequenceLength(ch); + + if (!isTrailing) { + continue; + } + + break; + } + + return (width << 2 /* TriviaFullWidthShift */) | hasCommentOrNewLine; + } + }; + + Scanner.prototype.isNewLineCharacter = function (ch) { + switch (ch) { + case 13 /* carriageReturn */: + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + return true; + default: + return false; + } + }; + + Scanner.prototype.scanWhitespaceTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.absoluteIndex(); + + var width = 0; + while (true) { + var ch = this.currentCharCode(); + + switch (ch) { + case 32 /* space */: + case 160 /* nonBreakingSpace */: + case 8192 /* enQuad */: + case 8193 /* emQuad */: + case 8194 /* enSpace */: + case 8195 /* emSpace */: + case 8196 /* threePerEmSpace */: + case 8197 /* fourPerEmSpace */: + case 8198 /* sixPerEmSpace */: + case 8199 /* figureSpace */: + case 8200 /* punctuationSpace */: + case 8201 /* thinSpace */: + case 8202 /* hairSpace */: + case 8203 /* zeroWidthSpace */: + case 8239 /* narrowNoBreakSpace */: + case 12288 /* ideographicSpace */: + + case 9 /* tab */: + case 11 /* verticalTab */: + case 12 /* formFeed */: + case 65279 /* byteOrderMark */: + this.slidingWindow.moveToNextItem(); + width++; + continue; + } + + break; + } + + return TypeScript.Syntax.deferredTrivia(4 /* WhitespaceTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanSingleLineCommentTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.slidingWindow.absoluteIndex(); + var width = this.scanSingleLineCommentTriviaLength(); + + return TypeScript.Syntax.deferredTrivia(7 /* SingleLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanSingleLineCommentTriviaLength = function () { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + var width = 2; + while (true) { + if (this.slidingWindow.isAtEndOfSource() || this.isNewLineCharacter(this.currentCharCode())) { + return width; + } + + this.slidingWindow.moveToNextItem(); + width++; + } + }; + + Scanner.prototype.scanMultiLineCommentTrivia = function (underlyingText, underlyingTextStart) { + var absoluteStartIndex = this.absoluteIndex(); + var width = this.scanMultiLineCommentTriviaLength(null); + + return TypeScript.Syntax.deferredTrivia(6 /* MultiLineCommentTrivia */, underlyingText, underlyingTextStart + absoluteStartIndex, width); + }; + + Scanner.prototype.scanMultiLineCommentTriviaLength = function (diagnostics) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + var width = 2; + while (true) { + if (this.slidingWindow.isAtEndOfSource()) { + if (diagnostics !== null) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), this.slidingWindow.absoluteIndex(), 0, TypeScript.DiagnosticCode.AsteriskSlash_expected, null)); + } + + return width; + } + + var ch = this.currentCharCode(); + if (ch === 42 /* asterisk */ && this.slidingWindow.peekItemN(1) === 47 /* slash */) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + width += 2; + return width; + } + + this.slidingWindow.moveToNextItem(); + width++; + } + }; + + Scanner.prototype.scanLineTerminatorSequenceTrivia = function (ch) { + var absoluteStartIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + var width = this.scanLineTerminatorSequenceLength(ch); + + var text = this.substring(absoluteStartIndex, absoluteStartIndex + width, false); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(absoluteStartIndex); + + return TypeScript.Syntax.trivia(5 /* NewLineTrivia */, text); + }; + + Scanner.prototype.scanLineTerminatorSequenceLength = function (ch) { + this.slidingWindow.moveToNextItem(); + + if (ch === 13 /* carriageReturn */ && this.currentCharCode() === 10 /* lineFeed */) { + this.slidingWindow.moveToNextItem(); + return 2; + } else { + return 1; + } + }; + + Scanner.prototype.scanSyntaxToken = function (diagnostics, allowRegularExpression) { + if (this.slidingWindow.isAtEndOfSource()) { + return 10 /* EndOfFileToken */; + } + + var character = this.currentCharCode(); + + switch (character) { + case 34 /* doubleQuote */: + case 39 /* singleQuote */: + return this.scanStringLiteral(diagnostics); + + case 47 /* slash */: + return this.scanSlashToken(allowRegularExpression); + + case 46 /* dot */: + return this.scanDotToken(diagnostics); + + case 45 /* minus */: + return this.scanMinusToken(); + + case 33 /* exclamation */: + return this.scanExclamationToken(); + + case 61 /* equals */: + return this.scanEqualsToken(); + + case 124 /* bar */: + return this.scanBarToken(); + + case 42 /* asterisk */: + return this.scanAsteriskToken(); + + case 43 /* plus */: + return this.scanPlusToken(); + + case 37 /* percent */: + return this.scanPercentToken(); + + case 38 /* ampersand */: + return this.scanAmpersandToken(); + + case 94 /* caret */: + return this.scanCaretToken(); + + case 60 /* lessThan */: + return this.scanLessThanToken(); + + case 62 /* greaterThan */: + return this.advanceAndSetTokenKind(81 /* GreaterThanToken */); + + case 44 /* comma */: + return this.advanceAndSetTokenKind(79 /* CommaToken */); + + case 58 /* colon */: + return this.advanceAndSetTokenKind(106 /* ColonToken */); + + case 59 /* semicolon */: + return this.advanceAndSetTokenKind(78 /* SemicolonToken */); + + case 126 /* tilde */: + return this.advanceAndSetTokenKind(102 /* TildeToken */); + + case 40 /* openParen */: + return this.advanceAndSetTokenKind(72 /* OpenParenToken */); + + case 41 /* closeParen */: + return this.advanceAndSetTokenKind(73 /* CloseParenToken */); + + case 123 /* openBrace */: + return this.advanceAndSetTokenKind(70 /* OpenBraceToken */); + + case 125 /* closeBrace */: + return this.advanceAndSetTokenKind(71 /* CloseBraceToken */); + + case 91 /* openBracket */: + return this.advanceAndSetTokenKind(74 /* OpenBracketToken */); + + case 93 /* closeBracket */: + return this.advanceAndSetTokenKind(75 /* CloseBracketToken */); + + case 63 /* question */: + return this.advanceAndSetTokenKind(105 /* QuestionToken */); + } + + if (isNumericLiteralStart[character]) { + return this.scanNumericLiteral(diagnostics); + } + + if (isIdentifierStartCharacter[character]) { + var result = this.tryFastScanIdentifierOrKeyword(character); + if (result !== 0 /* None */) { + return result; + } + } + + if (this.isIdentifierStart(this.peekCharOrUnicodeEscape())) { + return this.slowScanIdentifierOrKeyword(diagnostics); + } + + return this.scanDefaultCharacter(character, diagnostics); + }; + + Scanner.prototype.isIdentifierStart = function (interpretedChar) { + if (isIdentifierStartCharacter[interpretedChar]) { + return true; + } + + return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierStart(interpretedChar, this._languageVersion); + }; + + Scanner.prototype.isIdentifierPart = function (interpretedChar) { + if (isIdentifierPartCharacter[interpretedChar]) { + return true; + } + + return interpretedChar > 127 /* maxAsciiCharacter */ && TypeScript.Unicode.isIdentifierPart(interpretedChar, this._languageVersion); + }; + + Scanner.prototype.tryFastScanIdentifierOrKeyword = function (firstCharacter) { + var slidingWindow = this.slidingWindow; + var window = slidingWindow.window; + + var startIndex = slidingWindow.currentRelativeItemIndex; + var endIndex = slidingWindow.windowCount; + var currentIndex = startIndex; + var character = 0; + + while (currentIndex < endIndex) { + character = window[currentIndex]; + if (!isIdentifierPartCharacter[character]) { + break; + } + + currentIndex++; + } + + if (currentIndex === endIndex) { + return 0 /* None */; + } else if (character === 92 /* backslash */ || character > 127 /* maxAsciiCharacter */) { + return 0 /* None */; + } else { + var kind; + var identifierLength = currentIndex - startIndex; + if (isKeywordStartCharacter[firstCharacter]) { + kind = TypeScript.ScannerUtilities.identifierKind(window, startIndex, identifierLength); + } else { + kind = 11 /* IdentifierName */; + } + + slidingWindow.setAbsoluteIndex(slidingWindow.absoluteIndex() + identifierLength); + + return kind; + } + }; + + Scanner.prototype.slowScanIdentifierOrKeyword = function (diagnostics) { + var startIndex = this.slidingWindow.absoluteIndex(); + var sawUnicodeEscape = false; + + do { + var unicodeEscape = this.scanCharOrUnicodeEscape(diagnostics); + sawUnicodeEscape = sawUnicodeEscape || unicodeEscape; + } while(this.isIdentifierPart(this.peekCharOrUnicodeEscape())); + + var length = this.slidingWindow.absoluteIndex() - startIndex; + var text = this.text.substr(startIndex, length, false); + var valueText = TypeScript.Syntax.massageEscapes(text); + + var keywordKind = TypeScript.SyntaxFacts.getTokenKind(valueText); + if (keywordKind >= 15 /* FirstKeyword */ && keywordKind <= 69 /* LastKeyword */) { + if (sawUnicodeEscape) { + return keywordKind | -2147483648 /* IsVariableWidthKeyword */; + } else { + return keywordKind; + } + } + + return 11 /* IdentifierName */; + }; + + Scanner.prototype.scanNumericLiteral = function (diagnostics) { + if (this.isHexNumericLiteral()) { + this.scanHexNumericLiteral(); + } else if (this.isOctalNumericLiteral()) { + this.scanOctalNumericLiteral(diagnostics); + } else { + this.scanDecimalNumericLiteral(); + } + + return 13 /* NumericLiteral */; + }; + + Scanner.prototype.isOctalNumericLiteral = function () { + return this.currentCharCode() === 48 /* _0 */ && TypeScript.CharacterInfo.isOctalDigit(this.slidingWindow.peekItemN(1)); + }; + + Scanner.prototype.scanOctalNumericLiteral = function (diagnostics) { + var position = this.absoluteIndex(); + + while (TypeScript.CharacterInfo.isOctalDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + + if (this.languageVersion() >= 1 /* EcmaScript5 */) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, this.absoluteIndex() - position, TypeScript.DiagnosticCode.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher, null)); + } + }; + + Scanner.prototype.scanDecimalDigits = function () { + while (TypeScript.CharacterInfo.isDecimalDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + }; + + Scanner.prototype.scanDecimalNumericLiteral = function () { + this.scanDecimalDigits(); + + if (this.currentCharCode() === 46 /* dot */) { + this.slidingWindow.moveToNextItem(); + } + + this.scanDecimalDigits(); + + var ch = this.currentCharCode(); + if (ch === 101 /* e */ || ch === 69 /* E */) { + var nextChar1 = this.slidingWindow.peekItemN(1); + + if (TypeScript.CharacterInfo.isDecimalDigit(nextChar1)) { + this.slidingWindow.moveToNextItem(); + this.scanDecimalDigits(); + } else if (nextChar1 === 45 /* minus */ || nextChar1 === 43 /* plus */) { + var nextChar2 = this.slidingWindow.peekItemN(2); + if (TypeScript.CharacterInfo.isDecimalDigit(nextChar2)) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + this.scanDecimalDigits(); + } + } + } + }; + + Scanner.prototype.scanHexNumericLiteral = function () { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + + while (TypeScript.CharacterInfo.isHexDigit(this.currentCharCode())) { + this.slidingWindow.moveToNextItem(); + } + }; + + Scanner.prototype.isHexNumericLiteral = function () { + if (this.currentCharCode() === 48 /* _0 */) { + var ch = this.slidingWindow.peekItemN(1); + + if (ch === 120 /* x */ || ch === 88 /* X */) { + ch = this.slidingWindow.peekItemN(2); + + return TypeScript.CharacterInfo.isHexDigit(ch); + } + } + + return false; + }; + + Scanner.prototype.advanceAndSetTokenKind = function (kind) { + this.slidingWindow.moveToNextItem(); + return kind; + }; + + Scanner.prototype.scanLessThanToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 82 /* LessThanEqualsToken */; + } else if (this.currentCharCode() === 60 /* lessThan */) { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 112 /* LessThanLessThanEqualsToken */; + } else { + return 95 /* LessThanLessThanToken */; + } + } else { + return 80 /* LessThanToken */; + } + }; + + Scanner.prototype.scanBarToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 116 /* BarEqualsToken */; + } else if (this.currentCharCode() === 124 /* bar */) { + this.slidingWindow.moveToNextItem(); + return 104 /* BarBarToken */; + } else { + return 99 /* BarToken */; + } + }; + + Scanner.prototype.scanCaretToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 117 /* CaretEqualsToken */; + } else { + return 100 /* CaretToken */; + } + }; + + Scanner.prototype.scanAmpersandToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 115 /* AmpersandEqualsToken */; + } else if (this.currentCharCode() === 38 /* ampersand */) { + this.slidingWindow.moveToNextItem(); + return 103 /* AmpersandAmpersandToken */; + } else { + return 98 /* AmpersandToken */; + } + }; + + Scanner.prototype.scanPercentToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 111 /* PercentEqualsToken */; + } else { + return 92 /* PercentToken */; + } + }; + + Scanner.prototype.scanMinusToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 109 /* MinusEqualsToken */; + } else if (character === 45 /* minus */) { + this.slidingWindow.moveToNextItem(); + return 94 /* MinusMinusToken */; + } else { + return 90 /* MinusToken */; + } + }; + + Scanner.prototype.scanPlusToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 108 /* PlusEqualsToken */; + } else if (character === 43 /* plus */) { + this.slidingWindow.moveToNextItem(); + return 93 /* PlusPlusToken */; + } else { + return 89 /* PlusToken */; + } + }; + + Scanner.prototype.scanAsteriskToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 110 /* AsteriskEqualsToken */; + } else { + return 91 /* AsteriskToken */; + } + }; + + Scanner.prototype.scanEqualsToken = function () { + this.slidingWindow.moveToNextItem(); + var character = this.currentCharCode(); + if (character === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + return 87 /* EqualsEqualsEqualsToken */; + } else { + return 84 /* EqualsEqualsToken */; + } + } else if (character === 62 /* greaterThan */) { + this.slidingWindow.moveToNextItem(); + return 85 /* EqualsGreaterThanToken */; + } else { + return 107 /* EqualsToken */; + } + }; + + Scanner.prototype.isDotPrefixedNumericLiteral = function () { + if (this.currentCharCode() === 46 /* dot */) { + var ch = this.slidingWindow.peekItemN(1); + return TypeScript.CharacterInfo.isDecimalDigit(ch); + } + + return false; + }; + + Scanner.prototype.scanDotToken = function (diagnostics) { + if (this.isDotPrefixedNumericLiteral()) { + return this.scanNumericLiteral(diagnostics); + } + + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 46 /* dot */ && this.slidingWindow.peekItemN(1) === 46 /* dot */) { + this.slidingWindow.moveToNextItem(); + this.slidingWindow.moveToNextItem(); + return 77 /* DotDotDotToken */; + } else { + return 76 /* DotToken */; + } + }; + + Scanner.prototype.scanSlashToken = function (allowRegularExpression) { + if (allowRegularExpression) { + var result = this.tryScanRegularExpressionToken(); + if (result !== 0 /* None */) { + return result; + } + } + + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + return 119 /* SlashEqualsToken */; + } else { + return 118 /* SlashToken */; + } + }; + + Scanner.prototype.tryScanRegularExpressionToken = function () { + var startIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + this.slidingWindow.moveToNextItem(); + + var inEscape = false; + var inCharacterClass = false; + while (true) { + var ch = this.currentCharCode(); + + if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) { + this.slidingWindow.rewindToPinnedIndex(startIndex); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + return 0 /* None */; + } + + this.slidingWindow.moveToNextItem(); + if (inEscape) { + inEscape = false; + continue; + } + + switch (ch) { + case 92 /* backslash */: + inEscape = true; + continue; + + case 91 /* openBracket */: + inCharacterClass = true; + continue; + + case 93 /* closeBracket */: + inCharacterClass = false; + continue; + + case 47 /* slash */: + if (inCharacterClass) { + continue; + } + + break; + + default: + continue; + } + + break; + } + + while (isIdentifierPartCharacter[this.currentCharCode()]) { + this.slidingWindow.moveToNextItem(); + } + + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + return 12 /* RegularExpressionLiteral */; + }; + + Scanner.prototype.scanExclamationToken = function () { + this.slidingWindow.moveToNextItem(); + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + if (this.currentCharCode() === 61 /* equals */) { + this.slidingWindow.moveToNextItem(); + + return 88 /* ExclamationEqualsEqualsToken */; + } else { + return 86 /* ExclamationEqualsToken */; + } + } else { + return 101 /* ExclamationToken */; + } + }; + + Scanner.prototype.scanDefaultCharacter = function (character, diagnostics) { + var position = this.slidingWindow.absoluteIndex(); + this.slidingWindow.moveToNextItem(); + + var text = String.fromCharCode(character); + var messageText = this.getErrorMessageText(text); + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), position, 1, TypeScript.DiagnosticCode.Unexpected_character_0, [messageText])); + + return 9 /* ErrorToken */; + }; + + Scanner.prototype.getErrorMessageText = function (text) { + if (text === "\\") { + return '"\\"'; + } + + return JSON.stringify(text); + }; + + Scanner.prototype.skipEscapeSequence = function (diagnostics) { + var rewindPoint = this.slidingWindow.getAndPinAbsoluteIndex(); + + this.slidingWindow.moveToNextItem(); + + var ch = this.currentCharCode(); + this.slidingWindow.moveToNextItem(); + switch (ch) { + case 120 /* x */: + case 117 /* u */: + this.slidingWindow.rewindToPinnedIndex(rewindPoint); + var value = this.scanUnicodeOrHexEscape(diagnostics); + break; + + case 13 /* carriageReturn */: + if (this.currentCharCode() === 10 /* lineFeed */) { + this.slidingWindow.moveToNextItem(); + } + break; + + default: + break; + } + + this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint); + }; + + Scanner.prototype.scanStringLiteral = function (diagnostics) { + var quoteCharacter = this.currentCharCode(); + + this.slidingWindow.moveToNextItem(); + + while (true) { + var ch = this.currentCharCode(); + if (ch === 92 /* backslash */) { + this.skipEscapeSequence(diagnostics); + } else if (ch === quoteCharacter) { + this.slidingWindow.moveToNextItem(); + break; + } else if (this.isNewLineCharacter(ch) || this.slidingWindow.isAtEndOfSource()) { + diagnostics.push(new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), TypeScript.MathPrototype.min(this.slidingWindow.absoluteIndex(), this.text.length()), 1, TypeScript.DiagnosticCode.Missing_close_quote_character, null)); + break; + } else { + this.slidingWindow.moveToNextItem(); + } + } + + return 14 /* StringLiteral */; + }; + + Scanner.prototype.isUnicodeEscape = function (character) { + if (character === 92 /* backslash */) { + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 117 /* u */) { + return true; + } + } + + return false; + }; + + Scanner.prototype.peekCharOrUnicodeEscape = function () { + var character = this.currentCharCode(); + if (this.isUnicodeEscape(character)) { + return this.peekUnicodeOrHexEscape(); + } else { + return character; + } + }; + + Scanner.prototype.peekUnicodeOrHexEscape = function () { + var startIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + var ch = this.scanUnicodeOrHexEscape(null); + + this.slidingWindow.rewindToPinnedIndex(startIndex); + this.slidingWindow.releaseAndUnpinAbsoluteIndex(startIndex); + + return ch; + }; + + Scanner.prototype.scanCharOrUnicodeEscape = function (errors) { + var ch = this.currentCharCode(); + if (ch === 92 /* backslash */) { + var ch2 = this.slidingWindow.peekItemN(1); + if (ch2 === 117 /* u */) { + this.scanUnicodeOrHexEscape(errors); + return true; + } + } + + this.slidingWindow.moveToNextItem(); + return false; + }; + + Scanner.prototype.scanUnicodeOrHexEscape = function (errors) { + var start = this.slidingWindow.absoluteIndex(); + var character = this.currentCharCode(); + + this.slidingWindow.moveToNextItem(); + + character = this.currentCharCode(); + + var intChar = 0; + this.slidingWindow.moveToNextItem(); + + var count = character === 117 /* u */ ? 4 : 2; + + for (var i = 0; i < count; i++) { + var ch2 = this.currentCharCode(); + if (!TypeScript.CharacterInfo.isHexDigit(ch2)) { + if (errors !== null) { + var end = this.slidingWindow.absoluteIndex(); + var info = this.createIllegalEscapeDiagnostic(start, end); + errors.push(info); + } + + break; + } + + intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2); + this.slidingWindow.moveToNextItem(); + } + + return intChar; + }; + + Scanner.prototype.substring = function (start, end, intern) { + var length = end - start; + var offset = start - this.slidingWindow.windowAbsoluteStartIndex; + + if (intern) { + return TypeScript.Collections.DefaultStringTable.addCharArray(this.slidingWindow.window, offset, length); + } else { + return TypeScript.StringUtilities.fromCharCodeArray(this.slidingWindow.window.slice(offset, offset + length)); + } + }; + + Scanner.prototype.createIllegalEscapeDiagnostic = function (start, end) { + return new TypeScript.Diagnostic(this.fileName, this.text.lineMap(), start, end - start, TypeScript.DiagnosticCode.Unrecognized_escape_sequence, null); + }; + + Scanner.isValidIdentifier = function (text, languageVersion) { + var scanner = new Scanner(null, text, languageVersion, Scanner.triviaWindow); + var errors = new Array(); + var token = scanner.scan(errors, false); + + return errors.length === 0 && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token) && token.width() === text.length(); + }; + Scanner.triviaWindow = TypeScript.ArrayUtilities.createArray(2048, 0); + return Scanner; + })(); + TypeScript.Scanner = Scanner; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ScannerUtilities = (function () { + function ScannerUtilities() { + } + ScannerUtilities.identifierKind = function (array, startIndex, length) { + switch (length) { + case 2: + switch (array[startIndex]) { + case 100 /* d */: + return (array[startIndex + 1] === 111 /* o */) ? 22 /* DoKeyword */ : 11 /* IdentifierName */; + case 105 /* i */: + switch (array[startIndex + 1]) { + case 102 /* f */: + return 28 /* IfKeyword */; + case 110 /* n */: + return 29 /* InKeyword */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 3: + switch (array[startIndex]) { + case 102 /* f */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 114 /* r */) ? 26 /* ForKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 119 /* w */) ? 31 /* NewKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 121 /* y */) ? 38 /* TryKeyword */ : 11 /* IdentifierName */; + case 118 /* v */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 114 /* r */) ? 40 /* VarKeyword */ : 11 /* IdentifierName */; + case 108 /* l */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 53 /* LetKeyword */ : 11 /* IdentifierName */; + case 97 /* a */: + return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 121 /* y */) ? 60 /* AnyKeyword */ : 11 /* IdentifierName */; + case 103 /* g */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 64 /* GetKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */) ? 68 /* SetKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 4: + switch (array[startIndex]) { + case 99 /* c */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 16 /* CaseKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + switch (array[startIndex + 1]) { + case 108 /* l */: + return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 101 /* e */) ? 23 /* ElseKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 109 /* m */) ? 46 /* EnumKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 110 /* n */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 108 /* l */) ? 32 /* NullKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + switch (array[startIndex + 1]) { + case 104 /* h */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 115 /* s */) ? 35 /* ThisKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 2] === 117 /* u */ && array[startIndex + 3] === 101 /* e */) ? 37 /* TrueKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 118 /* v */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 100 /* d */) ? 41 /* VoidKeyword */ : 11 /* IdentifierName */; + case 119 /* w */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 104 /* h */) ? 43 /* WithKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 5: + switch (array[startIndex]) { + case 98 /* b */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 107 /* k */) ? 15 /* BreakKeyword */ : 11 /* IdentifierName */; + case 99 /* c */: + switch (array[startIndex + 1]) { + case 97 /* a */: + return (array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 104 /* h */) ? 17 /* CatchKeyword */ : 11 /* IdentifierName */; + case 108 /* l */: + return (array[startIndex + 2] === 97 /* a */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 115 /* s */) ? 44 /* ClassKeyword */ : 11 /* IdentifierName */; + case 111 /* o */: + return (array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */) ? 45 /* ConstKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 102 /* f */: + return (array[startIndex + 1] === 97 /* a */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 101 /* e */) ? 24 /* FalseKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 114 /* r */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 119 /* w */) ? 36 /* ThrowKeyword */ : 11 /* IdentifierName */; + case 119 /* w */: + return (array[startIndex + 1] === 104 /* h */ && array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */) ? 42 /* WhileKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */) ? 50 /* SuperKeyword */ : 11 /* IdentifierName */; + case 121 /* y */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 101 /* e */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 100 /* d */) ? 59 /* YieldKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 6: + switch (array[startIndex]) { + case 100 /* d */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 108 /* l */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 101 /* e */) ? 21 /* DeleteKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 110 /* n */) ? 33 /* ReturnKeyword */ : 11 /* IdentifierName */; + case 115 /* s */: + switch (array[startIndex + 1]) { + case 119 /* w */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 99 /* c */ && array[startIndex + 5] === 104 /* h */) ? 34 /* SwitchKeyword */ : 11 /* IdentifierName */; + case 116 /* t */: + switch (array[startIndex + 2]) { + case 97 /* a */: + return (array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 58 /* StaticKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 3] === 105 /* i */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 103 /* g */) ? 69 /* StringKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 116 /* t */: + return (array[startIndex + 1] === 121 /* y */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 111 /* o */ && array[startIndex + 5] === 102 /* f */) ? 39 /* TypeOfKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 47 /* ExportKeyword */ : 11 /* IdentifierName */; + case 105 /* i */: + return (array[startIndex + 1] === 109 /* m */ && array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 111 /* o */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 116 /* t */) ? 49 /* ImportKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 99 /* c */) ? 57 /* PublicKeyword */ : 11 /* IdentifierName */; + case 109 /* m */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 100 /* d */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 101 /* e */) ? 65 /* ModuleKeyword */ : 11 /* IdentifierName */; + case 110 /* n */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 109 /* m */ && array[startIndex + 3] === 98 /* b */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 114 /* r */) ? 67 /* NumberKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 7: + switch (array[startIndex]) { + case 100 /* d */: + switch (array[startIndex + 1]) { + case 101 /* e */: + switch (array[startIndex + 2]) { + case 102 /* f */: + return (array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 117 /* u */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 116 /* t */) ? 20 /* DefaultKeyword */ : 11 /* IdentifierName */; + case 99 /* c */: + return (array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 63 /* DeclareKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 102 /* f */: + return (array[startIndex + 1] === 105 /* i */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 97 /* a */ && array[startIndex + 4] === 108 /* l */ && array[startIndex + 5] === 108 /* l */ && array[startIndex + 6] === 121 /* y */) ? 25 /* FinallyKeyword */ : 11 /* IdentifierName */; + case 101 /* e */: + return (array[startIndex + 1] === 120 /* x */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 110 /* n */ && array[startIndex + 5] === 100 /* d */ && array[startIndex + 6] === 115 /* s */) ? 48 /* ExtendsKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + switch (array[startIndex + 1]) { + case 97 /* a */: + return (array[startIndex + 2] === 99 /* c */ && array[startIndex + 3] === 107 /* k */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */) ? 54 /* PackageKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 2] === 105 /* i */ && array[startIndex + 3] === 118 /* v */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 116 /* t */ && array[startIndex + 6] === 101 /* e */) ? 55 /* PrivateKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 98 /* b */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 97 /* a */ && array[startIndex + 6] === 110 /* n */) ? 61 /* BooleanKeyword */ : 11 /* IdentifierName */; + case 114 /* r */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 113 /* q */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 101 /* e */) ? 66 /* RequireKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 8: + switch (array[startIndex]) { + case 99 /* c */: + return (array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 105 /* i */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 101 /* e */) ? 18 /* ContinueKeyword */ : 11 /* IdentifierName */; + case 100 /* d */: + return (array[startIndex + 1] === 101 /* e */ && array[startIndex + 2] === 98 /* b */ && array[startIndex + 3] === 117 /* u */ && array[startIndex + 4] === 103 /* g */ && array[startIndex + 5] === 103 /* g */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 114 /* r */) ? 19 /* DebuggerKeyword */ : 11 /* IdentifierName */; + case 102 /* f */: + return (array[startIndex + 1] === 117 /* u */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 99 /* c */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 105 /* i */ && array[startIndex + 6] === 111 /* o */ && array[startIndex + 7] === 110 /* n */) ? 27 /* FunctionKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 9: + switch (array[startIndex]) { + case 105 /* i */: + return (array[startIndex + 1] === 110 /* n */ && array[startIndex + 2] === 116 /* t */ && array[startIndex + 3] === 101 /* e */ && array[startIndex + 4] === 114 /* r */ && array[startIndex + 5] === 102 /* f */ && array[startIndex + 6] === 97 /* a */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 101 /* e */) ? 52 /* InterfaceKeyword */ : 11 /* IdentifierName */; + case 112 /* p */: + return (array[startIndex + 1] === 114 /* r */ && array[startIndex + 2] === 111 /* o */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 99 /* c */ && array[startIndex + 6] === 116 /* t */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 100 /* d */) ? 56 /* ProtectedKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + case 10: + switch (array[startIndex]) { + case 105 /* i */: + switch (array[startIndex + 1]) { + case 110 /* n */: + return (array[startIndex + 2] === 115 /* s */ && array[startIndex + 3] === 116 /* t */ && array[startIndex + 4] === 97 /* a */ && array[startIndex + 5] === 110 /* n */ && array[startIndex + 6] === 99 /* c */ && array[startIndex + 7] === 101 /* e */ && array[startIndex + 8] === 111 /* o */ && array[startIndex + 9] === 102 /* f */) ? 30 /* InstanceOfKeyword */ : 11 /* IdentifierName */; + case 109 /* m */: + return (array[startIndex + 2] === 112 /* p */ && array[startIndex + 3] === 108 /* l */ && array[startIndex + 4] === 101 /* e */ && array[startIndex + 5] === 109 /* m */ && array[startIndex + 6] === 101 /* e */ && array[startIndex + 7] === 110 /* n */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 115 /* s */) ? 51 /* ImplementsKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + + default: + return 11 /* IdentifierName */; + } + + case 11: + return (array[startIndex] === 99 /* c */ && array[startIndex + 1] === 111 /* o */ && array[startIndex + 2] === 110 /* n */ && array[startIndex + 3] === 115 /* s */ && array[startIndex + 4] === 116 /* t */ && array[startIndex + 5] === 114 /* r */ && array[startIndex + 6] === 117 /* u */ && array[startIndex + 7] === 99 /* c */ && array[startIndex + 8] === 116 /* t */ && array[startIndex + 9] === 111 /* o */ && array[startIndex + 10] === 114 /* r */) ? 62 /* ConstructorKeyword */ : 11 /* IdentifierName */; + default: + return 11 /* IdentifierName */; + } + }; + return ScannerUtilities; + })(); + TypeScript.ScannerUtilities = ScannerUtilities; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var EmptySeparatedSyntaxList = (function () { + function EmptySeparatedSyntaxList() { + } + EmptySeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + EmptySeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isList = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + + EmptySeparatedSyntaxList.prototype.toJSON = function (key) { + return []; + }; + + EmptySeparatedSyntaxList.prototype.childCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.separatorCount = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.toArray = function () { + return []; + }; + + EmptySeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + return []; + }; + + EmptySeparatedSyntaxList.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.separatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySeparatedSyntaxList.prototype.collectTextElements = function (elements) { + }; + + EmptySeparatedSyntaxList.prototype.firstToken = function () { + return null; + }; + + EmptySeparatedSyntaxList.prototype.lastToken = function () { + return null; + }; + + EmptySeparatedSyntaxList.prototype.fullWidth = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.fullText = function () { + return ""; + }; + + EmptySeparatedSyntaxList.prototype.width = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return false; + }; + + EmptySeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + throw TypeScript.Errors.invalidOperation(); + }; + + EmptySeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + }; + + EmptySeparatedSyntaxList.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySeparatedSyntaxList.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return 0; + }; + + EmptySeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return 0; + }; + return EmptySeparatedSyntaxList; + })(); + + Syntax.emptySeparatedList = new EmptySeparatedSyntaxList(); + + var SingletonSeparatedSyntaxList = (function () { + function SingletonSeparatedSyntaxList(item) { + this.item = item; + } + SingletonSeparatedSyntaxList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + SingletonSeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isList = function () { + return false; + }; + SingletonSeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + + SingletonSeparatedSyntaxList.prototype.childCount = function () { + return 1; + }; + SingletonSeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return 1; + }; + SingletonSeparatedSyntaxList.prototype.separatorCount = function () { + return 0; + }; + + SingletonSeparatedSyntaxList.prototype.toArray = function () { + return [this.item]; + }; + SingletonSeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + return [this.item]; + }; + + SingletonSeparatedSyntaxList.prototype.childAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSeparatedSyntaxList.prototype.separatorAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + SingletonSeparatedSyntaxList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSeparatedSyntaxList.prototype.firstToken = function () { + return this.item.firstToken(); + }; + + SingletonSeparatedSyntaxList.prototype.lastToken = function () { + return this.item.lastToken(); + }; + + SingletonSeparatedSyntaxList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.width = function () { + return this.item.width(); + }; + + SingletonSeparatedSyntaxList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSeparatedSyntaxList.prototype.leadingTrivia = function () { + return this.item.leadingTrivia(); + }; + + SingletonSeparatedSyntaxList.prototype.trailingTrivia = function () { + return this.item.trailingTrivia(); + }; + + SingletonSeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return this.item.leadingTriviaWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return this.item.trailingTriviaWidth(); + }; + + SingletonSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + return this.item.isTypeScriptSpecific(); + }; + + SingletonSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return this.item.isIncrementallyUnusable(); + }; + + SingletonSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + return this.item.findTokenInternal(new TypeScript.PositionedSeparatedList(parent, this, fullStart), position, fullStart); + }; + + SingletonSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + array.splice(index, 0, this.item); + }; + return SingletonSeparatedSyntaxList; + })(); + + var NormalSeparatedSyntaxList = (function () { + function NormalSeparatedSyntaxList(elements) { + this._data = 0; + this.elements = elements; + } + NormalSeparatedSyntaxList.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + NormalSeparatedSyntaxList.prototype.isToken = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isNode = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isList = function () { + return false; + }; + NormalSeparatedSyntaxList.prototype.isSeparatedList = function () { + return true; + }; + NormalSeparatedSyntaxList.prototype.toJSON = function (key) { + return this.elements; + }; + + NormalSeparatedSyntaxList.prototype.childCount = function () { + return this.elements.length; + }; + NormalSeparatedSyntaxList.prototype.nonSeparatorCount = function () { + return TypeScript.IntegerUtilities.integerDivide(this.elements.length + 1, 2); + }; + NormalSeparatedSyntaxList.prototype.separatorCount = function () { + return TypeScript.IntegerUtilities.integerDivide(this.elements.length, 2); + }; + + NormalSeparatedSyntaxList.prototype.toArray = function () { + return this.elements.slice(0); + }; + + NormalSeparatedSyntaxList.prototype.toNonSeparatorArray = function () { + var result = []; + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + result.push(this.nonSeparatorAt(i)); + } + + return result; + }; + + NormalSeparatedSyntaxList.prototype.childAt = function (index) { + if (index < 0 || index >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[index]; + }; + + NormalSeparatedSyntaxList.prototype.nonSeparatorAt = function (index) { + var value = index * 2; + if (value < 0 || value >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[value]; + }; + + NormalSeparatedSyntaxList.prototype.separatorAt = function (index) { + var value = index * 2 + 1; + if (value < 0 || value >= this.elements.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.elements[value]; + }; + + NormalSeparatedSyntaxList.prototype.firstToken = function () { + var token; + for (var i = 0, n = this.elements.length; i < n; i++) { + if (i % 2 === 0) { + var nodeOrToken = this.elements[i]; + token = nodeOrToken.firstToken(); + if (token !== null) { + return token; + } + } else { + token = this.elements[i]; + if (token.width() > 0) { + return token; + } + } + } + + return null; + }; + + NormalSeparatedSyntaxList.prototype.lastToken = function () { + var token; + for (var i = this.elements.length - 1; i >= 0; i--) { + if (i % 2 === 0) { + var nodeOrToken = this.elements[i]; + token = nodeOrToken.lastToken(); + if (token !== null) { + return token; + } + } else { + token = this.elements[i]; + if (token.width() > 0) { + return token; + } + } + } + + return null; + }; + + NormalSeparatedSyntaxList.prototype.fullText = function () { + var elements = []; + this.collectTextElements(elements); + return elements.join(""); + }; + + NormalSeparatedSyntaxList.prototype.isTypeScriptSpecific = function () { + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + if (this.nonSeparatorAt(i).isTypeScriptSpecific()) { + return true; + } + } + + return false; + }; + + NormalSeparatedSyntaxList.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + NormalSeparatedSyntaxList.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + NormalSeparatedSyntaxList.prototype.width = function () { + var fullWidth = this.fullWidth(); + return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.leadingTrivia = function () { + return this.firstToken().leadingTrivia(); + }; + + NormalSeparatedSyntaxList.prototype.trailingTrivia = function () { + return this.lastToken().trailingTrivia(); + }; + + NormalSeparatedSyntaxList.prototype.leadingTriviaWidth = function () { + return this.firstToken().leadingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.trailingTriviaWidth = function () { + return this.lastToken().trailingTriviaWidth(); + }; + + NormalSeparatedSyntaxList.prototype.computeData = function () { + var fullWidth = 0; + var isIncrementallyUnusable = false; + + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + + var childWidth = element.fullWidth(); + fullWidth += childWidth; + + isIncrementallyUnusable = isIncrementallyUnusable || element.isIncrementallyUnusable(); + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + NormalSeparatedSyntaxList.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data = this.computeData(); + } + + return this._data; + }; + + NormalSeparatedSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedSeparatedList(parent, this, fullStart); + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + + var childWidth = element.fullWidth(); + if (position < childWidth) { + return element.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + NormalSeparatedSyntaxList.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.elements.length; i < n; i++) { + var element = this.elements[i]; + element.collectTextElements(elements); + } + }; + + NormalSeparatedSyntaxList.prototype.insertChildrenInto = function (array, index) { + if (index === 0) { + array.unshift.apply(array, this.elements); + } else { + array.splice.apply(array, [index, 0].concat(this.elements)); + } + }; + return NormalSeparatedSyntaxList; + })(); + + function separatedList(nodes) { + return separatedListAndValidate(nodes, false); + } + Syntax.separatedList = separatedList; + + function separatedListAndValidate(nodes, validate) { + if (nodes === undefined || nodes === null || nodes.length === 0) { + return Syntax.emptySeparatedList; + } + + if (validate) { + for (var i = 0; i < nodes.length; i++) { + var item = nodes[i]; + + if (i % 2 === 1) { + } + } + } + + if (nodes.length === 1) { + return new SingletonSeparatedSyntaxList(nodes[0]); + } + + return new NormalSeparatedSyntaxList(nodes); + } + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SlidingWindow = (function () { + function SlidingWindow(source, window, defaultValue, sourceLength) { + if (typeof sourceLength === "undefined") { sourceLength = -1; } + this.source = source; + this.window = window; + this.defaultValue = defaultValue; + this.sourceLength = sourceLength; + this.windowCount = 0; + this.windowAbsoluteStartIndex = 0; + this.currentRelativeItemIndex = 0; + this._pinCount = 0; + this.firstPinnedAbsoluteIndex = -1; + } + SlidingWindow.prototype.windowAbsoluteEndIndex = function () { + return this.windowAbsoluteStartIndex + this.windowCount; + }; + + SlidingWindow.prototype.addMoreItemsToWindow = function (argument) { + if (this.sourceLength >= 0 && this.absoluteIndex() >= this.sourceLength) { + return false; + } + + if (this.windowCount >= this.window.length) { + this.tryShiftOrGrowWindow(); + } + + var spaceAvailable = this.window.length - this.windowCount; + var amountFetched = this.source.fetchMoreItems(argument, this.windowAbsoluteEndIndex(), this.window, this.windowCount, spaceAvailable); + + this.windowCount += amountFetched; + return amountFetched > 0; + }; + + SlidingWindow.prototype.tryShiftOrGrowWindow = function () { + var currentIndexIsPastWindowHalfwayPoint = this.currentRelativeItemIndex > (this.window.length >>> 1); + + var isAllowedToShift = this.firstPinnedAbsoluteIndex === -1 || this.firstPinnedAbsoluteIndex > this.windowAbsoluteStartIndex; + + if (currentIndexIsPastWindowHalfwayPoint && isAllowedToShift) { + var shiftStartIndex = this.firstPinnedAbsoluteIndex === -1 ? this.currentRelativeItemIndex : this.firstPinnedAbsoluteIndex - this.windowAbsoluteStartIndex; + + var shiftCount = this.windowCount - shiftStartIndex; + + if (shiftCount > 0) { + TypeScript.ArrayUtilities.copy(this.window, shiftStartIndex, this.window, 0, shiftCount); + } + + this.windowAbsoluteStartIndex += shiftStartIndex; + + this.windowCount -= shiftStartIndex; + + this.currentRelativeItemIndex -= shiftStartIndex; + } else { + TypeScript.ArrayUtilities.grow(this.window, this.window.length * 2, this.defaultValue); + } + }; + + SlidingWindow.prototype.absoluteIndex = function () { + return this.windowAbsoluteStartIndex + this.currentRelativeItemIndex; + }; + + SlidingWindow.prototype.isAtEndOfSource = function () { + return this.absoluteIndex() >= this.sourceLength; + }; + + SlidingWindow.prototype.getAndPinAbsoluteIndex = function () { + var absoluteIndex = this.absoluteIndex(); + var pinCount = this._pinCount++; + if (pinCount === 0) { + this.firstPinnedAbsoluteIndex = absoluteIndex; + } + + return absoluteIndex; + }; + + SlidingWindow.prototype.releaseAndUnpinAbsoluteIndex = function (absoluteIndex) { + this._pinCount--; + if (this._pinCount === 0) { + this.firstPinnedAbsoluteIndex = -1; + } + }; + + SlidingWindow.prototype.rewindToPinnedIndex = function (absoluteIndex) { + var relativeIndex = absoluteIndex - this.windowAbsoluteStartIndex; + + this.currentRelativeItemIndex = relativeIndex; + }; + + SlidingWindow.prototype.currentItem = function (argument) { + if (this.currentRelativeItemIndex >= this.windowCount) { + if (!this.addMoreItemsToWindow(argument)) { + return this.defaultValue; + } + } + + return this.window[this.currentRelativeItemIndex]; + }; + + SlidingWindow.prototype.peekItemN = function (n) { + while (this.currentRelativeItemIndex + n >= this.windowCount) { + if (!this.addMoreItemsToWindow(null)) { + return this.defaultValue; + } + } + + return this.window[this.currentRelativeItemIndex + n]; + }; + + SlidingWindow.prototype.moveToNextItem = function () { + this.currentRelativeItemIndex++; + }; + + SlidingWindow.prototype.disgardAllItemsFromCurrentIndexOnwards = function () { + this.windowCount = this.currentRelativeItemIndex; + }; + + SlidingWindow.prototype.setAbsoluteIndex = function (absoluteIndex) { + if (this.absoluteIndex() === absoluteIndex) { + return; + } + + if (this._pinCount > 0) { + } + + if (absoluteIndex >= this.windowAbsoluteStartIndex && absoluteIndex < this.windowAbsoluteEndIndex()) { + this.currentRelativeItemIndex = (absoluteIndex - this.windowAbsoluteStartIndex); + } else { + this.windowAbsoluteStartIndex = absoluteIndex; + + this.windowCount = 0; + + this.currentRelativeItemIndex = 0; + } + }; + + SlidingWindow.prototype.pinCount = function () { + return this._pinCount; + }; + return SlidingWindow; + })(); + TypeScript.SlidingWindow = SlidingWindow; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + function emptySourceUnit() { + return TypeScript.Syntax.normalModeFactory.sourceUnit(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(10 /* EndOfFileToken */, { text: "" })); + } + Syntax.emptySourceUnit = emptySourceUnit; + + function getStandaloneExpression(positionedToken) { + var token = positionedToken.token(); + if (positionedToken !== null && positionedToken.kind() === 11 /* IdentifierName */) { + var parentPositionedNode = positionedToken.containingNode(); + var parentNode = parentPositionedNode.node(); + + if (parentNode.kind() === 121 /* QualifiedName */ && parentNode.right === token) { + return parentPositionedNode; + } else if (parentNode.kind() === 212 /* MemberAccessExpression */ && parentNode.name === token) { + return parentPositionedNode; + } + } + + return positionedToken; + } + Syntax.getStandaloneExpression = getStandaloneExpression; + + function isInModuleOrTypeContext(positionedToken) { + if (positionedToken !== null) { + var positionedNodeOrToken = TypeScript.Syntax.getStandaloneExpression(positionedToken); + var parent = positionedNodeOrToken.containingNode(); + + if (parent !== null) { + switch (parent.kind()) { + case 246 /* ModuleNameModuleReference */: + return true; + case 121 /* QualifiedName */: + return true; + default: + return isInTypeOnlyContext(positionedToken); + } + } + } + + return false; + } + Syntax.isInModuleOrTypeContext = isInModuleOrTypeContext; + + function isInTypeOnlyContext(positionedToken) { + var positionedNodeOrToken = TypeScript.Syntax.getStandaloneExpression(positionedToken); + var positionedParent = positionedNodeOrToken.containingNode(); + + var parent = positionedParent.node(); + var nodeOrToken = positionedNodeOrToken.nodeOrToken(); + + if (parent !== null) { + switch (parent.kind()) { + case 124 /* ArrayType */: + return parent.type === nodeOrToken; + case 220 /* CastExpression */: + return parent.type === nodeOrToken; + case 244 /* TypeAnnotation */: + case 230 /* ExtendsHeritageClause */: + case 231 /* ImplementsHeritageClause */: + case 228 /* TypeArgumentList */: + return true; + } + } + + return false; + } + Syntax.isInTypeOnlyContext = isInTypeOnlyContext; + + function childOffset(parent, child) { + var offset = 0; + for (var i = 0, n = parent.childCount(); i < n; i++) { + var current = parent.childAt(i); + if (current === child) { + return offset; + } + + if (current !== null) { + offset += current.fullWidth(); + } + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.childOffset = childOffset; + + function childOffsetAt(parent, index) { + var offset = 0; + for (var i = 0; i < index; i++) { + var current = parent.childAt(i); + if (current !== null) { + offset += current.fullWidth(); + } + } + + return offset; + } + Syntax.childOffsetAt = childOffsetAt; + + function childIndex(parent, child) { + for (var i = 0, n = parent.childCount(); i < n; i++) { + var current = parent.childAt(i); + if (current === child) { + return i; + } + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.childIndex = childIndex; + + function nodeStructuralEquals(node1, node2) { + if (node1 === null) { + return node2 === null; + } + + return node1.structuralEquals(node2); + } + Syntax.nodeStructuralEquals = nodeStructuralEquals; + + function nodeOrTokenStructuralEquals(node1, node2) { + if (node1 === node2) { + return true; + } + + if (node1 === null || node2 === null) { + return false; + } + + if (node1.isToken()) { + return node2.isToken() ? tokenStructuralEquals(node1, node2) : false; + } + + return node2.isNode() ? nodeStructuralEquals(node1, node2) : false; + } + Syntax.nodeOrTokenStructuralEquals = nodeOrTokenStructuralEquals; + + function tokenStructuralEquals(token1, token2) { + if (token1 === token2) { + return true; + } + + if (token1 === null || token2 === null) { + return false; + } + + return token1.kind() === token2.kind() && token1.width() === token2.width() && token1.fullWidth() === token2.fullWidth() && token1.text() === token2.text() && TypeScript.Syntax.triviaListStructuralEquals(token1.leadingTrivia(), token2.leadingTrivia()) && TypeScript.Syntax.triviaListStructuralEquals(token1.trailingTrivia(), token2.trailingTrivia()); + } + Syntax.tokenStructuralEquals = tokenStructuralEquals; + + function triviaListStructuralEquals(triviaList1, triviaList2) { + if (triviaList1.count() !== triviaList2.count()) { + return false; + } + + for (var i = 0, n = triviaList1.count(); i < n; i++) { + if (!TypeScript.Syntax.triviaStructuralEquals(triviaList1.syntaxTriviaAt(i), triviaList2.syntaxTriviaAt(i))) { + return false; + } + } + + return true; + } + Syntax.triviaListStructuralEquals = triviaListStructuralEquals; + + function triviaStructuralEquals(trivia1, trivia2) { + return trivia1.kind() === trivia2.kind() && trivia1.fullWidth() === trivia2.fullWidth() && trivia1.fullText() === trivia2.fullText(); + } + Syntax.triviaStructuralEquals = triviaStructuralEquals; + + function listStructuralEquals(list1, list2) { + if (list1.childCount() !== list2.childCount()) { + return false; + } + + for (var i = 0, n = list1.childCount(); i < n; i++) { + var child1 = list1.childAt(i); + var child2 = list2.childAt(i); + + if (!TypeScript.Syntax.nodeOrTokenStructuralEquals(child1, child2)) { + return false; + } + } + + return true; + } + Syntax.listStructuralEquals = listStructuralEquals; + + function separatedListStructuralEquals(list1, list2) { + if (list1.childCount() !== list2.childCount()) { + return false; + } + + for (var i = 0, n = list1.childCount(); i < n; i++) { + var element1 = list1.childAt(i); + var element2 = list2.childAt(i); + if (!TypeScript.Syntax.nodeOrTokenStructuralEquals(element1, element2)) { + return false; + } + } + + return true; + } + Syntax.separatedListStructuralEquals = separatedListStructuralEquals; + + function elementStructuralEquals(element1, element2) { + if (element1 === element2) { + return true; + } + + if (element1 === null || element2 === null) { + return false; + } + + if (element2.kind() !== element2.kind()) { + return false; + } + + if (element1.isToken()) { + return tokenStructuralEquals(element1, element2); + } else if (element1.isNode()) { + return nodeStructuralEquals(element1, element2); + } else if (element1.isList()) { + return listStructuralEquals(element1, element2); + } else if (element1.isSeparatedList()) { + return separatedListStructuralEquals(element1, element2); + } + + throw TypeScript.Errors.invalidOperation(); + } + Syntax.elementStructuralEquals = elementStructuralEquals; + + function identifierName(text, info) { + if (typeof info === "undefined") { info = null; } + return TypeScript.Syntax.identifier(text); + } + Syntax.identifierName = identifierName; + + function trueExpression() { + return TypeScript.Syntax.token(37 /* TrueKeyword */); + } + Syntax.trueExpression = trueExpression; + + function falseExpression() { + return TypeScript.Syntax.token(24 /* FalseKeyword */); + } + Syntax.falseExpression = falseExpression; + + function numericLiteralExpression(text) { + return TypeScript.Syntax.token(13 /* NumericLiteral */, { text: text }); + } + Syntax.numericLiteralExpression = numericLiteralExpression; + + function stringLiteralExpression(text) { + return TypeScript.Syntax.token(14 /* StringLiteral */, { text: text }); + } + Syntax.stringLiteralExpression = stringLiteralExpression; + + function isSuperInvocationExpression(node) { + return node.kind() === 213 /* InvocationExpression */ && node.expression.kind() === 50 /* SuperKeyword */; + } + Syntax.isSuperInvocationExpression = isSuperInvocationExpression; + + function isSuperInvocationExpressionStatement(node) { + return node.kind() === 149 /* ExpressionStatement */ && isSuperInvocationExpression(node.expression); + } + Syntax.isSuperInvocationExpressionStatement = isSuperInvocationExpressionStatement; + + function isSuperMemberAccessExpression(node) { + return node.kind() === 212 /* MemberAccessExpression */ && node.expression.kind() === 50 /* SuperKeyword */; + } + Syntax.isSuperMemberAccessExpression = isSuperMemberAccessExpression; + + function isSuperMemberAccessInvocationExpression(node) { + return node.kind() === 213 /* InvocationExpression */ && isSuperMemberAccessExpression(node.expression); + } + Syntax.isSuperMemberAccessInvocationExpression = isSuperMemberAccessInvocationExpression; + + function assignmentExpression(left, token, right) { + return TypeScript.Syntax.normalModeFactory.binaryExpression(174 /* AssignmentExpression */, left, token, right); + } + Syntax.assignmentExpression = assignmentExpression; + + function nodeHasSkippedOrMissingTokens(node) { + for (var i = 0; i < node.childCount(); i++) { + var child = node.childAt(i); + if (child !== null && child.isToken()) { + var token = child; + + if (token.hasSkippedToken() || (token.width() === 0 && token.kind() !== 10 /* EndOfFileToken */)) { + return true; + } + } + } + return false; + } + Syntax.nodeHasSkippedOrMissingTokens = nodeHasSkippedOrMissingTokens; + + function isUnterminatedStringLiteral(token) { + if (token && token.kind() === 14 /* StringLiteral */) { + var text = token.text(); + return text.length < 2 || text.charCodeAt(text.length - 1) !== text.charCodeAt(0); + } + + return false; + } + Syntax.isUnterminatedStringLiteral = isUnterminatedStringLiteral; + + function isUnterminatedMultilineCommentTrivia(trivia) { + if (trivia && trivia.kind() === 6 /* MultiLineCommentTrivia */) { + var text = trivia.fullText(); + return text.length < 4 || text.substring(text.length - 2) !== "*/"; + } + return false; + } + Syntax.isUnterminatedMultilineCommentTrivia = isUnterminatedMultilineCommentTrivia; + + function isEntirelyInsideCommentTrivia(trivia, fullStart, position) { + if (trivia && trivia.isComment() && position > fullStart) { + var end = fullStart + trivia.fullWidth(); + if (position < end) { + return true; + } else if (position === end) { + return trivia.kind() === 7 /* SingleLineCommentTrivia */ || isUnterminatedMultilineCommentTrivia(trivia); + } + } + + return false; + } + Syntax.isEntirelyInsideCommentTrivia = isEntirelyInsideCommentTrivia; + + function isEntirelyInsideComment(sourceUnit, position) { + var positionedToken = sourceUnit.findToken(position); + var fullStart = positionedToken.fullStart(); + var triviaList = null; + var lastTriviaBeforeToken = null; + + if (positionedToken.kind() === 10 /* EndOfFileToken */) { + if (positionedToken.token().hasLeadingTrivia()) { + triviaList = positionedToken.token().leadingTrivia(); + } else { + positionedToken = positionedToken.previousToken(); + if (positionedToken) { + if (positionedToken && positionedToken.token().hasTrailingTrivia()) { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + } + } + } else { + if (position <= (fullStart + positionedToken.token().leadingTriviaWidth())) { + triviaList = positionedToken.token().leadingTrivia(); + } else if (position >= (fullStart + positionedToken.token().width())) { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + } + + if (triviaList) { + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + if (position <= fullStart) { + break; + } else if (position <= fullStart + trivia.fullWidth() && trivia.isComment()) { + lastTriviaBeforeToken = trivia; + break; + } + + fullStart += trivia.fullWidth(); + } + } + + return lastTriviaBeforeToken && isEntirelyInsideCommentTrivia(lastTriviaBeforeToken, fullStart, position); + } + Syntax.isEntirelyInsideComment = isEntirelyInsideComment; + + function isEntirelyInStringOrRegularExpressionLiteral(sourceUnit, position) { + var positionedToken = sourceUnit.findToken(position); + + if (positionedToken) { + if (positionedToken.kind() === 10 /* EndOfFileToken */) { + positionedToken = positionedToken.previousToken(); + return positionedToken && positionedToken.token().trailingTriviaWidth() === 0 && isUnterminatedStringLiteral(positionedToken.token()); + } else if (position > positionedToken.start()) { + return (position < positionedToken.end() && (positionedToken.kind() === 14 /* StringLiteral */ || positionedToken.kind() === 12 /* RegularExpressionLiteral */)) || (position <= positionedToken.end() && isUnterminatedStringLiteral(positionedToken.token())); + } + } + + return false; + } + Syntax.isEntirelyInStringOrRegularExpressionLiteral = isEntirelyInStringOrRegularExpressionLiteral; + + function findSkippedTokenInTriviaList(positionedToken, position, lookInLeadingTriviaList) { + var triviaList = null; + var fullStart; + + if (lookInLeadingTriviaList) { + triviaList = positionedToken.token().leadingTrivia(); + fullStart = positionedToken.fullStart(); + } else { + triviaList = positionedToken.token().trailingTrivia(); + fullStart = positionedToken.end(); + } + + if (triviaList && triviaList.hasSkippedToken()) { + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + var triviaWidth = trivia.fullWidth(); + + if (trivia.isSkippedToken() && position >= fullStart && position <= fullStart + triviaWidth) { + return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullStart); + } + + fullStart += triviaWidth; + } + } + + return null; + } + + function findSkippedTokenOnLeftInTriviaList(positionedToken, position, lookInLeadingTriviaList) { + var triviaList = null; + var fullEnd; + + if (lookInLeadingTriviaList) { + triviaList = positionedToken.token().leadingTrivia(); + fullEnd = positionedToken.fullStart() + triviaList.fullWidth(); + } else { + triviaList = positionedToken.token().trailingTrivia(); + fullEnd = positionedToken.fullEnd(); + } + + if (triviaList && triviaList.hasSkippedToken()) { + for (var i = triviaList.count() - 1; i >= 0; i--) { + var trivia = triviaList.syntaxTriviaAt(i); + var triviaWidth = trivia.fullWidth(); + + if (trivia.isSkippedToken() && position >= fullEnd) { + return new TypeScript.PositionedSkippedToken(positionedToken, trivia.skippedToken(), fullEnd - triviaWidth); + } + + fullEnd -= triviaWidth; + } + } + + return null; + } + + function findSkippedTokenInLeadingTriviaList(positionedToken, position) { + return findSkippedTokenInTriviaList(positionedToken, position, true); + } + Syntax.findSkippedTokenInLeadingTriviaList = findSkippedTokenInLeadingTriviaList; + + function findSkippedTokenInTrailingTriviaList(positionedToken, position) { + return findSkippedTokenInTriviaList(positionedToken, position, false); + } + Syntax.findSkippedTokenInTrailingTriviaList = findSkippedTokenInTrailingTriviaList; + + function findSkippedTokenInPositionedToken(positionedToken, position) { + var positionInLeadingTriviaList = (position < positionedToken.start()); + return findSkippedTokenInTriviaList(positionedToken, position, positionInLeadingTriviaList); + } + Syntax.findSkippedTokenInPositionedToken = findSkippedTokenInPositionedToken; + + function findSkippedTokenOnLeft(positionedToken, position) { + var positionInLeadingTriviaList = (position < positionedToken.start()); + return findSkippedTokenOnLeftInTriviaList(positionedToken, position, positionInLeadingTriviaList); + } + Syntax.findSkippedTokenOnLeft = findSkippedTokenOnLeft; + + function getAncestorOfKind(positionedToken, kind) { + while (positionedToken && positionedToken.parent()) { + if (positionedToken.parent().kind() === kind) { + return positionedToken.parent(); + } + + positionedToken = positionedToken.parent(); + } + + return null; + } + Syntax.getAncestorOfKind = getAncestorOfKind; + + function hasAncestorOfKind(positionedToken, kind) { + return TypeScript.Syntax.getAncestorOfKind(positionedToken, kind) !== null; + } + Syntax.hasAncestorOfKind = hasAncestorOfKind; + + function isIntegerLiteral(expression) { + if (expression) { + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + expression = expression.operand; + return expression.isToken() && TypeScript.IntegerUtilities.isInteger(expression.text()); + + case 13 /* NumericLiteral */: + var text = expression.text(); + return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text); + } + } + + return false; + } + Syntax.isIntegerLiteral = isIntegerLiteral; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var NormalModeFactory = (function () { + function NormalModeFactory() { + } + NormalModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) { + return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, false); + }; + NormalModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, false); + }; + NormalModeFactory.prototype.moduleNameModuleReference = function (moduleName) { + return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, false); + }; + NormalModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false); + }; + NormalModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) { + return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, false); + }; + NormalModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) { + return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, false); + }; + NormalModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, false); + }; + NormalModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) { + return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, false); + }; + NormalModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) { + return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, false); + }; + NormalModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) { + return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, false); + }; + NormalModeFactory.prototype.equalsValueClause = function (equalsToken, value) { + return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, false); + }; + NormalModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) { + return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, false); + }; + NormalModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) { + return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, false); + }; + NormalModeFactory.prototype.omittedExpression = function () { + return new TypeScript.OmittedExpressionSyntax(false); + }; + NormalModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) { + return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, false); + }; + NormalModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) { + return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, false); + }; + NormalModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) { + return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, false); + }; + NormalModeFactory.prototype.qualifiedName = function (left, dotToken, right) { + return new TypeScript.QualifiedNameSyntax(left, dotToken, right, false); + }; + NormalModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) { + return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, false); + }; + NormalModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, false); + }; + NormalModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, false); + }; + NormalModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) { + return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, false); + }; + NormalModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) { + return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, false); + }; + NormalModeFactory.prototype.genericType = function (name, typeArgumentList) { + return new TypeScript.GenericTypeSyntax(name, typeArgumentList, false); + }; + NormalModeFactory.prototype.typeQuery = function (typeOfKeyword, name) { + return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, false); + }; + NormalModeFactory.prototype.typeAnnotation = function (colonToken, type) { + return new TypeScript.TypeAnnotationSyntax(colonToken, type, false); + }; + NormalModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) { + return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, false); + }; + NormalModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, false); + }; + NormalModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) { + return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, false); + }; + NormalModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) { + return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, false); + }; + NormalModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, false); + }; + NormalModeFactory.prototype.invocationExpression = function (expression, argumentList) { + return new TypeScript.InvocationExpressionSyntax(expression, argumentList, false); + }; + NormalModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, false); + }; + NormalModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) { + return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, false); + }; + NormalModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, false); + }; + NormalModeFactory.prototype.constructSignature = function (newKeyword, callSignature) { + return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, false); + }; + NormalModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) { + return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, false); + }; + NormalModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, false); + }; + NormalModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) { + return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, false); + }; + NormalModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) { + return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, false); + }; + NormalModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) { + return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, false); + }; + NormalModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) { + return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, false); + }; + NormalModeFactory.prototype.typeParameter = function (identifier, constraint) { + return new TypeScript.TypeParameterSyntax(identifier, constraint, false); + }; + NormalModeFactory.prototype.constraint = function (extendsKeyword, type) { + return new TypeScript.ConstraintSyntax(extendsKeyword, type, false); + }; + NormalModeFactory.prototype.elseClause = function (elseKeyword, statement) { + return new TypeScript.ElseClauseSyntax(elseKeyword, statement, false); + }; + NormalModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, false); + }; + NormalModeFactory.prototype.expressionStatement = function (expression, semicolonToken) { + return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, false); + }; + NormalModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, false); + }; + NormalModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) { + return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, false); + }; + NormalModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, false); + }; + NormalModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) { + return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, false); + }; + NormalModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) { + return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, false); + }; + NormalModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) { + return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, false); + }; + NormalModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) { + return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, false); + }; + NormalModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) { + return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, false); + }; + NormalModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) { + return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, false); + }; + NormalModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, false); + }; + NormalModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) { + return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, false); + }; + NormalModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) { + return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, false); + }; + NormalModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) { + return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) { + return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, false); + }; + NormalModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, false); + }; + NormalModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, false); + }; + NormalModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) { + return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, false); + }; + NormalModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) { + return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, false); + }; + NormalModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) { + return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, false); + }; + NormalModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) { + return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, false); + }; + NormalModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) { + return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, false); + }; + NormalModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) { + return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, false); + }; + NormalModeFactory.prototype.emptyStatement = function (semicolonToken) { + return new TypeScript.EmptyStatementSyntax(semicolonToken, false); + }; + NormalModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) { + return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, false); + }; + NormalModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, false); + }; + NormalModeFactory.prototype.finallyClause = function (finallyKeyword, block) { + return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, false); + }; + NormalModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) { + return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, false); + }; + NormalModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, false); + }; + NormalModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) { + return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, false); + }; + NormalModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) { + return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, false); + }; + NormalModeFactory.prototype.voidExpression = function (voidKeyword, expression) { + return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, false); + }; + NormalModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) { + return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, false); + }; + return NormalModeFactory; + })(); + Syntax.NormalModeFactory = NormalModeFactory; + + var StrictModeFactory = (function () { + function StrictModeFactory() { + } + StrictModeFactory.prototype.sourceUnit = function (moduleElements, endOfFileToken) { + return new TypeScript.SourceUnitSyntax(moduleElements, endOfFileToken, true); + }; + StrictModeFactory.prototype.externalModuleReference = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + return new TypeScript.ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, true); + }; + StrictModeFactory.prototype.moduleNameModuleReference = function (moduleName) { + return new TypeScript.ModuleNameModuleReferenceSyntax(moduleName, true); + }; + StrictModeFactory.prototype.importDeclaration = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new TypeScript.ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, true); + }; + StrictModeFactory.prototype.exportAssignment = function (exportKeyword, equalsToken, identifier, semicolonToken) { + return new TypeScript.ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.classDeclaration = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + return new TypeScript.ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.interfaceDeclaration = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + return new TypeScript.InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, true); + }; + StrictModeFactory.prototype.heritageClause = function (kind, extendsOrImplementsKeyword, typeNames) { + return new TypeScript.HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, true); + }; + StrictModeFactory.prototype.moduleDeclaration = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + return new TypeScript.ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.functionDeclaration = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + return new TypeScript.FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, true); + }; + StrictModeFactory.prototype.variableStatement = function (modifiers, variableDeclaration, semicolonToken) { + return new TypeScript.VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, true); + }; + StrictModeFactory.prototype.variableDeclaration = function (varKeyword, variableDeclarators) { + return new TypeScript.VariableDeclarationSyntax(varKeyword, variableDeclarators, true); + }; + StrictModeFactory.prototype.variableDeclarator = function (propertyName, typeAnnotation, equalsValueClause) { + return new TypeScript.VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, true); + }; + StrictModeFactory.prototype.equalsValueClause = function (equalsToken, value) { + return new TypeScript.EqualsValueClauseSyntax(equalsToken, value, true); + }; + StrictModeFactory.prototype.prefixUnaryExpression = function (kind, operatorToken, operand) { + return new TypeScript.PrefixUnaryExpressionSyntax(kind, operatorToken, operand, true); + }; + StrictModeFactory.prototype.arrayLiteralExpression = function (openBracketToken, expressions, closeBracketToken) { + return new TypeScript.ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, true); + }; + StrictModeFactory.prototype.omittedExpression = function () { + return new TypeScript.OmittedExpressionSyntax(true); + }; + StrictModeFactory.prototype.parenthesizedExpression = function (openParenToken, expression, closeParenToken) { + return new TypeScript.ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, true); + }; + StrictModeFactory.prototype.simpleArrowFunctionExpression = function (identifier, equalsGreaterThanToken, block, expression) { + return new TypeScript.SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, true); + }; + StrictModeFactory.prototype.parenthesizedArrowFunctionExpression = function (callSignature, equalsGreaterThanToken, block, expression) { + return new TypeScript.ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, true); + }; + StrictModeFactory.prototype.qualifiedName = function (left, dotToken, right) { + return new TypeScript.QualifiedNameSyntax(left, dotToken, right, true); + }; + StrictModeFactory.prototype.typeArgumentList = function (lessThanToken, typeArguments, greaterThanToken) { + return new TypeScript.TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, true); + }; + StrictModeFactory.prototype.constructorType = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, true); + }; + StrictModeFactory.prototype.functionType = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + return new TypeScript.FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, true); + }; + StrictModeFactory.prototype.objectType = function (openBraceToken, typeMembers, closeBraceToken) { + return new TypeScript.ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, true); + }; + StrictModeFactory.prototype.arrayType = function (type, openBracketToken, closeBracketToken) { + return new TypeScript.ArrayTypeSyntax(type, openBracketToken, closeBracketToken, true); + }; + StrictModeFactory.prototype.genericType = function (name, typeArgumentList) { + return new TypeScript.GenericTypeSyntax(name, typeArgumentList, true); + }; + StrictModeFactory.prototype.typeQuery = function (typeOfKeyword, name) { + return new TypeScript.TypeQuerySyntax(typeOfKeyword, name, true); + }; + StrictModeFactory.prototype.typeAnnotation = function (colonToken, type) { + return new TypeScript.TypeAnnotationSyntax(colonToken, type, true); + }; + StrictModeFactory.prototype.block = function (openBraceToken, statements, closeBraceToken) { + return new TypeScript.BlockSyntax(openBraceToken, statements, closeBraceToken, true); + }; + StrictModeFactory.prototype.parameter = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + return new TypeScript.ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, true); + }; + StrictModeFactory.prototype.memberAccessExpression = function (expression, dotToken, name) { + return new TypeScript.MemberAccessExpressionSyntax(expression, dotToken, name, true); + }; + StrictModeFactory.prototype.postfixUnaryExpression = function (kind, operand, operatorToken) { + return new TypeScript.PostfixUnaryExpressionSyntax(kind, operand, operatorToken, true); + }; + StrictModeFactory.prototype.elementAccessExpression = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + return new TypeScript.ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, true); + }; + StrictModeFactory.prototype.invocationExpression = function (expression, argumentList) { + return new TypeScript.InvocationExpressionSyntax(expression, argumentList, true); + }; + StrictModeFactory.prototype.argumentList = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + return new TypeScript.ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, true); + }; + StrictModeFactory.prototype.binaryExpression = function (kind, left, operatorToken, right) { + return new TypeScript.BinaryExpressionSyntax(kind, left, operatorToken, right, true); + }; + StrictModeFactory.prototype.conditionalExpression = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + return new TypeScript.ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, true); + }; + StrictModeFactory.prototype.constructSignature = function (newKeyword, callSignature) { + return new TypeScript.ConstructSignatureSyntax(newKeyword, callSignature, true); + }; + StrictModeFactory.prototype.methodSignature = function (propertyName, questionToken, callSignature) { + return new TypeScript.MethodSignatureSyntax(propertyName, questionToken, callSignature, true); + }; + StrictModeFactory.prototype.indexSignature = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + return new TypeScript.IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, true); + }; + StrictModeFactory.prototype.propertySignature = function (propertyName, questionToken, typeAnnotation) { + return new TypeScript.PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, true); + }; + StrictModeFactory.prototype.callSignature = function (typeParameterList, parameterList, typeAnnotation) { + return new TypeScript.CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, true); + }; + StrictModeFactory.prototype.parameterList = function (openParenToken, parameters, closeParenToken) { + return new TypeScript.ParameterListSyntax(openParenToken, parameters, closeParenToken, true); + }; + StrictModeFactory.prototype.typeParameterList = function (lessThanToken, typeParameters, greaterThanToken) { + return new TypeScript.TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, true); + }; + StrictModeFactory.prototype.typeParameter = function (identifier, constraint) { + return new TypeScript.TypeParameterSyntax(identifier, constraint, true); + }; + StrictModeFactory.prototype.constraint = function (extendsKeyword, type) { + return new TypeScript.ConstraintSyntax(extendsKeyword, type, true); + }; + StrictModeFactory.prototype.elseClause = function (elseKeyword, statement) { + return new TypeScript.ElseClauseSyntax(elseKeyword, statement, true); + }; + StrictModeFactory.prototype.ifStatement = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + return new TypeScript.IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, true); + }; + StrictModeFactory.prototype.expressionStatement = function (expression, semicolonToken) { + return new TypeScript.ExpressionStatementSyntax(expression, semicolonToken, true); + }; + StrictModeFactory.prototype.constructorDeclaration = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + return new TypeScript.ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, true); + }; + StrictModeFactory.prototype.memberFunctionDeclaration = function (modifiers, propertyName, callSignature, block, semicolonToken) { + return new TypeScript.MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, true); + }; + StrictModeFactory.prototype.getAccessor = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + return new TypeScript.GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, true); + }; + StrictModeFactory.prototype.setAccessor = function (modifiers, setKeyword, propertyName, parameterList, block) { + return new TypeScript.SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, true); + }; + StrictModeFactory.prototype.memberVariableDeclaration = function (modifiers, variableDeclarator, semicolonToken) { + return new TypeScript.MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, true); + }; + StrictModeFactory.prototype.indexMemberDeclaration = function (modifiers, indexSignature, semicolonToken) { + return new TypeScript.IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, true); + }; + StrictModeFactory.prototype.throwStatement = function (throwKeyword, expression, semicolonToken) { + return new TypeScript.ThrowStatementSyntax(throwKeyword, expression, semicolonToken, true); + }; + StrictModeFactory.prototype.returnStatement = function (returnKeyword, expression, semicolonToken) { + return new TypeScript.ReturnStatementSyntax(returnKeyword, expression, semicolonToken, true); + }; + StrictModeFactory.prototype.objectCreationExpression = function (newKeyword, expression, argumentList) { + return new TypeScript.ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, true); + }; + StrictModeFactory.prototype.switchStatement = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + return new TypeScript.SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, true); + }; + StrictModeFactory.prototype.caseSwitchClause = function (caseKeyword, expression, colonToken, statements) { + return new TypeScript.CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, true); + }; + StrictModeFactory.prototype.defaultSwitchClause = function (defaultKeyword, colonToken, statements) { + return new TypeScript.DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, true); + }; + StrictModeFactory.prototype.breakStatement = function (breakKeyword, identifier, semicolonToken) { + return new TypeScript.BreakStatementSyntax(breakKeyword, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.continueStatement = function (continueKeyword, identifier, semicolonToken) { + return new TypeScript.ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, true); + }; + StrictModeFactory.prototype.forStatement = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + return new TypeScript.ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.forInStatement = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + return new TypeScript.ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.whileStatement = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.withStatement = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + return new TypeScript.WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, true); + }; + StrictModeFactory.prototype.enumDeclaration = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + return new TypeScript.EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, true); + }; + StrictModeFactory.prototype.enumElement = function (propertyName, equalsValueClause) { + return new TypeScript.EnumElementSyntax(propertyName, equalsValueClause, true); + }; + StrictModeFactory.prototype.castExpression = function (lessThanToken, type, greaterThanToken, expression) { + return new TypeScript.CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, true); + }; + StrictModeFactory.prototype.objectLiteralExpression = function (openBraceToken, propertyAssignments, closeBraceToken) { + return new TypeScript.ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, true); + }; + StrictModeFactory.prototype.simplePropertyAssignment = function (propertyName, colonToken, expression) { + return new TypeScript.SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, true); + }; + StrictModeFactory.prototype.functionPropertyAssignment = function (propertyName, callSignature, block) { + return new TypeScript.FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, true); + }; + StrictModeFactory.prototype.functionExpression = function (functionKeyword, identifier, callSignature, block) { + return new TypeScript.FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, true); + }; + StrictModeFactory.prototype.emptyStatement = function (semicolonToken) { + return new TypeScript.EmptyStatementSyntax(semicolonToken, true); + }; + StrictModeFactory.prototype.tryStatement = function (tryKeyword, block, catchClause, finallyClause) { + return new TypeScript.TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, true); + }; + StrictModeFactory.prototype.catchClause = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + return new TypeScript.CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, true); + }; + StrictModeFactory.prototype.finallyClause = function (finallyKeyword, block) { + return new TypeScript.FinallyClauseSyntax(finallyKeyword, block, true); + }; + StrictModeFactory.prototype.labeledStatement = function (identifier, colonToken, statement) { + return new TypeScript.LabeledStatementSyntax(identifier, colonToken, statement, true); + }; + StrictModeFactory.prototype.doStatement = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + return new TypeScript.DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, true); + }; + StrictModeFactory.prototype.typeOfExpression = function (typeOfKeyword, expression) { + return new TypeScript.TypeOfExpressionSyntax(typeOfKeyword, expression, true); + }; + StrictModeFactory.prototype.deleteExpression = function (deleteKeyword, expression) { + return new TypeScript.DeleteExpressionSyntax(deleteKeyword, expression, true); + }; + StrictModeFactory.prototype.voidExpression = function (voidKeyword, expression) { + return new TypeScript.VoidExpressionSyntax(voidKeyword, expression, true); + }; + StrictModeFactory.prototype.debuggerStatement = function (debuggerKeyword, semicolonToken) { + return new TypeScript.DebuggerStatementSyntax(debuggerKeyword, semicolonToken, true); + }; + return StrictModeFactory; + })(); + Syntax.StrictModeFactory = StrictModeFactory; + + Syntax.normalModeFactory = new NormalModeFactory(); + Syntax.strictModeFactory = new StrictModeFactory(); + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (SyntaxFacts) { + function isDirectivePrologueElement(node) { + if (node.kind() === 149 /* ExpressionStatement */) { + var expressionStatement = node; + var expression = expressionStatement.expression; + + if (expression.kind() === 14 /* StringLiteral */) { + return true; + } + } + + return false; + } + SyntaxFacts.isDirectivePrologueElement = isDirectivePrologueElement; + + function isUseStrictDirective(node) { + var expressionStatement = node; + var stringLiteral = expressionStatement.expression; + + var text = stringLiteral.text(); + return text === '"use strict"' || text === "'use strict'"; + } + SyntaxFacts.isUseStrictDirective = isUseStrictDirective; + + function isIdentifierNameOrAnyKeyword(token) { + var tokenKind = token.tokenKind; + return tokenKind === 11 /* IdentifierName */ || TypeScript.SyntaxFacts.isAnyKeyword(tokenKind); + } + SyntaxFacts.isIdentifierNameOrAnyKeyword = isIdentifierNameOrAnyKeyword; + })(TypeScript.SyntaxFacts || (TypeScript.SyntaxFacts = {})); + var SyntaxFacts = TypeScript.SyntaxFacts; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var EmptySyntaxList = (function () { + function EmptySyntaxList() { + } + EmptySyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + EmptySyntaxList.prototype.isNode = function () { + return false; + }; + EmptySyntaxList.prototype.isToken = function () { + return false; + }; + EmptySyntaxList.prototype.isList = function () { + return true; + }; + EmptySyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + EmptySyntaxList.prototype.toJSON = function (key) { + return []; + }; + + EmptySyntaxList.prototype.childCount = function () { + return 0; + }; + + EmptySyntaxList.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptySyntaxList.prototype.toArray = function () { + return []; + }; + + EmptySyntaxList.prototype.collectTextElements = function (elements) { + }; + + EmptySyntaxList.prototype.firstToken = function () { + return null; + }; + + EmptySyntaxList.prototype.lastToken = function () { + return null; + }; + + EmptySyntaxList.prototype.fullWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.width = function () { + return 0; + }; + + EmptySyntaxList.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySyntaxList.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + EmptySyntaxList.prototype.leadingTriviaWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.trailingTriviaWidth = function () { + return 0; + }; + + EmptySyntaxList.prototype.fullText = function () { + return ""; + }; + + EmptySyntaxList.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptySyntaxList.prototype.isIncrementallyUnusable = function () { + return false; + }; + + EmptySyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + throw TypeScript.Errors.invalidOperation(); + }; + + EmptySyntaxList.prototype.insertChildrenInto = function (array, index) { + }; + return EmptySyntaxList; + })(); + Syntax.EmptySyntaxList = EmptySyntaxList; + + Syntax.emptyList = new EmptySyntaxList(); + + var SingletonSyntaxList = (function () { + function SingletonSyntaxList(item) { + this.item = item; + } + SingletonSyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + SingletonSyntaxList.prototype.isToken = function () { + return false; + }; + SingletonSyntaxList.prototype.isNode = function () { + return false; + }; + SingletonSyntaxList.prototype.isList = function () { + return true; + }; + SingletonSyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + SingletonSyntaxList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSyntaxList.prototype.childCount = function () { + return 1; + }; + + SingletonSyntaxList.prototype.childAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSyntaxList.prototype.toArray = function () { + return [this.item]; + }; + + SingletonSyntaxList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSyntaxList.prototype.firstToken = function () { + return this.item.firstToken(); + }; + + SingletonSyntaxList.prototype.lastToken = function () { + return this.item.lastToken(); + }; + + SingletonSyntaxList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSyntaxList.prototype.width = function () { + return this.item.width(); + }; + + SingletonSyntaxList.prototype.leadingTrivia = function () { + return this.item.leadingTrivia(); + }; + + SingletonSyntaxList.prototype.trailingTrivia = function () { + return this.item.trailingTrivia(); + }; + + SingletonSyntaxList.prototype.leadingTriviaWidth = function () { + return this.item.leadingTriviaWidth(); + }; + + SingletonSyntaxList.prototype.trailingTriviaWidth = function () { + return this.item.trailingTriviaWidth(); + }; + + SingletonSyntaxList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSyntaxList.prototype.isTypeScriptSpecific = function () { + return this.item.isTypeScriptSpecific(); + }; + + SingletonSyntaxList.prototype.isIncrementallyUnusable = function () { + return this.item.isIncrementallyUnusable(); + }; + + SingletonSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + return this.item.findTokenInternal(new TypeScript.PositionedList(parent, this, fullStart), position, fullStart); + }; + + SingletonSyntaxList.prototype.insertChildrenInto = function (array, index) { + array.splice(index, 0, this.item); + }; + return SingletonSyntaxList; + })(); + + var NormalSyntaxList = (function () { + function NormalSyntaxList(nodeOrTokens) { + this._data = 0; + this.nodeOrTokens = nodeOrTokens; + } + NormalSyntaxList.prototype.kind = function () { + return 1 /* List */; + }; + + NormalSyntaxList.prototype.isNode = function () { + return false; + }; + NormalSyntaxList.prototype.isToken = function () { + return false; + }; + NormalSyntaxList.prototype.isList = function () { + return true; + }; + NormalSyntaxList.prototype.isSeparatedList = function () { + return false; + }; + + NormalSyntaxList.prototype.toJSON = function (key) { + return this.nodeOrTokens; + }; + + NormalSyntaxList.prototype.childCount = function () { + return this.nodeOrTokens.length; + }; + + NormalSyntaxList.prototype.childAt = function (index) { + if (index < 0 || index >= this.nodeOrTokens.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.nodeOrTokens[index]; + }; + + NormalSyntaxList.prototype.toArray = function () { + return this.nodeOrTokens.slice(0); + }; + + NormalSyntaxList.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var element = this.nodeOrTokens[i]; + element.collectTextElements(elements); + } + }; + + NormalSyntaxList.prototype.firstToken = function () { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var token = this.nodeOrTokens[i].firstToken(); + if (token !== null) { + return token; + } + } + + return null; + }; + + NormalSyntaxList.prototype.lastToken = function () { + for (var i = this.nodeOrTokens.length - 1; i >= 0; i--) { + var token = this.nodeOrTokens[i].lastToken(); + if (token !== null) { + return token; + } + } + + return null; + }; + + NormalSyntaxList.prototype.fullText = function () { + var elements = new Array(); + this.collectTextElements(elements); + return elements.join(""); + }; + + NormalSyntaxList.prototype.isTypeScriptSpecific = function () { + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + if (this.nodeOrTokens[i].isTypeScriptSpecific()) { + return true; + } + } + + return false; + }; + + NormalSyntaxList.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + NormalSyntaxList.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + NormalSyntaxList.prototype.width = function () { + var fullWidth = this.fullWidth(); + return fullWidth - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + NormalSyntaxList.prototype.leadingTrivia = function () { + return this.firstToken().leadingTrivia(); + }; + + NormalSyntaxList.prototype.trailingTrivia = function () { + return this.lastToken().trailingTrivia(); + }; + + NormalSyntaxList.prototype.leadingTriviaWidth = function () { + return this.firstToken().leadingTriviaWidth(); + }; + + NormalSyntaxList.prototype.trailingTriviaWidth = function () { + return this.lastToken().trailingTriviaWidth(); + }; + + NormalSyntaxList.prototype.computeData = function () { + var fullWidth = 0; + var isIncrementallyUnusable = false; + + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var node = this.nodeOrTokens[i]; + fullWidth += node.fullWidth(); + isIncrementallyUnusable = isIncrementallyUnusable || node.isIncrementallyUnusable(); + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + NormalSyntaxList.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data = this.computeData(); + } + + return this._data; + }; + + NormalSyntaxList.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedList(parent, this, fullStart); + for (var i = 0, n = this.nodeOrTokens.length; i < n; i++) { + var nodeOrToken = this.nodeOrTokens[i]; + + var childWidth = nodeOrToken.fullWidth(); + if (position < childWidth) { + return nodeOrToken.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + NormalSyntaxList.prototype.insertChildrenInto = function (array, index) { + if (index === 0) { + array.unshift.apply(array, this.nodeOrTokens); + } else { + array.splice.apply(array, [index, 0].concat(this.nodeOrTokens)); + } + }; + return NormalSyntaxList; + })(); + + function list(nodes) { + if (nodes === undefined || nodes === null || nodes.length === 0) { + return Syntax.emptyList; + } + + if (nodes.length === 1) { + var item = nodes[0]; + return new SingletonSyntaxList(item); + } + + return new NormalSyntaxList(nodes); + } + Syntax.list = list; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxNode = (function () { + function SyntaxNode(parsedInStrictMode) { + this._data = parsedInStrictMode ? 4 /* NodeParsedInStrictModeMask */ : 0; + } + SyntaxNode.prototype.isNode = function () { + return true; + }; + SyntaxNode.prototype.isToken = function () { + return false; + }; + SyntaxNode.prototype.isList = function () { + return false; + }; + SyntaxNode.prototype.isSeparatedList = function () { + return false; + }; + + SyntaxNode.prototype.kind = function () { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.childCount = function () { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.childAt = function (slot) { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.firstToken = function () { + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) { + return element.firstToken(); + } + } + } + + return null; + }; + + SyntaxNode.prototype.lastToken = function () { + for (var i = this.childCount() - 1; i >= 0; i--) { + var element = this.childAt(i); + + if (element !== null) { + if (element.fullWidth() > 0 || element.kind() === 10 /* EndOfFileToken */) { + return element.lastToken(); + } + } + } + + return null; + }; + + SyntaxNode.prototype.insertChildrenInto = function (array, index) { + for (var i = this.childCount() - 1; i >= 0; i--) { + var element = this.childAt(i); + + if (element !== null) { + if (element.isNode() || element.isToken()) { + array.splice(index, 0, element); + } else if (element.isList()) { + element.insertChildrenInto(array, index); + } else if (element.isSeparatedList()) { + element.insertChildrenInto(array, index); + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + } + }; + + SyntaxNode.prototype.leadingTrivia = function () { + var firstToken = this.firstToken(); + return firstToken ? firstToken.leadingTrivia() : TypeScript.Syntax.emptyTriviaList; + }; + + SyntaxNode.prototype.trailingTrivia = function () { + var lastToken = this.lastToken(); + return lastToken ? lastToken.trailingTrivia() : TypeScript.Syntax.emptyTriviaList; + }; + + SyntaxNode.prototype.toJSON = function (key) { + var result = { + kind: TypeScript.SyntaxKind[this.kind()], + fullWidth: this.fullWidth() + }; + + if (this.isIncrementallyUnusable()) { + result.isIncrementallyUnusable = true; + } + + if (this.parsedInStrictMode()) { + result.parsedInStrictMode = true; + } + + for (var i = 0, n = this.childCount(); i < n; i++) { + var value = this.childAt(i); + + if (value) { + for (var name in this) { + if (value === this[name]) { + result[name] = value; + break; + } + } + } + } + + return result; + }; + + SyntaxNode.prototype.accept = function (visitor) { + throw TypeScript.Errors.abstract(); + }; + + SyntaxNode.prototype.fullText = function () { + var elements = []; + this.collectTextElements(elements); + return elements.join(""); + }; + + SyntaxNode.prototype.collectTextElements = function (elements) { + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + element.collectTextElements(elements); + } + } + }; + + SyntaxNode.prototype.replaceToken = function (token1, token2) { + if (token1 === token2) { + return this; + } + + return this.accept(new TypeScript.SyntaxTokenReplacer(token1, token2)); + }; + + SyntaxNode.prototype.withLeadingTrivia = function (trivia) { + return this.replaceToken(this.firstToken(), this.firstToken().withLeadingTrivia(trivia)); + }; + + SyntaxNode.prototype.withTrailingTrivia = function (trivia) { + return this.replaceToken(this.lastToken(), this.lastToken().withTrailingTrivia(trivia)); + }; + + SyntaxNode.prototype.hasLeadingTrivia = function () { + return this.lastToken().hasLeadingTrivia(); + }; + + SyntaxNode.prototype.hasTrailingTrivia = function () { + return this.lastToken().hasTrailingTrivia(); + }; + + SyntaxNode.prototype.isTypeScriptSpecific = function () { + return false; + }; + + SyntaxNode.prototype.isIncrementallyUnusable = function () { + return (this.data() & 2 /* NodeIncrementallyUnusableMask */) !== 0; + }; + + SyntaxNode.prototype.parsedInStrictMode = function () { + return (this.data() & 4 /* NodeParsedInStrictModeMask */) !== 0; + }; + + SyntaxNode.prototype.fullWidth = function () { + return this.data() >>> 3 /* NodeFullWidthShift */; + }; + + SyntaxNode.prototype.computeData = function () { + var slotCount = this.childCount(); + + var fullWidth = 0; + var childWidth = 0; + + var isIncrementallyUnusable = ((this._data & 2 /* NodeIncrementallyUnusableMask */) !== 0) || slotCount === 0; + + for (var i = 0, n = slotCount; i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + childWidth = element.fullWidth(); + fullWidth += childWidth; + + if (!isIncrementallyUnusable) { + isIncrementallyUnusable = element.isIncrementallyUnusable(); + } + } + } + + return (fullWidth << 3 /* NodeFullWidthShift */) | (isIncrementallyUnusable ? 2 /* NodeIncrementallyUnusableMask */ : 0) | 1 /* NodeDataComputed */; + }; + + SyntaxNode.prototype.data = function () { + if ((this._data & 1 /* NodeDataComputed */) === 0) { + this._data |= this.computeData(); + } + + return this._data; + }; + + SyntaxNode.prototype.findToken = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var endOfFileToken = this.tryGetEndOfFileAt(position); + if (endOfFileToken !== null) { + return endOfFileToken; + } + + if (position < 0 || position >= this.fullWidth()) { + throw TypeScript.Errors.argumentOutOfRange("position"); + } + + var positionedToken = this.findTokenInternal(null, position, 0); + + if (includeSkippedTokens) { + return TypeScript.Syntax.findSkippedTokenInPositionedToken(positionedToken, position) || positionedToken; + } + + return positionedToken; + }; + + SyntaxNode.prototype.tryGetEndOfFileAt = function (position) { + if (this.kind() === 120 /* SourceUnit */ && position === this.fullWidth()) { + var sourceUnit = this; + return new TypeScript.PositionedToken(new TypeScript.PositionedNode(null, sourceUnit, 0), sourceUnit.endOfFileToken, sourceUnit.moduleElements.fullWidth()); + } + + return null; + }; + + SyntaxNode.prototype.findTokenInternal = function (parent, position, fullStart) { + parent = new TypeScript.PositionedNode(parent, this, fullStart); + for (var i = 0, n = this.childCount(); i < n; i++) { + var element = this.childAt(i); + + if (element !== null) { + var childWidth = element.fullWidth(); + + if (position < childWidth) { + return element.findTokenInternal(parent, position, fullStart); + } + + position -= childWidth; + fullStart += childWidth; + } + } + + throw TypeScript.Errors.invalidOperation(); + }; + + SyntaxNode.prototype.findTokenOnLeft = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var positionedToken = this.findToken(position, false); + var start = positionedToken.start(); + + if (includeSkippedTokens) { + positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken; + } + + if (position > start) { + return positionedToken; + } + + if (positionedToken.fullStart() === 0) { + return null; + } + + return positionedToken.previousToken(includeSkippedTokens); + }; + + SyntaxNode.prototype.findCompleteTokenOnLeft = function (position, includeSkippedTokens) { + if (typeof includeSkippedTokens === "undefined") { includeSkippedTokens = false; } + var positionedToken = this.findToken(position, false); + + if (includeSkippedTokens) { + positionedToken = TypeScript.Syntax.findSkippedTokenOnLeft(positionedToken, position) || positionedToken; + } + + if (positionedToken.token().width() > 0 && position >= positionedToken.end()) { + return positionedToken; + } + + return positionedToken.previousToken(includeSkippedTokens); + }; + + SyntaxNode.prototype.isModuleElement = function () { + return false; + }; + + SyntaxNode.prototype.isClassElement = function () { + return false; + }; + + SyntaxNode.prototype.isTypeMember = function () { + return false; + }; + + SyntaxNode.prototype.isStatement = function () { + return false; + }; + + SyntaxNode.prototype.isExpression = function () { + return false; + }; + + SyntaxNode.prototype.isSwitchClause = function () { + return false; + }; + + SyntaxNode.prototype.structuralEquals = function (node) { + if (this === node) { + return true; + } + if (node === null) { + return false; + } + if (this.kind() !== node.kind()) { + return false; + } + + for (var i = 0, n = this.childCount(); i < n; i++) { + var element1 = this.childAt(i); + var element2 = node.childAt(i); + + if (!TypeScript.Syntax.elementStructuralEquals(element1, element2)) { + return false; + } + } + + return true; + }; + + SyntaxNode.prototype.width = function () { + return this.fullWidth() - this.leadingTriviaWidth() - this.trailingTriviaWidth(); + }; + + SyntaxNode.prototype.leadingTriviaWidth = function () { + var firstToken = this.firstToken(); + return firstToken === null ? 0 : firstToken.leadingTriviaWidth(); + }; + + SyntaxNode.prototype.trailingTriviaWidth = function () { + var lastToken = this.lastToken(); + return lastToken === null ? 0 : lastToken.trailingTriviaWidth(); + }; + return SyntaxNode; + })(); + TypeScript.SyntaxNode = SyntaxNode; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SourceUnitSyntax = (function (_super) { + __extends(SourceUnitSyntax, _super); + function SourceUnitSyntax(moduleElements, endOfFileToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.moduleElements = moduleElements; + this.endOfFileToken = endOfFileToken; + } + SourceUnitSyntax.prototype.accept = function (visitor) { + return visitor.visitSourceUnit(this); + }; + + SourceUnitSyntax.prototype.kind = function () { + return 120 /* SourceUnit */; + }; + + SourceUnitSyntax.prototype.childCount = function () { + return 2; + }; + + SourceUnitSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.moduleElements; + case 1: + return this.endOfFileToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SourceUnitSyntax.prototype.update = function (moduleElements, endOfFileToken) { + if (this.moduleElements === moduleElements && this.endOfFileToken === endOfFileToken) { + return this; + } + + return new SourceUnitSyntax(moduleElements, endOfFileToken, this.parsedInStrictMode()); + }; + + SourceUnitSyntax.create = function (endOfFileToken) { + return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false); + }; + + SourceUnitSyntax.create1 = function (endOfFileToken) { + return new SourceUnitSyntax(TypeScript.Syntax.emptyList, endOfFileToken, false); + }; + + SourceUnitSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SourceUnitSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SourceUnitSyntax.prototype.withModuleElements = function (moduleElements) { + return this.update(moduleElements, this.endOfFileToken); + }; + + SourceUnitSyntax.prototype.withModuleElement = function (moduleElement) { + return this.withModuleElements(TypeScript.Syntax.list([moduleElement])); + }; + + SourceUnitSyntax.prototype.withEndOfFileToken = function (endOfFileToken) { + return this.update(this.moduleElements, endOfFileToken); + }; + + SourceUnitSyntax.prototype.isTypeScriptSpecific = function () { + if (this.moduleElements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SourceUnitSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SourceUnitSyntax = SourceUnitSyntax; + + var ExternalModuleReferenceSyntax = (function (_super) { + __extends(ExternalModuleReferenceSyntax, _super); + function ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.requireKeyword = requireKeyword; + this.openParenToken = openParenToken; + this.stringLiteral = stringLiteral; + this.closeParenToken = closeParenToken; + } + ExternalModuleReferenceSyntax.prototype.accept = function (visitor) { + return visitor.visitExternalModuleReference(this); + }; + + ExternalModuleReferenceSyntax.prototype.kind = function () { + return 245 /* ExternalModuleReference */; + }; + + ExternalModuleReferenceSyntax.prototype.childCount = function () { + return 4; + }; + + ExternalModuleReferenceSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.requireKeyword; + case 1: + return this.openParenToken; + case 2: + return this.stringLiteral; + case 3: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExternalModuleReferenceSyntax.prototype.isModuleReference = function () { + return true; + }; + + ExternalModuleReferenceSyntax.prototype.update = function (requireKeyword, openParenToken, stringLiteral, closeParenToken) { + if (this.requireKeyword === requireKeyword && this.openParenToken === openParenToken && this.stringLiteral === stringLiteral && this.closeParenToken === closeParenToken) { + return this; + } + + return new ExternalModuleReferenceSyntax(requireKeyword, openParenToken, stringLiteral, closeParenToken, this.parsedInStrictMode()); + }; + + ExternalModuleReferenceSyntax.create1 = function (stringLiteral) { + return new ExternalModuleReferenceSyntax(TypeScript.Syntax.token(66 /* RequireKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), stringLiteral, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ExternalModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExternalModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExternalModuleReferenceSyntax.prototype.withRequireKeyword = function (requireKeyword) { + return this.update(requireKeyword, this.openParenToken, this.stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.requireKeyword, openParenToken, this.stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withStringLiteral = function (stringLiteral) { + return this.update(this.requireKeyword, this.openParenToken, stringLiteral, this.closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.requireKeyword, this.openParenToken, this.stringLiteral, closeParenToken); + }; + + ExternalModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ExternalModuleReferenceSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExternalModuleReferenceSyntax = ExternalModuleReferenceSyntax; + + var ModuleNameModuleReferenceSyntax = (function (_super) { + __extends(ModuleNameModuleReferenceSyntax, _super); + function ModuleNameModuleReferenceSyntax(moduleName, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.moduleName = moduleName; + } + ModuleNameModuleReferenceSyntax.prototype.accept = function (visitor) { + return visitor.visitModuleNameModuleReference(this); + }; + + ModuleNameModuleReferenceSyntax.prototype.kind = function () { + return 246 /* ModuleNameModuleReference */; + }; + + ModuleNameModuleReferenceSyntax.prototype.childCount = function () { + return 1; + }; + + ModuleNameModuleReferenceSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.moduleName; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ModuleNameModuleReferenceSyntax.prototype.isModuleReference = function () { + return true; + }; + + ModuleNameModuleReferenceSyntax.prototype.update = function (moduleName) { + if (this.moduleName === moduleName) { + return this; + } + + return new ModuleNameModuleReferenceSyntax(moduleName, this.parsedInStrictMode()); + }; + + ModuleNameModuleReferenceSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ModuleNameModuleReferenceSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ModuleNameModuleReferenceSyntax.prototype.withModuleName = function (moduleName) { + return this.update(moduleName); + }; + + ModuleNameModuleReferenceSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ModuleNameModuleReferenceSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ModuleNameModuleReferenceSyntax = ModuleNameModuleReferenceSyntax; + + var ImportDeclarationSyntax = (function (_super) { + __extends(ImportDeclarationSyntax, _super); + function ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.importKeyword = importKeyword; + this.identifier = identifier; + this.equalsToken = equalsToken; + this.moduleReference = moduleReference; + this.semicolonToken = semicolonToken; + } + ImportDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitImportDeclaration(this); + }; + + ImportDeclarationSyntax.prototype.kind = function () { + return 133 /* ImportDeclaration */; + }; + + ImportDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + ImportDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.importKeyword; + case 2: + return this.identifier; + case 3: + return this.equalsToken; + case 4: + return this.moduleReference; + case 5: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ImportDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ImportDeclarationSyntax.prototype.update = function (modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + if (this.modifiers === modifiers && this.importKeyword === importKeyword && this.identifier === identifier && this.equalsToken === equalsToken && this.moduleReference === moduleReference && this.semicolonToken === semicolonToken) { + return this; + } + + return new ImportDeclarationSyntax(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, this.parsedInStrictMode()); + }; + + ImportDeclarationSyntax.create = function (importKeyword, identifier, equalsToken, moduleReference, semicolonToken) { + return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, importKeyword, identifier, equalsToken, moduleReference, semicolonToken, false); + }; + + ImportDeclarationSyntax.create1 = function (identifier, moduleReference) { + return new ImportDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(49 /* ImportKeyword */), identifier, TypeScript.Syntax.token(107 /* EqualsToken */), moduleReference, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ImportDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ImportDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ImportDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ImportDeclarationSyntax.prototype.withImportKeyword = function (importKeyword) { + return this.update(this.modifiers, importKeyword, this.identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.importKeyword, identifier, this.equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(this.modifiers, this.importKeyword, this.identifier, equalsToken, this.moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withModuleReference = function (moduleReference) { + return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, moduleReference, this.semicolonToken); + }; + + ImportDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.importKeyword, this.identifier, this.equalsToken, this.moduleReference, semicolonToken); + }; + + ImportDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ImportDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ImportDeclarationSyntax = ImportDeclarationSyntax; + + var ExportAssignmentSyntax = (function (_super) { + __extends(ExportAssignmentSyntax, _super); + function ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.exportKeyword = exportKeyword; + this.equalsToken = equalsToken; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + ExportAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitExportAssignment(this); + }; + + ExportAssignmentSyntax.prototype.kind = function () { + return 134 /* ExportAssignment */; + }; + + ExportAssignmentSyntax.prototype.childCount = function () { + return 4; + }; + + ExportAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.exportKeyword; + case 1: + return this.equalsToken; + case 2: + return this.identifier; + case 3: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExportAssignmentSyntax.prototype.isModuleElement = function () { + return true; + }; + + ExportAssignmentSyntax.prototype.update = function (exportKeyword, equalsToken, identifier, semicolonToken) { + if (this.exportKeyword === exportKeyword && this.equalsToken === equalsToken && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new ExportAssignmentSyntax(exportKeyword, equalsToken, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + ExportAssignmentSyntax.create1 = function (identifier) { + return new ExportAssignmentSyntax(TypeScript.Syntax.token(47 /* ExportKeyword */), TypeScript.Syntax.token(107 /* EqualsToken */), identifier, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ExportAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExportAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExportAssignmentSyntax.prototype.withExportKeyword = function (exportKeyword) { + return this.update(exportKeyword, this.equalsToken, this.identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(this.exportKeyword, equalsToken, this.identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.exportKeyword, this.equalsToken, identifier, this.semicolonToken); + }; + + ExportAssignmentSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.exportKeyword, this.equalsToken, this.identifier, semicolonToken); + }; + + ExportAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ExportAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExportAssignmentSyntax = ExportAssignmentSyntax; + + var ClassDeclarationSyntax = (function (_super) { + __extends(ClassDeclarationSyntax, _super); + function ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.classKeyword = classKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.openBraceToken = openBraceToken; + this.classElements = classElements; + this.closeBraceToken = closeBraceToken; + } + ClassDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitClassDeclaration(this); + }; + + ClassDeclarationSyntax.prototype.kind = function () { + return 131 /* ClassDeclaration */; + }; + + ClassDeclarationSyntax.prototype.childCount = function () { + return 8; + }; + + ClassDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.classKeyword; + case 2: + return this.identifier; + case 3: + return this.typeParameterList; + case 4: + return this.heritageClauses; + case 5: + return this.openBraceToken; + case 6: + return this.classElements; + case 7: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ClassDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ClassDeclarationSyntax.prototype.update = function (modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken) { + if (this.modifiers === modifiers && this.classKeyword === classKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.openBraceToken === openBraceToken && this.classElements === classElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ClassDeclarationSyntax(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken, this.parsedInStrictMode()); + }; + + ClassDeclarationSyntax.create = function (classKeyword, identifier, openBraceToken, closeBraceToken) { + return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, classKeyword, identifier, null, TypeScript.Syntax.emptyList, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + ClassDeclarationSyntax.create1 = function (identifier) { + return new ClassDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(44 /* ClassKeyword */), identifier, null, TypeScript.Syntax.emptyList, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ClassDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ClassDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ClassDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ClassDeclarationSyntax.prototype.withClassKeyword = function (classKeyword) { + return this.update(this.modifiers, classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.classKeyword, identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.modifiers, this.classKeyword, this.identifier, typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, heritageClauses, this.openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) { + return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause])); + }; + + ClassDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, openBraceToken, this.classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withClassElements = function (classElements) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, classElements, this.closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.withClassElement = function (classElement) { + return this.withClassElements(TypeScript.Syntax.list([classElement])); + }; + + ClassDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.classKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.openBraceToken, this.classElements, closeBraceToken); + }; + + ClassDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ClassDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ClassDeclarationSyntax = ClassDeclarationSyntax; + + var InterfaceDeclarationSyntax = (function (_super) { + __extends(InterfaceDeclarationSyntax, _super); + function InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.interfaceKeyword = interfaceKeyword; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.body = body; + } + InterfaceDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitInterfaceDeclaration(this); + }; + + InterfaceDeclarationSyntax.prototype.kind = function () { + return 128 /* InterfaceDeclaration */; + }; + + InterfaceDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + InterfaceDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.interfaceKeyword; + case 2: + return this.identifier; + case 3: + return this.typeParameterList; + case 4: + return this.heritageClauses; + case 5: + return this.body; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + InterfaceDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + InterfaceDeclarationSyntax.prototype.update = function (modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body) { + if (this.modifiers === modifiers && this.interfaceKeyword === interfaceKeyword && this.identifier === identifier && this.typeParameterList === typeParameterList && this.heritageClauses === heritageClauses && this.body === body) { + return this; + } + + return new InterfaceDeclarationSyntax(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, body, this.parsedInStrictMode()); + }; + + InterfaceDeclarationSyntax.create = function (interfaceKeyword, identifier, body) { + return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, interfaceKeyword, identifier, null, TypeScript.Syntax.emptyList, body, false); + }; + + InterfaceDeclarationSyntax.create1 = function (identifier) { + return new InterfaceDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(52 /* InterfaceKeyword */), identifier, null, TypeScript.Syntax.emptyList, ObjectTypeSyntax.create1(), false); + }; + + InterfaceDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + InterfaceDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + InterfaceDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + InterfaceDeclarationSyntax.prototype.withInterfaceKeyword = function (interfaceKeyword) { + return this.update(this.modifiers, interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.interfaceKeyword, identifier, this.typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, typeParameterList, this.heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withHeritageClauses = function (heritageClauses) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, heritageClauses, this.body); + }; + + InterfaceDeclarationSyntax.prototype.withHeritageClause = function (heritageClause) { + return this.withHeritageClauses(TypeScript.Syntax.list([heritageClause])); + }; + + InterfaceDeclarationSyntax.prototype.withBody = function (body) { + return this.update(this.modifiers, this.interfaceKeyword, this.identifier, this.typeParameterList, this.heritageClauses, body); + }; + + InterfaceDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return InterfaceDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.InterfaceDeclarationSyntax = InterfaceDeclarationSyntax; + + var HeritageClauseSyntax = (function (_super) { + __extends(HeritageClauseSyntax, _super); + function HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.extendsOrImplementsKeyword = extendsOrImplementsKeyword; + this.typeNames = typeNames; + + this._kind = kind; + } + HeritageClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitHeritageClause(this); + }; + + HeritageClauseSyntax.prototype.childCount = function () { + return 2; + }; + + HeritageClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.extendsOrImplementsKeyword; + case 1: + return this.typeNames; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + HeritageClauseSyntax.prototype.kind = function () { + return this._kind; + }; + + HeritageClauseSyntax.prototype.update = function (kind, extendsOrImplementsKeyword, typeNames) { + if (this._kind === kind && this.extendsOrImplementsKeyword === extendsOrImplementsKeyword && this.typeNames === typeNames) { + return this; + } + + return new HeritageClauseSyntax(kind, extendsOrImplementsKeyword, typeNames, this.parsedInStrictMode()); + }; + + HeritageClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + HeritageClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + HeritageClauseSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.extendsOrImplementsKeyword, this.typeNames); + }; + + HeritageClauseSyntax.prototype.withExtendsOrImplementsKeyword = function (extendsOrImplementsKeyword) { + return this.update(this._kind, extendsOrImplementsKeyword, this.typeNames); + }; + + HeritageClauseSyntax.prototype.withTypeNames = function (typeNames) { + return this.update(this._kind, this.extendsOrImplementsKeyword, typeNames); + }; + + HeritageClauseSyntax.prototype.withTypeName = function (typeName) { + return this.withTypeNames(TypeScript.Syntax.separatedList([typeName])); + }; + + HeritageClauseSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return HeritageClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.HeritageClauseSyntax = HeritageClauseSyntax; + + var ModuleDeclarationSyntax = (function (_super) { + __extends(ModuleDeclarationSyntax, _super); + function ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.moduleKeyword = moduleKeyword; + this.name = name; + this.stringLiteral = stringLiteral; + this.openBraceToken = openBraceToken; + this.moduleElements = moduleElements; + this.closeBraceToken = closeBraceToken; + } + ModuleDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitModuleDeclaration(this); + }; + + ModuleDeclarationSyntax.prototype.kind = function () { + return 130 /* ModuleDeclaration */; + }; + + ModuleDeclarationSyntax.prototype.childCount = function () { + return 7; + }; + + ModuleDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.moduleKeyword; + case 2: + return this.name; + case 3: + return this.stringLiteral; + case 4: + return this.openBraceToken; + case 5: + return this.moduleElements; + case 6: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ModuleDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + ModuleDeclarationSyntax.prototype.update = function (modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken) { + if (this.modifiers === modifiers && this.moduleKeyword === moduleKeyword && this.name === name && this.stringLiteral === stringLiteral && this.openBraceToken === openBraceToken && this.moduleElements === moduleElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ModuleDeclarationSyntax(modifiers, moduleKeyword, name, stringLiteral, openBraceToken, moduleElements, closeBraceToken, this.parsedInStrictMode()); + }; + + ModuleDeclarationSyntax.create = function (moduleKeyword, openBraceToken, closeBraceToken) { + return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, moduleKeyword, null, null, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + ModuleDeclarationSyntax.create1 = function () { + return new ModuleDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(65 /* ModuleKeyword */), null, null, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ModuleDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ModuleDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ModuleDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ModuleDeclarationSyntax.prototype.withModuleKeyword = function (moduleKeyword) { + return this.update(this.modifiers, moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withName = function (name) { + return this.update(this.modifiers, this.moduleKeyword, name, this.stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withStringLiteral = function (stringLiteral) { + return this.update(this.modifiers, this.moduleKeyword, this.name, stringLiteral, this.openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, openBraceToken, this.moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModuleElements = function (moduleElements) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, moduleElements, this.closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.withModuleElement = function (moduleElement) { + return this.withModuleElements(TypeScript.Syntax.list([moduleElement])); + }; + + ModuleDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.moduleKeyword, this.name, this.stringLiteral, this.openBraceToken, this.moduleElements, closeBraceToken); + }; + + ModuleDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ModuleDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ModuleDeclarationSyntax = ModuleDeclarationSyntax; + + var FunctionDeclarationSyntax = (function (_super) { + __extends(FunctionDeclarationSyntax, _super); + function FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + } + FunctionDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionDeclaration(this); + }; + + FunctionDeclarationSyntax.prototype.kind = function () { + return 129 /* FunctionDeclaration */; + }; + + FunctionDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + FunctionDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.functionKeyword; + case 2: + return this.identifier; + case 3: + return this.callSignature; + case 4: + return this.block; + case 5: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionDeclarationSyntax.prototype.isStatement = function () { + return true; + }; + + FunctionDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + FunctionDeclarationSyntax.prototype.update = function (modifiers, functionKeyword, identifier, callSignature, block, semicolonToken) { + if (this.modifiers === modifiers && this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new FunctionDeclarationSyntax(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken, this.parsedInStrictMode()); + }; + + FunctionDeclarationSyntax.create = function (functionKeyword, identifier, callSignature) { + return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, functionKeyword, identifier, callSignature, null, null, false); + }; + + FunctionDeclarationSyntax.create1 = function (identifier) { + return new FunctionDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(27 /* FunctionKeyword */), identifier, CallSignatureSyntax.create1(), null, null, false); + }; + + FunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + FunctionDeclarationSyntax.prototype.withFunctionKeyword = function (functionKeyword) { + return this.update(this.modifiers, functionKeyword, this.identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.functionKeyword, identifier, this.callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, callSignature, this.block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, block, this.semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.functionKeyword, this.identifier, this.callSignature, this.block, semicolonToken); + }; + + FunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block !== null && this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionDeclarationSyntax = FunctionDeclarationSyntax; + + var VariableStatementSyntax = (function (_super) { + __extends(VariableStatementSyntax, _super); + function VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.variableDeclaration = variableDeclaration; + this.semicolonToken = semicolonToken; + } + VariableStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableStatement(this); + }; + + VariableStatementSyntax.prototype.kind = function () { + return 148 /* VariableStatement */; + }; + + VariableStatementSyntax.prototype.childCount = function () { + return 3; + }; + + VariableStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.variableDeclaration; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableStatementSyntax.prototype.isStatement = function () { + return true; + }; + + VariableStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + VariableStatementSyntax.prototype.update = function (modifiers, variableDeclaration, semicolonToken) { + if (this.modifiers === modifiers && this.variableDeclaration === variableDeclaration && this.semicolonToken === semicolonToken) { + return this; + } + + return new VariableStatementSyntax(modifiers, variableDeclaration, semicolonToken, this.parsedInStrictMode()); + }; + + VariableStatementSyntax.create = function (variableDeclaration, semicolonToken) { + return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, semicolonToken, false); + }; + + VariableStatementSyntax.create1 = function (variableDeclaration) { + return new VariableStatementSyntax(TypeScript.Syntax.emptyList, variableDeclaration, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + VariableStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableStatementSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.variableDeclaration, this.semicolonToken); + }; + + VariableStatementSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + VariableStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.modifiers, variableDeclaration, this.semicolonToken); + }; + + VariableStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.variableDeclaration, semicolonToken); + }; + + VariableStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableStatementSyntax = VariableStatementSyntax; + + var VariableDeclarationSyntax = (function (_super) { + __extends(VariableDeclarationSyntax, _super); + function VariableDeclarationSyntax(varKeyword, variableDeclarators, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.varKeyword = varKeyword; + this.variableDeclarators = variableDeclarators; + } + VariableDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableDeclaration(this); + }; + + VariableDeclarationSyntax.prototype.kind = function () { + return 224 /* VariableDeclaration */; + }; + + VariableDeclarationSyntax.prototype.childCount = function () { + return 2; + }; + + VariableDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.varKeyword; + case 1: + return this.variableDeclarators; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableDeclarationSyntax.prototype.update = function (varKeyword, variableDeclarators) { + if (this.varKeyword === varKeyword && this.variableDeclarators === variableDeclarators) { + return this; + } + + return new VariableDeclarationSyntax(varKeyword, variableDeclarators, this.parsedInStrictMode()); + }; + + VariableDeclarationSyntax.create1 = function (variableDeclarators) { + return new VariableDeclarationSyntax(TypeScript.Syntax.token(40 /* VarKeyword */), variableDeclarators, false); + }; + + VariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableDeclarationSyntax.prototype.withVarKeyword = function (varKeyword) { + return this.update(varKeyword, this.variableDeclarators); + }; + + VariableDeclarationSyntax.prototype.withVariableDeclarators = function (variableDeclarators) { + return this.update(this.varKeyword, variableDeclarators); + }; + + VariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) { + return this.withVariableDeclarators(TypeScript.Syntax.separatedList([variableDeclarator])); + }; + + VariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclarators.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableDeclarationSyntax = VariableDeclarationSyntax; + + var VariableDeclaratorSyntax = (function (_super) { + __extends(VariableDeclaratorSyntax, _super); + function VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + } + VariableDeclaratorSyntax.prototype.accept = function (visitor) { + return visitor.visitVariableDeclarator(this); + }; + + VariableDeclaratorSyntax.prototype.kind = function () { + return 225 /* VariableDeclarator */; + }; + + VariableDeclaratorSyntax.prototype.childCount = function () { + return 3; + }; + + VariableDeclaratorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.typeAnnotation; + case 2: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VariableDeclaratorSyntax.prototype.update = function (propertyName, typeAnnotation, equalsValueClause) { + if (this.propertyName === propertyName && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new VariableDeclaratorSyntax(propertyName, typeAnnotation, equalsValueClause, this.parsedInStrictMode()); + }; + + VariableDeclaratorSyntax.create = function (propertyName) { + return new VariableDeclaratorSyntax(propertyName, null, null, false); + }; + + VariableDeclaratorSyntax.create1 = function (propertyName) { + return new VariableDeclaratorSyntax(propertyName, null, null, false); + }; + + VariableDeclaratorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VariableDeclaratorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VariableDeclaratorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.typeAnnotation, this.equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.propertyName, typeAnnotation, this.equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.propertyName, this.typeAnnotation, equalsValueClause); + }; + + VariableDeclaratorSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeAnnotation !== null) { + return true; + } + if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VariableDeclaratorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VariableDeclaratorSyntax = VariableDeclaratorSyntax; + + var EqualsValueClauseSyntax = (function (_super) { + __extends(EqualsValueClauseSyntax, _super); + function EqualsValueClauseSyntax(equalsToken, value, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.equalsToken = equalsToken; + this.value = value; + } + EqualsValueClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitEqualsValueClause(this); + }; + + EqualsValueClauseSyntax.prototype.kind = function () { + return 232 /* EqualsValueClause */; + }; + + EqualsValueClauseSyntax.prototype.childCount = function () { + return 2; + }; + + EqualsValueClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.equalsToken; + case 1: + return this.value; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EqualsValueClauseSyntax.prototype.update = function (equalsToken, value) { + if (this.equalsToken === equalsToken && this.value === value) { + return this; + } + + return new EqualsValueClauseSyntax(equalsToken, value, this.parsedInStrictMode()); + }; + + EqualsValueClauseSyntax.create1 = function (value) { + return new EqualsValueClauseSyntax(TypeScript.Syntax.token(107 /* EqualsToken */), value, false); + }; + + EqualsValueClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EqualsValueClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EqualsValueClauseSyntax.prototype.withEqualsToken = function (equalsToken) { + return this.update(equalsToken, this.value); + }; + + EqualsValueClauseSyntax.prototype.withValue = function (value) { + return this.update(this.equalsToken, value); + }; + + EqualsValueClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.value.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return EqualsValueClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EqualsValueClauseSyntax = EqualsValueClauseSyntax; + + var PrefixUnaryExpressionSyntax = (function (_super) { + __extends(PrefixUnaryExpressionSyntax, _super); + function PrefixUnaryExpressionSyntax(kind, operatorToken, operand, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.operatorToken = operatorToken; + this.operand = operand; + + this._kind = kind; + } + PrefixUnaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitPrefixUnaryExpression(this); + }; + + PrefixUnaryExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + PrefixUnaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.operatorToken; + case 1: + return this.operand; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PrefixUnaryExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + PrefixUnaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + PrefixUnaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + PrefixUnaryExpressionSyntax.prototype.update = function (kind, operatorToken, operand) { + if (this._kind === kind && this.operatorToken === operatorToken && this.operand === operand) { + return this; + } + + return new PrefixUnaryExpressionSyntax(kind, operatorToken, operand, this.parsedInStrictMode()); + }; + + PrefixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PrefixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PrefixUnaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.operatorToken, this.operand); + }; + + PrefixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, operatorToken, this.operand); + }; + + PrefixUnaryExpressionSyntax.prototype.withOperand = function (operand) { + return this.update(this._kind, this.operatorToken, operand); + }; + + PrefixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.operand.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return PrefixUnaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PrefixUnaryExpressionSyntax = PrefixUnaryExpressionSyntax; + + var ArrayLiteralExpressionSyntax = (function (_super) { + __extends(ArrayLiteralExpressionSyntax, _super); + function ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBracketToken = openBracketToken; + this.expressions = expressions; + this.closeBracketToken = closeBracketToken; + } + ArrayLiteralExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitArrayLiteralExpression(this); + }; + + ArrayLiteralExpressionSyntax.prototype.kind = function () { + return 214 /* ArrayLiteralExpression */; + }; + + ArrayLiteralExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ArrayLiteralExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBracketToken; + case 1: + return this.expressions; + case 2: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArrayLiteralExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ArrayLiteralExpressionSyntax.prototype.update = function (openBracketToken, expressions, closeBracketToken) { + if (this.openBracketToken === openBracketToken && this.expressions === expressions && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ArrayLiteralExpressionSyntax(openBracketToken, expressions, closeBracketToken, this.parsedInStrictMode()); + }; + + ArrayLiteralExpressionSyntax.create = function (openBracketToken, closeBracketToken) { + return new ArrayLiteralExpressionSyntax(openBracketToken, TypeScript.Syntax.emptySeparatedList, closeBracketToken, false); + }; + + ArrayLiteralExpressionSyntax.create1 = function () { + return new ArrayLiteralExpressionSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ArrayLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArrayLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArrayLiteralExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(openBracketToken, this.expressions, this.closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.withExpressions = function (expressions) { + return this.update(this.openBracketToken, expressions, this.closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.withExpression = function (expression) { + return this.withExpressions(TypeScript.Syntax.separatedList([expression])); + }; + + ArrayLiteralExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.openBracketToken, this.expressions, closeBracketToken); + }; + + ArrayLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expressions.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ArrayLiteralExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArrayLiteralExpressionSyntax = ArrayLiteralExpressionSyntax; + + var OmittedExpressionSyntax = (function (_super) { + __extends(OmittedExpressionSyntax, _super); + function OmittedExpressionSyntax(parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + } + OmittedExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitOmittedExpression(this); + }; + + OmittedExpressionSyntax.prototype.kind = function () { + return 223 /* OmittedExpression */; + }; + + OmittedExpressionSyntax.prototype.childCount = function () { + return 0; + }; + + OmittedExpressionSyntax.prototype.childAt = function (slot) { + throw TypeScript.Errors.invalidOperation(); + }; + + OmittedExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + OmittedExpressionSyntax.prototype.update = function () { + return this; + }; + + OmittedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + OmittedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + OmittedExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return OmittedExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.OmittedExpressionSyntax = OmittedExpressionSyntax; + + var ParenthesizedExpressionSyntax = (function (_super) { + __extends(ParenthesizedExpressionSyntax, _super); + function ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + } + ParenthesizedExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitParenthesizedExpression(this); + }; + + ParenthesizedExpressionSyntax.prototype.kind = function () { + return 217 /* ParenthesizedExpression */; + }; + + ParenthesizedExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ParenthesizedExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openParenToken; + case 1: + return this.expression; + case 2: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParenthesizedExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ParenthesizedExpressionSyntax.prototype.update = function (openParenToken, expression, closeParenToken) { + if (this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken) { + return this; + } + + return new ParenthesizedExpressionSyntax(openParenToken, expression, closeParenToken, this.parsedInStrictMode()); + }; + + ParenthesizedExpressionSyntax.create1 = function (expression) { + return new ParenthesizedExpressionSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ParenthesizedExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParenthesizedExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParenthesizedExpressionSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(openParenToken, this.expression, this.closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.openParenToken, expression, this.closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.openParenToken, this.expression, closeParenToken); + }; + + ParenthesizedExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ParenthesizedExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParenthesizedExpressionSyntax = ParenthesizedExpressionSyntax; + + var SimpleArrowFunctionExpressionSyntax = (function (_super) { + __extends(SimpleArrowFunctionExpressionSyntax, _super); + function SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + } + SimpleArrowFunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitSimpleArrowFunctionExpression(this); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.kind = function () { + return 219 /* SimpleArrowFunctionExpression */; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.equalsGreaterThanToken; + case 2: + return this.block; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + SimpleArrowFunctionExpressionSyntax.prototype.update = function (identifier, equalsGreaterThanToken, block, expression) { + if (this.identifier === identifier && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) { + return this; + } + + return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, block, expression, this.parsedInStrictMode()); + }; + + SimpleArrowFunctionExpressionSyntax.create = function (identifier, equalsGreaterThanToken) { + return new SimpleArrowFunctionExpressionSyntax(identifier, equalsGreaterThanToken, null, null, false); + }; + + SimpleArrowFunctionExpressionSyntax.create1 = function (identifier) { + return new SimpleArrowFunctionExpressionSyntax(identifier, TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.equalsGreaterThanToken, this.block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.identifier, equalsGreaterThanToken, this.block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.identifier, this.equalsGreaterThanToken, block, this.expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.identifier, this.equalsGreaterThanToken, this.block, expression); + }; + + SimpleArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return SimpleArrowFunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SimpleArrowFunctionExpressionSyntax = SimpleArrowFunctionExpressionSyntax; + + var ParenthesizedArrowFunctionExpressionSyntax = (function (_super) { + __extends(ParenthesizedArrowFunctionExpressionSyntax, _super); + function ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.callSignature = callSignature; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.block = block; + this.expression = expression; + } + ParenthesizedArrowFunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitParenthesizedArrowFunctionExpression(this); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.kind = function () { + return 218 /* ParenthesizedArrowFunctionExpression */; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.callSignature; + case 1: + return this.equalsGreaterThanToken; + case 2: + return this.block; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isArrowFunctionExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.update = function (callSignature, equalsGreaterThanToken, block, expression) { + if (this.callSignature === callSignature && this.equalsGreaterThanToken === equalsGreaterThanToken && this.block === block && this.expression === expression) { + return this; + } + + return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, block, expression, this.parsedInStrictMode()); + }; + + ParenthesizedArrowFunctionExpressionSyntax.create = function (callSignature, equalsGreaterThanToken) { + return new ParenthesizedArrowFunctionExpressionSyntax(callSignature, equalsGreaterThanToken, null, null, false); + }; + + ParenthesizedArrowFunctionExpressionSyntax.create1 = function () { + return new ParenthesizedArrowFunctionExpressionSyntax(CallSignatureSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), null, null, false); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(callSignature, this.equalsGreaterThanToken, this.block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.callSignature, equalsGreaterThanToken, this.block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.callSignature, this.equalsGreaterThanToken, block, this.expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.callSignature, this.equalsGreaterThanToken, this.block, expression); + }; + + ParenthesizedArrowFunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ParenthesizedArrowFunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParenthesizedArrowFunctionExpressionSyntax = ParenthesizedArrowFunctionExpressionSyntax; + + var QualifiedNameSyntax = (function (_super) { + __extends(QualifiedNameSyntax, _super); + function QualifiedNameSyntax(left, dotToken, right, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.left = left; + this.dotToken = dotToken; + this.right = right; + } + QualifiedNameSyntax.prototype.accept = function (visitor) { + return visitor.visitQualifiedName(this); + }; + + QualifiedNameSyntax.prototype.kind = function () { + return 121 /* QualifiedName */; + }; + + QualifiedNameSyntax.prototype.childCount = function () { + return 3; + }; + + QualifiedNameSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.left; + case 1: + return this.dotToken; + case 2: + return this.right; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + QualifiedNameSyntax.prototype.isName = function () { + return true; + }; + + QualifiedNameSyntax.prototype.isType = function () { + return true; + }; + + QualifiedNameSyntax.prototype.update = function (left, dotToken, right) { + if (this.left === left && this.dotToken === dotToken && this.right === right) { + return this; + } + + return new QualifiedNameSyntax(left, dotToken, right, this.parsedInStrictMode()); + }; + + QualifiedNameSyntax.create1 = function (left, right) { + return new QualifiedNameSyntax(left, TypeScript.Syntax.token(76 /* DotToken */), right, false); + }; + + QualifiedNameSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + QualifiedNameSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + QualifiedNameSyntax.prototype.withLeft = function (left) { + return this.update(left, this.dotToken, this.right); + }; + + QualifiedNameSyntax.prototype.withDotToken = function (dotToken) { + return this.update(this.left, dotToken, this.right); + }; + + QualifiedNameSyntax.prototype.withRight = function (right) { + return this.update(this.left, this.dotToken, right); + }; + + QualifiedNameSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return QualifiedNameSyntax; + })(TypeScript.SyntaxNode); + TypeScript.QualifiedNameSyntax = QualifiedNameSyntax; + + var TypeArgumentListSyntax = (function (_super) { + __extends(TypeArgumentListSyntax, _super); + function TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.typeArguments = typeArguments; + this.greaterThanToken = greaterThanToken; + } + TypeArgumentListSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeArgumentList(this); + }; + + TypeArgumentListSyntax.prototype.kind = function () { + return 228 /* TypeArgumentList */; + }; + + TypeArgumentListSyntax.prototype.childCount = function () { + return 3; + }; + + TypeArgumentListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.typeArguments; + case 2: + return this.greaterThanToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeArgumentListSyntax.prototype.update = function (lessThanToken, typeArguments, greaterThanToken) { + if (this.lessThanToken === lessThanToken && this.typeArguments === typeArguments && this.greaterThanToken === greaterThanToken) { + return this; + } + + return new TypeArgumentListSyntax(lessThanToken, typeArguments, greaterThanToken, this.parsedInStrictMode()); + }; + + TypeArgumentListSyntax.create = function (lessThanToken, greaterThanToken) { + return new TypeArgumentListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false); + }; + + TypeArgumentListSyntax.create1 = function () { + return new TypeArgumentListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false); + }; + + TypeArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeArgumentListSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.typeArguments, this.greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.withTypeArguments = function (typeArguments) { + return this.update(this.lessThanToken, typeArguments, this.greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.withTypeArgument = function (typeArgument) { + return this.withTypeArguments(TypeScript.Syntax.separatedList([typeArgument])); + }; + + TypeArgumentListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.typeArguments, greaterThanToken); + }; + + TypeArgumentListSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeArgumentListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeArgumentListSyntax = TypeArgumentListSyntax; + + var ConstructorTypeSyntax = (function (_super) { + __extends(ConstructorTypeSyntax, _super); + function ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + } + ConstructorTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructorType(this); + }; + + ConstructorTypeSyntax.prototype.kind = function () { + return 125 /* ConstructorType */; + }; + + ConstructorTypeSyntax.prototype.childCount = function () { + return 5; + }; + + ConstructorTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.typeParameterList; + case 2: + return this.parameterList; + case 3: + return this.equalsGreaterThanToken; + case 4: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructorTypeSyntax.prototype.isType = function () { + return true; + }; + + ConstructorTypeSyntax.prototype.update = function (newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type) { + if (this.newKeyword === newKeyword && this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) { + return this; + } + + return new ConstructorTypeSyntax(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode()); + }; + + ConstructorTypeSyntax.create = function (newKeyword, parameterList, equalsGreaterThanToken, type) { + return new ConstructorTypeSyntax(newKeyword, null, parameterList, equalsGreaterThanToken, type, false); + }; + + ConstructorTypeSyntax.create1 = function (type) { + return new ConstructorTypeSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false); + }; + + ConstructorTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructorTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructorTypeSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(this.newKeyword, typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.newKeyword, this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.newKeyword, this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type); + }; + + ConstructorTypeSyntax.prototype.withType = function (type) { + return this.update(this.newKeyword, this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type); + }; + + ConstructorTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructorTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructorTypeSyntax = ConstructorTypeSyntax; + + var FunctionTypeSyntax = (function (_super) { + __extends(FunctionTypeSyntax, _super); + function FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.equalsGreaterThanToken = equalsGreaterThanToken; + this.type = type; + } + FunctionTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionType(this); + }; + + FunctionTypeSyntax.prototype.kind = function () { + return 123 /* FunctionType */; + }; + + FunctionTypeSyntax.prototype.childCount = function () { + return 4; + }; + + FunctionTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeParameterList; + case 1: + return this.parameterList; + case 2: + return this.equalsGreaterThanToken; + case 3: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionTypeSyntax.prototype.isType = function () { + return true; + }; + + FunctionTypeSyntax.prototype.update = function (typeParameterList, parameterList, equalsGreaterThanToken, type) { + if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.equalsGreaterThanToken === equalsGreaterThanToken && this.type === type) { + return this; + } + + return new FunctionTypeSyntax(typeParameterList, parameterList, equalsGreaterThanToken, type, this.parsedInStrictMode()); + }; + + FunctionTypeSyntax.create = function (parameterList, equalsGreaterThanToken, type) { + return new FunctionTypeSyntax(null, parameterList, equalsGreaterThanToken, type, false); + }; + + FunctionTypeSyntax.create1 = function (type) { + return new FunctionTypeSyntax(null, ParameterListSyntax.create1(), TypeScript.Syntax.token(85 /* EqualsGreaterThanToken */), type, false); + }; + + FunctionTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionTypeSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(typeParameterList, this.parameterList, this.equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.typeParameterList, parameterList, this.equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withEqualsGreaterThanToken = function (equalsGreaterThanToken) { + return this.update(this.typeParameterList, this.parameterList, equalsGreaterThanToken, this.type); + }; + + FunctionTypeSyntax.prototype.withType = function (type) { + return this.update(this.typeParameterList, this.parameterList, this.equalsGreaterThanToken, type); + }; + + FunctionTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return FunctionTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionTypeSyntax = FunctionTypeSyntax; + + var ObjectTypeSyntax = (function (_super) { + __extends(ObjectTypeSyntax, _super); + function ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.typeMembers = typeMembers; + this.closeBraceToken = closeBraceToken; + } + ObjectTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectType(this); + }; + + ObjectTypeSyntax.prototype.kind = function () { + return 122 /* ObjectType */; + }; + + ObjectTypeSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.typeMembers; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectTypeSyntax.prototype.isType = function () { + return true; + }; + + ObjectTypeSyntax.prototype.update = function (openBraceToken, typeMembers, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.typeMembers === typeMembers && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ObjectTypeSyntax(openBraceToken, typeMembers, closeBraceToken, this.parsedInStrictMode()); + }; + + ObjectTypeSyntax.create = function (openBraceToken, closeBraceToken) { + return new ObjectTypeSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + ObjectTypeSyntax.create1 = function () { + return new ObjectTypeSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ObjectTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectTypeSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.typeMembers, this.closeBraceToken); + }; + + ObjectTypeSyntax.prototype.withTypeMembers = function (typeMembers) { + return this.update(this.openBraceToken, typeMembers, this.closeBraceToken); + }; + + ObjectTypeSyntax.prototype.withTypeMember = function (typeMember) { + return this.withTypeMembers(TypeScript.Syntax.separatedList([typeMember])); + }; + + ObjectTypeSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.typeMembers, closeBraceToken); + }; + + ObjectTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ObjectTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectTypeSyntax = ObjectTypeSyntax; + + var ArrayTypeSyntax = (function (_super) { + __extends(ArrayTypeSyntax, _super); + function ArrayTypeSyntax(type, openBracketToken, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.type = type; + this.openBracketToken = openBracketToken; + this.closeBracketToken = closeBracketToken; + } + ArrayTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitArrayType(this); + }; + + ArrayTypeSyntax.prototype.kind = function () { + return 124 /* ArrayType */; + }; + + ArrayTypeSyntax.prototype.childCount = function () { + return 3; + }; + + ArrayTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.type; + case 1: + return this.openBracketToken; + case 2: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArrayTypeSyntax.prototype.isType = function () { + return true; + }; + + ArrayTypeSyntax.prototype.update = function (type, openBracketToken, closeBracketToken) { + if (this.type === type && this.openBracketToken === openBracketToken && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ArrayTypeSyntax(type, openBracketToken, closeBracketToken, this.parsedInStrictMode()); + }; + + ArrayTypeSyntax.create1 = function (type) { + return new ArrayTypeSyntax(type, TypeScript.Syntax.token(74 /* OpenBracketToken */), TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ArrayTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArrayTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArrayTypeSyntax.prototype.withType = function (type) { + return this.update(type, this.openBracketToken, this.closeBracketToken); + }; + + ArrayTypeSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(this.type, openBracketToken, this.closeBracketToken); + }; + + ArrayTypeSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.type, this.openBracketToken, closeBracketToken); + }; + + ArrayTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ArrayTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArrayTypeSyntax = ArrayTypeSyntax; + + var GenericTypeSyntax = (function (_super) { + __extends(GenericTypeSyntax, _super); + function GenericTypeSyntax(name, typeArgumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.name = name; + this.typeArgumentList = typeArgumentList; + } + GenericTypeSyntax.prototype.accept = function (visitor) { + return visitor.visitGenericType(this); + }; + + GenericTypeSyntax.prototype.kind = function () { + return 126 /* GenericType */; + }; + + GenericTypeSyntax.prototype.childCount = function () { + return 2; + }; + + GenericTypeSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.name; + case 1: + return this.typeArgumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + GenericTypeSyntax.prototype.isType = function () { + return true; + }; + + GenericTypeSyntax.prototype.update = function (name, typeArgumentList) { + if (this.name === name && this.typeArgumentList === typeArgumentList) { + return this; + } + + return new GenericTypeSyntax(name, typeArgumentList, this.parsedInStrictMode()); + }; + + GenericTypeSyntax.create1 = function (name) { + return new GenericTypeSyntax(name, TypeArgumentListSyntax.create1(), false); + }; + + GenericTypeSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + GenericTypeSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + GenericTypeSyntax.prototype.withName = function (name) { + return this.update(name, this.typeArgumentList); + }; + + GenericTypeSyntax.prototype.withTypeArgumentList = function (typeArgumentList) { + return this.update(this.name, typeArgumentList); + }; + + GenericTypeSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return GenericTypeSyntax; + })(TypeScript.SyntaxNode); + TypeScript.GenericTypeSyntax = GenericTypeSyntax; + + var TypeQuerySyntax = (function (_super) { + __extends(TypeQuerySyntax, _super); + function TypeQuerySyntax(typeOfKeyword, name, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeOfKeyword = typeOfKeyword; + this.name = name; + } + TypeQuerySyntax.prototype.accept = function (visitor) { + return visitor.visitTypeQuery(this); + }; + + TypeQuerySyntax.prototype.kind = function () { + return 127 /* TypeQuery */; + }; + + TypeQuerySyntax.prototype.childCount = function () { + return 2; + }; + + TypeQuerySyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeOfKeyword; + case 1: + return this.name; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeQuerySyntax.prototype.isType = function () { + return true; + }; + + TypeQuerySyntax.prototype.update = function (typeOfKeyword, name) { + if (this.typeOfKeyword === typeOfKeyword && this.name === name) { + return this; + } + + return new TypeQuerySyntax(typeOfKeyword, name, this.parsedInStrictMode()); + }; + + TypeQuerySyntax.create1 = function (name) { + return new TypeQuerySyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), name, false); + }; + + TypeQuerySyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeQuerySyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeQuerySyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) { + return this.update(typeOfKeyword, this.name); + }; + + TypeQuerySyntax.prototype.withName = function (name) { + return this.update(this.typeOfKeyword, name); + }; + + TypeQuerySyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeQuerySyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeQuerySyntax = TypeQuerySyntax; + + var TypeAnnotationSyntax = (function (_super) { + __extends(TypeAnnotationSyntax, _super); + function TypeAnnotationSyntax(colonToken, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.colonToken = colonToken; + this.type = type; + } + TypeAnnotationSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeAnnotation(this); + }; + + TypeAnnotationSyntax.prototype.kind = function () { + return 244 /* TypeAnnotation */; + }; + + TypeAnnotationSyntax.prototype.childCount = function () { + return 2; + }; + + TypeAnnotationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.colonToken; + case 1: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeAnnotationSyntax.prototype.update = function (colonToken, type) { + if (this.colonToken === colonToken && this.type === type) { + return this; + } + + return new TypeAnnotationSyntax(colonToken, type, this.parsedInStrictMode()); + }; + + TypeAnnotationSyntax.create1 = function (type) { + return new TypeAnnotationSyntax(TypeScript.Syntax.token(106 /* ColonToken */), type, false); + }; + + TypeAnnotationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeAnnotationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeAnnotationSyntax.prototype.withColonToken = function (colonToken) { + return this.update(colonToken, this.type); + }; + + TypeAnnotationSyntax.prototype.withType = function (type) { + return this.update(this.colonToken, type); + }; + + TypeAnnotationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeAnnotationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeAnnotationSyntax = TypeAnnotationSyntax; + + var BlockSyntax = (function (_super) { + __extends(BlockSyntax, _super); + function BlockSyntax(openBraceToken, statements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.statements = statements; + this.closeBraceToken = closeBraceToken; + } + BlockSyntax.prototype.accept = function (visitor) { + return visitor.visitBlock(this); + }; + + BlockSyntax.prototype.kind = function () { + return 146 /* Block */; + }; + + BlockSyntax.prototype.childCount = function () { + return 3; + }; + + BlockSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.statements; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BlockSyntax.prototype.isStatement = function () { + return true; + }; + + BlockSyntax.prototype.isModuleElement = function () { + return true; + }; + + BlockSyntax.prototype.update = function (openBraceToken, statements, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.statements === statements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new BlockSyntax(openBraceToken, statements, closeBraceToken, this.parsedInStrictMode()); + }; + + BlockSyntax.create = function (openBraceToken, closeBraceToken) { + return new BlockSyntax(openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + BlockSyntax.create1 = function () { + return new BlockSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + BlockSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BlockSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BlockSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.statements, this.closeBraceToken); + }; + + BlockSyntax.prototype.withStatements = function (statements) { + return this.update(this.openBraceToken, statements, this.closeBraceToken); + }; + + BlockSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + BlockSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.statements, closeBraceToken); + }; + + BlockSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return BlockSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BlockSyntax = BlockSyntax; + + var ParameterSyntax = (function (_super) { + __extends(ParameterSyntax, _super); + function ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.dotDotDotToken = dotDotDotToken; + this.modifiers = modifiers; + this.identifier = identifier; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + } + ParameterSyntax.prototype.accept = function (visitor) { + return visitor.visitParameter(this); + }; + + ParameterSyntax.prototype.kind = function () { + return 242 /* Parameter */; + }; + + ParameterSyntax.prototype.childCount = function () { + return 6; + }; + + ParameterSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.dotDotDotToken; + case 1: + return this.modifiers; + case 2: + return this.identifier; + case 3: + return this.questionToken; + case 4: + return this.typeAnnotation; + case 5: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParameterSyntax.prototype.update = function (dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + if (this.dotDotDotToken === dotDotDotToken && this.modifiers === modifiers && this.identifier === identifier && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new ParameterSyntax(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause, this.parsedInStrictMode()); + }; + + ParameterSyntax.create = function (identifier) { + return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false); + }; + + ParameterSyntax.create1 = function (identifier) { + return new ParameterSyntax(null, TypeScript.Syntax.emptyList, identifier, null, null, null, false); + }; + + ParameterSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParameterSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParameterSyntax.prototype.withDotDotDotToken = function (dotDotDotToken) { + return this.update(dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withModifiers = function (modifiers) { + return this.update(this.dotDotDotToken, modifiers, this.identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ParameterSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.dotDotDotToken, this.modifiers, identifier, this.questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, questionToken, this.typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, typeAnnotation, this.equalsValueClause); + }; + + ParameterSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.dotDotDotToken, this.modifiers, this.identifier, this.questionToken, this.typeAnnotation, equalsValueClause); + }; + + ParameterSyntax.prototype.isTypeScriptSpecific = function () { + if (this.dotDotDotToken !== null) { + return true; + } + if (this.modifiers.isTypeScriptSpecific()) { + return true; + } + if (this.questionToken !== null) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + if (this.equalsValueClause !== null) { + return true; + } + return false; + }; + return ParameterSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParameterSyntax = ParameterSyntax; + + var MemberAccessExpressionSyntax = (function (_super) { + __extends(MemberAccessExpressionSyntax, _super); + function MemberAccessExpressionSyntax(expression, dotToken, name, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.dotToken = dotToken; + this.name = name; + } + MemberAccessExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberAccessExpression(this); + }; + + MemberAccessExpressionSyntax.prototype.kind = function () { + return 212 /* MemberAccessExpression */; + }; + + MemberAccessExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + MemberAccessExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.dotToken; + case 2: + return this.name; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberAccessExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + MemberAccessExpressionSyntax.prototype.update = function (expression, dotToken, name) { + if (this.expression === expression && this.dotToken === dotToken && this.name === name) { + return this; + } + + return new MemberAccessExpressionSyntax(expression, dotToken, name, this.parsedInStrictMode()); + }; + + MemberAccessExpressionSyntax.create1 = function (expression, name) { + return new MemberAccessExpressionSyntax(expression, TypeScript.Syntax.token(76 /* DotToken */), name, false); + }; + + MemberAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberAccessExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.dotToken, this.name); + }; + + MemberAccessExpressionSyntax.prototype.withDotToken = function (dotToken) { + return this.update(this.expression, dotToken, this.name); + }; + + MemberAccessExpressionSyntax.prototype.withName = function (name) { + return this.update(this.expression, this.dotToken, name); + }; + + MemberAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return MemberAccessExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberAccessExpressionSyntax = MemberAccessExpressionSyntax; + + var PostfixUnaryExpressionSyntax = (function (_super) { + __extends(PostfixUnaryExpressionSyntax, _super); + function PostfixUnaryExpressionSyntax(kind, operand, operatorToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.operand = operand; + this.operatorToken = operatorToken; + + this._kind = kind; + } + PostfixUnaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitPostfixUnaryExpression(this); + }; + + PostfixUnaryExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + PostfixUnaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.operand; + case 1: + return this.operatorToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PostfixUnaryExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + PostfixUnaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + PostfixUnaryExpressionSyntax.prototype.update = function (kind, operand, operatorToken) { + if (this._kind === kind && this.operand === operand && this.operatorToken === operatorToken) { + return this; + } + + return new PostfixUnaryExpressionSyntax(kind, operand, operatorToken, this.parsedInStrictMode()); + }; + + PostfixUnaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PostfixUnaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PostfixUnaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.operand, this.operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.withOperand = function (operand) { + return this.update(this._kind, operand, this.operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, this.operand, operatorToken); + }; + + PostfixUnaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.operand.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return PostfixUnaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PostfixUnaryExpressionSyntax = PostfixUnaryExpressionSyntax; + + var ElementAccessExpressionSyntax = (function (_super) { + __extends(ElementAccessExpressionSyntax, _super); + function ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.openBracketToken = openBracketToken; + this.argumentExpression = argumentExpression; + this.closeBracketToken = closeBracketToken; + } + ElementAccessExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitElementAccessExpression(this); + }; + + ElementAccessExpressionSyntax.prototype.kind = function () { + return 221 /* ElementAccessExpression */; + }; + + ElementAccessExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + ElementAccessExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.openBracketToken; + case 2: + return this.argumentExpression; + case 3: + return this.closeBracketToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ElementAccessExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ElementAccessExpressionSyntax.prototype.update = function (expression, openBracketToken, argumentExpression, closeBracketToken) { + if (this.expression === expression && this.openBracketToken === openBracketToken && this.argumentExpression === argumentExpression && this.closeBracketToken === closeBracketToken) { + return this; + } + + return new ElementAccessExpressionSyntax(expression, openBracketToken, argumentExpression, closeBracketToken, this.parsedInStrictMode()); + }; + + ElementAccessExpressionSyntax.create1 = function (expression, argumentExpression) { + return new ElementAccessExpressionSyntax(expression, TypeScript.Syntax.token(74 /* OpenBracketToken */), argumentExpression, TypeScript.Syntax.token(75 /* CloseBracketToken */), false); + }; + + ElementAccessExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ElementAccessExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ElementAccessExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.openBracketToken, this.argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(this.expression, openBracketToken, this.argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withArgumentExpression = function (argumentExpression) { + return this.update(this.expression, this.openBracketToken, argumentExpression, this.closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.expression, this.openBracketToken, this.argumentExpression, closeBracketToken); + }; + + ElementAccessExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentExpression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ElementAccessExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ElementAccessExpressionSyntax = ElementAccessExpressionSyntax; + + var InvocationExpressionSyntax = (function (_super) { + __extends(InvocationExpressionSyntax, _super); + function InvocationExpressionSyntax(expression, argumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.argumentList = argumentList; + } + InvocationExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitInvocationExpression(this); + }; + + InvocationExpressionSyntax.prototype.kind = function () { + return 213 /* InvocationExpression */; + }; + + InvocationExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + InvocationExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.argumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + InvocationExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + InvocationExpressionSyntax.prototype.update = function (expression, argumentList) { + if (this.expression === expression && this.argumentList === argumentList) { + return this; + } + + return new InvocationExpressionSyntax(expression, argumentList, this.parsedInStrictMode()); + }; + + InvocationExpressionSyntax.create1 = function (expression) { + return new InvocationExpressionSyntax(expression, ArgumentListSyntax.create1(), false); + }; + + InvocationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + InvocationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + InvocationExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.argumentList); + }; + + InvocationExpressionSyntax.prototype.withArgumentList = function (argumentList) { + return this.update(this.expression, argumentList); + }; + + InvocationExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentList.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return InvocationExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.InvocationExpressionSyntax = InvocationExpressionSyntax; + + var ArgumentListSyntax = (function (_super) { + __extends(ArgumentListSyntax, _super); + function ArgumentListSyntax(typeArgumentList, openParenToken, arguments, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeArgumentList = typeArgumentList; + this.openParenToken = openParenToken; + this.arguments = arguments; + this.closeParenToken = closeParenToken; + } + ArgumentListSyntax.prototype.accept = function (visitor) { + return visitor.visitArgumentList(this); + }; + + ArgumentListSyntax.prototype.kind = function () { + return 226 /* ArgumentList */; + }; + + ArgumentListSyntax.prototype.childCount = function () { + return 4; + }; + + ArgumentListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeArgumentList; + case 1: + return this.openParenToken; + case 2: + return this.arguments; + case 3: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ArgumentListSyntax.prototype.update = function (typeArgumentList, openParenToken, _arguments, closeParenToken) { + if (this.typeArgumentList === typeArgumentList && this.openParenToken === openParenToken && this.arguments === _arguments && this.closeParenToken === closeParenToken) { + return this; + } + + return new ArgumentListSyntax(typeArgumentList, openParenToken, _arguments, closeParenToken, this.parsedInStrictMode()); + }; + + ArgumentListSyntax.create = function (openParenToken, closeParenToken) { + return new ArgumentListSyntax(null, openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false); + }; + + ArgumentListSyntax.create1 = function () { + return new ArgumentListSyntax(null, TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ArgumentListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ArgumentListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ArgumentListSyntax.prototype.withTypeArgumentList = function (typeArgumentList) { + return this.update(typeArgumentList, this.openParenToken, this.arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.typeArgumentList, openParenToken, this.arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withArguments = function (_arguments) { + return this.update(this.typeArgumentList, this.openParenToken, _arguments, this.closeParenToken); + }; + + ArgumentListSyntax.prototype.withArgument = function (_argument) { + return this.withArguments(TypeScript.Syntax.separatedList([_argument])); + }; + + ArgumentListSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.typeArgumentList, this.openParenToken, this.arguments, closeParenToken); + }; + + ArgumentListSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeArgumentList !== null && this.typeArgumentList.isTypeScriptSpecific()) { + return true; + } + if (this.arguments.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ArgumentListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ArgumentListSyntax = ArgumentListSyntax; + + var BinaryExpressionSyntax = (function (_super) { + __extends(BinaryExpressionSyntax, _super); + function BinaryExpressionSyntax(kind, left, operatorToken, right, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.left = left; + this.operatorToken = operatorToken; + this.right = right; + + this._kind = kind; + } + BinaryExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitBinaryExpression(this); + }; + + BinaryExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + BinaryExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.left; + case 1: + return this.operatorToken; + case 2: + return this.right; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BinaryExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + BinaryExpressionSyntax.prototype.kind = function () { + return this._kind; + }; + + BinaryExpressionSyntax.prototype.update = function (kind, left, operatorToken, right) { + if (this._kind === kind && this.left === left && this.operatorToken === operatorToken && this.right === right) { + return this; + } + + return new BinaryExpressionSyntax(kind, left, operatorToken, right, this.parsedInStrictMode()); + }; + + BinaryExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BinaryExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BinaryExpressionSyntax.prototype.withKind = function (kind) { + return this.update(kind, this.left, this.operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withLeft = function (left) { + return this.update(this._kind, left, this.operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withOperatorToken = function (operatorToken) { + return this.update(this._kind, this.left, operatorToken, this.right); + }; + + BinaryExpressionSyntax.prototype.withRight = function (right) { + return this.update(this._kind, this.left, this.operatorToken, right); + }; + + BinaryExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.left.isTypeScriptSpecific()) { + return true; + } + if (this.right.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return BinaryExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BinaryExpressionSyntax = BinaryExpressionSyntax; + + var ConditionalExpressionSyntax = (function (_super) { + __extends(ConditionalExpressionSyntax, _super); + function ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.condition = condition; + this.questionToken = questionToken; + this.whenTrue = whenTrue; + this.colonToken = colonToken; + this.whenFalse = whenFalse; + } + ConditionalExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitConditionalExpression(this); + }; + + ConditionalExpressionSyntax.prototype.kind = function () { + return 186 /* ConditionalExpression */; + }; + + ConditionalExpressionSyntax.prototype.childCount = function () { + return 5; + }; + + ConditionalExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.condition; + case 1: + return this.questionToken; + case 2: + return this.whenTrue; + case 3: + return this.colonToken; + case 4: + return this.whenFalse; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConditionalExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ConditionalExpressionSyntax.prototype.update = function (condition, questionToken, whenTrue, colonToken, whenFalse) { + if (this.condition === condition && this.questionToken === questionToken && this.whenTrue === whenTrue && this.colonToken === colonToken && this.whenFalse === whenFalse) { + return this; + } + + return new ConditionalExpressionSyntax(condition, questionToken, whenTrue, colonToken, whenFalse, this.parsedInStrictMode()); + }; + + ConditionalExpressionSyntax.create1 = function (condition, whenTrue, whenFalse) { + return new ConditionalExpressionSyntax(condition, TypeScript.Syntax.token(105 /* QuestionToken */), whenTrue, TypeScript.Syntax.token(106 /* ColonToken */), whenFalse, false); + }; + + ConditionalExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConditionalExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConditionalExpressionSyntax.prototype.withCondition = function (condition) { + return this.update(condition, this.questionToken, this.whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.condition, questionToken, this.whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withWhenTrue = function (whenTrue) { + return this.update(this.condition, this.questionToken, whenTrue, this.colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.condition, this.questionToken, this.whenTrue, colonToken, this.whenFalse); + }; + + ConditionalExpressionSyntax.prototype.withWhenFalse = function (whenFalse) { + return this.update(this.condition, this.questionToken, this.whenTrue, this.colonToken, whenFalse); + }; + + ConditionalExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.whenTrue.isTypeScriptSpecific()) { + return true; + } + if (this.whenFalse.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ConditionalExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConditionalExpressionSyntax = ConditionalExpressionSyntax; + + var ConstructSignatureSyntax = (function (_super) { + __extends(ConstructSignatureSyntax, _super); + function ConstructSignatureSyntax(newKeyword, callSignature, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.callSignature = callSignature; + } + ConstructSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructSignature(this); + }; + + ConstructSignatureSyntax.prototype.kind = function () { + return 143 /* ConstructSignature */; + }; + + ConstructSignatureSyntax.prototype.childCount = function () { + return 2; + }; + + ConstructSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.callSignature; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + ConstructSignatureSyntax.prototype.update = function (newKeyword, callSignature) { + if (this.newKeyword === newKeyword && this.callSignature === callSignature) { + return this; + } + + return new ConstructSignatureSyntax(newKeyword, callSignature, this.parsedInStrictMode()); + }; + + ConstructSignatureSyntax.create1 = function () { + return new ConstructSignatureSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), CallSignatureSyntax.create1(), false); + }; + + ConstructSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructSignatureSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.callSignature); + }; + + ConstructSignatureSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.newKeyword, callSignature); + }; + + ConstructSignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructSignatureSyntax = ConstructSignatureSyntax; + + var MethodSignatureSyntax = (function (_super) { + __extends(MethodSignatureSyntax, _super); + function MethodSignatureSyntax(propertyName, questionToken, callSignature, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.callSignature = callSignature; + } + MethodSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitMethodSignature(this); + }; + + MethodSignatureSyntax.prototype.kind = function () { + return 145 /* MethodSignature */; + }; + + MethodSignatureSyntax.prototype.childCount = function () { + return 3; + }; + + MethodSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.questionToken; + case 2: + return this.callSignature; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MethodSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + MethodSignatureSyntax.prototype.update = function (propertyName, questionToken, callSignature) { + if (this.propertyName === propertyName && this.questionToken === questionToken && this.callSignature === callSignature) { + return this; + } + + return new MethodSignatureSyntax(propertyName, questionToken, callSignature, this.parsedInStrictMode()); + }; + + MethodSignatureSyntax.create = function (propertyName, callSignature) { + return new MethodSignatureSyntax(propertyName, null, callSignature, false); + }; + + MethodSignatureSyntax.create1 = function (propertyName) { + return new MethodSignatureSyntax(propertyName, null, CallSignatureSyntax.create1(), false); + }; + + MethodSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MethodSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MethodSignatureSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.questionToken, this.callSignature); + }; + + MethodSignatureSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.propertyName, questionToken, this.callSignature); + }; + + MethodSignatureSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.propertyName, this.questionToken, callSignature); + }; + + MethodSignatureSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return MethodSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MethodSignatureSyntax = MethodSignatureSyntax; + + var IndexSignatureSyntax = (function (_super) { + __extends(IndexSignatureSyntax, _super); + function IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBracketToken = openBracketToken; + this.parameter = parameter; + this.closeBracketToken = closeBracketToken; + this.typeAnnotation = typeAnnotation; + } + IndexSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitIndexSignature(this); + }; + + IndexSignatureSyntax.prototype.kind = function () { + return 144 /* IndexSignature */; + }; + + IndexSignatureSyntax.prototype.childCount = function () { + return 4; + }; + + IndexSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBracketToken; + case 1: + return this.parameter; + case 2: + return this.closeBracketToken; + case 3: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IndexSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + IndexSignatureSyntax.prototype.update = function (openBracketToken, parameter, closeBracketToken, typeAnnotation) { + if (this.openBracketToken === openBracketToken && this.parameter === parameter && this.closeBracketToken === closeBracketToken && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, typeAnnotation, this.parsedInStrictMode()); + }; + + IndexSignatureSyntax.create = function (openBracketToken, parameter, closeBracketToken) { + return new IndexSignatureSyntax(openBracketToken, parameter, closeBracketToken, null, false); + }; + + IndexSignatureSyntax.create1 = function (parameter) { + return new IndexSignatureSyntax(TypeScript.Syntax.token(74 /* OpenBracketToken */), parameter, TypeScript.Syntax.token(75 /* CloseBracketToken */), null, false); + }; + + IndexSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IndexSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IndexSignatureSyntax.prototype.withOpenBracketToken = function (openBracketToken) { + return this.update(openBracketToken, this.parameter, this.closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withParameter = function (parameter) { + return this.update(this.openBracketToken, parameter, this.closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withCloseBracketToken = function (closeBracketToken) { + return this.update(this.openBracketToken, this.parameter, closeBracketToken, this.typeAnnotation); + }; + + IndexSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.openBracketToken, this.parameter, this.closeBracketToken, typeAnnotation); + }; + + IndexSignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return IndexSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IndexSignatureSyntax = IndexSignatureSyntax; + + var PropertySignatureSyntax = (function (_super) { + __extends(PropertySignatureSyntax, _super); + function PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + } + PropertySignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitPropertySignature(this); + }; + + PropertySignatureSyntax.prototype.kind = function () { + return 141 /* PropertySignature */; + }; + + PropertySignatureSyntax.prototype.childCount = function () { + return 3; + }; + + PropertySignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.questionToken; + case 2: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + PropertySignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + PropertySignatureSyntax.prototype.update = function (propertyName, questionToken, typeAnnotation) { + if (this.propertyName === propertyName && this.questionToken === questionToken && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new PropertySignatureSyntax(propertyName, questionToken, typeAnnotation, this.parsedInStrictMode()); + }; + + PropertySignatureSyntax.create = function (propertyName) { + return new PropertySignatureSyntax(propertyName, null, null, false); + }; + + PropertySignatureSyntax.create1 = function (propertyName) { + return new PropertySignatureSyntax(propertyName, null, null, false); + }; + + PropertySignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + PropertySignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + PropertySignatureSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.questionToken, this.typeAnnotation); + }; + + PropertySignatureSyntax.prototype.withQuestionToken = function (questionToken) { + return this.update(this.propertyName, questionToken, this.typeAnnotation); + }; + + PropertySignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.propertyName, this.questionToken, typeAnnotation); + }; + + PropertySignatureSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return PropertySignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.PropertySignatureSyntax = PropertySignatureSyntax; + + var CallSignatureSyntax = (function (_super) { + __extends(CallSignatureSyntax, _super); + function CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + } + CallSignatureSyntax.prototype.accept = function (visitor) { + return visitor.visitCallSignature(this); + }; + + CallSignatureSyntax.prototype.kind = function () { + return 142 /* CallSignature */; + }; + + CallSignatureSyntax.prototype.childCount = function () { + return 3; + }; + + CallSignatureSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeParameterList; + case 1: + return this.parameterList; + case 2: + return this.typeAnnotation; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CallSignatureSyntax.prototype.isTypeMember = function () { + return true; + }; + + CallSignatureSyntax.prototype.update = function (typeParameterList, parameterList, typeAnnotation) { + if (this.typeParameterList === typeParameterList && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation) { + return this; + } + + return new CallSignatureSyntax(typeParameterList, parameterList, typeAnnotation, this.parsedInStrictMode()); + }; + + CallSignatureSyntax.create = function (parameterList) { + return new CallSignatureSyntax(null, parameterList, null, false); + }; + + CallSignatureSyntax.create1 = function () { + return new CallSignatureSyntax(null, ParameterListSyntax.create1(), null, false); + }; + + CallSignatureSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CallSignatureSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CallSignatureSyntax.prototype.withTypeParameterList = function (typeParameterList) { + return this.update(typeParameterList, this.parameterList, this.typeAnnotation); + }; + + CallSignatureSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.typeParameterList, parameterList, this.typeAnnotation); + }; + + CallSignatureSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.typeParameterList, this.parameterList, typeAnnotation); + }; + + CallSignatureSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeParameterList !== null) { + return true; + } + if (this.parameterList.isTypeScriptSpecific()) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + return false; + }; + return CallSignatureSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CallSignatureSyntax = CallSignatureSyntax; + + var ParameterListSyntax = (function (_super) { + __extends(ParameterListSyntax, _super); + function ParameterListSyntax(openParenToken, parameters, closeParenToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openParenToken = openParenToken; + this.parameters = parameters; + this.closeParenToken = closeParenToken; + } + ParameterListSyntax.prototype.accept = function (visitor) { + return visitor.visitParameterList(this); + }; + + ParameterListSyntax.prototype.kind = function () { + return 227 /* ParameterList */; + }; + + ParameterListSyntax.prototype.childCount = function () { + return 3; + }; + + ParameterListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openParenToken; + case 1: + return this.parameters; + case 2: + return this.closeParenToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParameterListSyntax.prototype.update = function (openParenToken, parameters, closeParenToken) { + if (this.openParenToken === openParenToken && this.parameters === parameters && this.closeParenToken === closeParenToken) { + return this; + } + + return new ParameterListSyntax(openParenToken, parameters, closeParenToken, this.parsedInStrictMode()); + }; + + ParameterListSyntax.create = function (openParenToken, closeParenToken) { + return new ParameterListSyntax(openParenToken, TypeScript.Syntax.emptySeparatedList, closeParenToken, false); + }; + + ParameterListSyntax.create1 = function () { + return new ParameterListSyntax(TypeScript.Syntax.token(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(73 /* CloseParenToken */), false); + }; + + ParameterListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ParameterListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ParameterListSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(openParenToken, this.parameters, this.closeParenToken); + }; + + ParameterListSyntax.prototype.withParameters = function (parameters) { + return this.update(this.openParenToken, parameters, this.closeParenToken); + }; + + ParameterListSyntax.prototype.withParameter = function (parameter) { + return this.withParameters(TypeScript.Syntax.separatedList([parameter])); + }; + + ParameterListSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.openParenToken, this.parameters, closeParenToken); + }; + + ParameterListSyntax.prototype.isTypeScriptSpecific = function () { + if (this.parameters.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ParameterListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ParameterListSyntax = ParameterListSyntax; + + var TypeParameterListSyntax = (function (_super) { + __extends(TypeParameterListSyntax, _super); + function TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.typeParameters = typeParameters; + this.greaterThanToken = greaterThanToken; + } + TypeParameterListSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeParameterList(this); + }; + + TypeParameterListSyntax.prototype.kind = function () { + return 229 /* TypeParameterList */; + }; + + TypeParameterListSyntax.prototype.childCount = function () { + return 3; + }; + + TypeParameterListSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.typeParameters; + case 2: + return this.greaterThanToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeParameterListSyntax.prototype.update = function (lessThanToken, typeParameters, greaterThanToken) { + if (this.lessThanToken === lessThanToken && this.typeParameters === typeParameters && this.greaterThanToken === greaterThanToken) { + return this; + } + + return new TypeParameterListSyntax(lessThanToken, typeParameters, greaterThanToken, this.parsedInStrictMode()); + }; + + TypeParameterListSyntax.create = function (lessThanToken, greaterThanToken) { + return new TypeParameterListSyntax(lessThanToken, TypeScript.Syntax.emptySeparatedList, greaterThanToken, false); + }; + + TypeParameterListSyntax.create1 = function () { + return new TypeParameterListSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(81 /* GreaterThanToken */), false); + }; + + TypeParameterListSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeParameterListSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeParameterListSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.typeParameters, this.greaterThanToken); + }; + + TypeParameterListSyntax.prototype.withTypeParameters = function (typeParameters) { + return this.update(this.lessThanToken, typeParameters, this.greaterThanToken); + }; + + TypeParameterListSyntax.prototype.withTypeParameter = function (typeParameter) { + return this.withTypeParameters(TypeScript.Syntax.separatedList([typeParameter])); + }; + + TypeParameterListSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.typeParameters, greaterThanToken); + }; + + TypeParameterListSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeParameterListSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeParameterListSyntax = TypeParameterListSyntax; + + var TypeParameterSyntax = (function (_super) { + __extends(TypeParameterSyntax, _super); + function TypeParameterSyntax(identifier, constraint, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.constraint = constraint; + } + TypeParameterSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeParameter(this); + }; + + TypeParameterSyntax.prototype.kind = function () { + return 238 /* TypeParameter */; + }; + + TypeParameterSyntax.prototype.childCount = function () { + return 2; + }; + + TypeParameterSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.constraint; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeParameterSyntax.prototype.update = function (identifier, constraint) { + if (this.identifier === identifier && this.constraint === constraint) { + return this; + } + + return new TypeParameterSyntax(identifier, constraint, this.parsedInStrictMode()); + }; + + TypeParameterSyntax.create = function (identifier) { + return new TypeParameterSyntax(identifier, null, false); + }; + + TypeParameterSyntax.create1 = function (identifier) { + return new TypeParameterSyntax(identifier, null, false); + }; + + TypeParameterSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeParameterSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeParameterSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.constraint); + }; + + TypeParameterSyntax.prototype.withConstraint = function (constraint) { + return this.update(this.identifier, constraint); + }; + + TypeParameterSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return TypeParameterSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeParameterSyntax = TypeParameterSyntax; + + var ConstraintSyntax = (function (_super) { + __extends(ConstraintSyntax, _super); + function ConstraintSyntax(extendsKeyword, type, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.extendsKeyword = extendsKeyword; + this.type = type; + } + ConstraintSyntax.prototype.accept = function (visitor) { + return visitor.visitConstraint(this); + }; + + ConstraintSyntax.prototype.kind = function () { + return 239 /* Constraint */; + }; + + ConstraintSyntax.prototype.childCount = function () { + return 2; + }; + + ConstraintSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.extendsKeyword; + case 1: + return this.type; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstraintSyntax.prototype.update = function (extendsKeyword, type) { + if (this.extendsKeyword === extendsKeyword && this.type === type) { + return this; + } + + return new ConstraintSyntax(extendsKeyword, type, this.parsedInStrictMode()); + }; + + ConstraintSyntax.create1 = function (type) { + return new ConstraintSyntax(TypeScript.Syntax.token(48 /* ExtendsKeyword */), type, false); + }; + + ConstraintSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstraintSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstraintSyntax.prototype.withExtendsKeyword = function (extendsKeyword) { + return this.update(extendsKeyword, this.type); + }; + + ConstraintSyntax.prototype.withType = function (type) { + return this.update(this.extendsKeyword, type); + }; + + ConstraintSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstraintSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstraintSyntax = ConstraintSyntax; + + var ElseClauseSyntax = (function (_super) { + __extends(ElseClauseSyntax, _super); + function ElseClauseSyntax(elseKeyword, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.elseKeyword = elseKeyword; + this.statement = statement; + } + ElseClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitElseClause(this); + }; + + ElseClauseSyntax.prototype.kind = function () { + return 235 /* ElseClause */; + }; + + ElseClauseSyntax.prototype.childCount = function () { + return 2; + }; + + ElseClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.elseKeyword; + case 1: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ElseClauseSyntax.prototype.update = function (elseKeyword, statement) { + if (this.elseKeyword === elseKeyword && this.statement === statement) { + return this; + } + + return new ElseClauseSyntax(elseKeyword, statement, this.parsedInStrictMode()); + }; + + ElseClauseSyntax.create1 = function (statement) { + return new ElseClauseSyntax(TypeScript.Syntax.token(23 /* ElseKeyword */), statement, false); + }; + + ElseClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ElseClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ElseClauseSyntax.prototype.withElseKeyword = function (elseKeyword) { + return this.update(elseKeyword, this.statement); + }; + + ElseClauseSyntax.prototype.withStatement = function (statement) { + return this.update(this.elseKeyword, statement); + }; + + ElseClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ElseClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ElseClauseSyntax = ElseClauseSyntax; + + var IfStatementSyntax = (function (_super) { + __extends(IfStatementSyntax, _super); + function IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.ifKeyword = ifKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + this.elseClause = elseClause; + } + IfStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitIfStatement(this); + }; + + IfStatementSyntax.prototype.kind = function () { + return 147 /* IfStatement */; + }; + + IfStatementSyntax.prototype.childCount = function () { + return 6; + }; + + IfStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.ifKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + case 5: + return this.elseClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IfStatementSyntax.prototype.isStatement = function () { + return true; + }; + + IfStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + IfStatementSyntax.prototype.update = function (ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause) { + if (this.ifKeyword === ifKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement && this.elseClause === elseClause) { + return this; + } + + return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause, this.parsedInStrictMode()); + }; + + IfStatementSyntax.create = function (ifKeyword, openParenToken, condition, closeParenToken, statement) { + return new IfStatementSyntax(ifKeyword, openParenToken, condition, closeParenToken, statement, null, false); + }; + + IfStatementSyntax.create1 = function (condition, statement) { + return new IfStatementSyntax(TypeScript.Syntax.token(28 /* IfKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, null, false); + }; + + IfStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IfStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IfStatementSyntax.prototype.withIfKeyword = function (ifKeyword) { + return this.update(ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.ifKeyword, openParenToken, this.condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.ifKeyword, this.openParenToken, condition, this.closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, closeParenToken, this.statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, statement, this.elseClause); + }; + + IfStatementSyntax.prototype.withElseClause = function (elseClause) { + return this.update(this.ifKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement, elseClause); + }; + + IfStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + if (this.elseClause !== null && this.elseClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return IfStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IfStatementSyntax = IfStatementSyntax; + + var ExpressionStatementSyntax = (function (_super) { + __extends(ExpressionStatementSyntax, _super); + function ExpressionStatementSyntax(expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ExpressionStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitExpressionStatement(this); + }; + + ExpressionStatementSyntax.prototype.kind = function () { + return 149 /* ExpressionStatement */; + }; + + ExpressionStatementSyntax.prototype.childCount = function () { + return 2; + }; + + ExpressionStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.expression; + case 1: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ExpressionStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ExpressionStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ExpressionStatementSyntax.prototype.update = function (expression, semicolonToken) { + if (this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ExpressionStatementSyntax(expression, semicolonToken, this.parsedInStrictMode()); + }; + + ExpressionStatementSyntax.create1 = function (expression) { + return new ExpressionStatementSyntax(expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ExpressionStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ExpressionStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ExpressionStatementSyntax.prototype.withExpression = function (expression) { + return this.update(expression, this.semicolonToken); + }; + + ExpressionStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.expression, semicolonToken); + }; + + ExpressionStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ExpressionStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ExpressionStatementSyntax = ExpressionStatementSyntax; + + var ConstructorDeclarationSyntax = (function (_super) { + __extends(ConstructorDeclarationSyntax, _super); + function ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.constructorKeyword = constructorKeyword; + this.parameterList = parameterList; + this.block = block; + this.semicolonToken = semicolonToken; + } + ConstructorDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitConstructorDeclaration(this); + }; + + ConstructorDeclarationSyntax.prototype.kind = function () { + return 137 /* ConstructorDeclaration */; + }; + + ConstructorDeclarationSyntax.prototype.childCount = function () { + return 5; + }; + + ConstructorDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.constructorKeyword; + case 2: + return this.parameterList; + case 3: + return this.block; + case 4: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ConstructorDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + ConstructorDeclarationSyntax.prototype.update = function (modifiers, constructorKeyword, parameterList, block, semicolonToken) { + if (this.modifiers === modifiers && this.constructorKeyword === constructorKeyword && this.parameterList === parameterList && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new ConstructorDeclarationSyntax(modifiers, constructorKeyword, parameterList, block, semicolonToken, this.parsedInStrictMode()); + }; + + ConstructorDeclarationSyntax.create = function (constructorKeyword, parameterList) { + return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, constructorKeyword, parameterList, null, null, false); + }; + + ConstructorDeclarationSyntax.create1 = function () { + return new ConstructorDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(62 /* ConstructorKeyword */), ParameterListSyntax.create1(), null, null, false); + }; + + ConstructorDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ConstructorDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ConstructorDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.constructorKeyword, this.parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + ConstructorDeclarationSyntax.prototype.withConstructorKeyword = function (constructorKeyword) { + return this.update(this.modifiers, constructorKeyword, this.parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.constructorKeyword, parameterList, this.block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.constructorKeyword, this.parameterList, block, this.semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.constructorKeyword, this.parameterList, this.block, semicolonToken); + }; + + ConstructorDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return ConstructorDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ConstructorDeclarationSyntax = ConstructorDeclarationSyntax; + + var MemberFunctionDeclarationSyntax = (function (_super) { + __extends(MemberFunctionDeclarationSyntax, _super); + function MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + this.semicolonToken = semicolonToken; + } + MemberFunctionDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberFunctionDeclaration(this); + }; + + MemberFunctionDeclarationSyntax.prototype.kind = function () { + return 135 /* MemberFunctionDeclaration */; + }; + + MemberFunctionDeclarationSyntax.prototype.childCount = function () { + return 5; + }; + + MemberFunctionDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.propertyName; + case 2: + return this.callSignature; + case 3: + return this.block; + case 4: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberFunctionDeclarationSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + MemberFunctionDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + MemberFunctionDeclarationSyntax.prototype.update = function (modifiers, propertyName, callSignature, block, semicolonToken) { + if (this.modifiers === modifiers && this.propertyName === propertyName && this.callSignature === callSignature && this.block === block && this.semicolonToken === semicolonToken) { + return this; + } + + return new MemberFunctionDeclarationSyntax(modifiers, propertyName, callSignature, block, semicolonToken, this.parsedInStrictMode()); + }; + + MemberFunctionDeclarationSyntax.create = function (propertyName, callSignature) { + return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, callSignature, null, null, false); + }; + + MemberFunctionDeclarationSyntax.create1 = function (propertyName) { + return new MemberFunctionDeclarationSyntax(TypeScript.Syntax.emptyList, propertyName, CallSignatureSyntax.create1(), null, null, false); + }; + + MemberFunctionDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberFunctionDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberFunctionDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.propertyName, this.callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + MemberFunctionDeclarationSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, propertyName, this.callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.modifiers, this.propertyName, callSignature, this.block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.propertyName, this.callSignature, block, this.semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.propertyName, this.callSignature, this.block, semicolonToken); + }; + + MemberFunctionDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return MemberFunctionDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberFunctionDeclarationSyntax = MemberFunctionDeclarationSyntax; + + var GetAccessorSyntax = (function (_super) { + __extends(GetAccessorSyntax, _super); + function GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.getKeyword = getKeyword; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + this.block = block; + } + GetAccessorSyntax.prototype.accept = function (visitor) { + return visitor.visitGetAccessor(this); + }; + + GetAccessorSyntax.prototype.kind = function () { + return 139 /* GetAccessor */; + }; + + GetAccessorSyntax.prototype.childCount = function () { + return 6; + }; + + GetAccessorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.getKeyword; + case 2: + return this.propertyName; + case 3: + return this.parameterList; + case 4: + return this.typeAnnotation; + case 5: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + GetAccessorSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + GetAccessorSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + GetAccessorSyntax.prototype.isClassElement = function () { + return true; + }; + + GetAccessorSyntax.prototype.update = function (modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block) { + if (this.modifiers === modifiers && this.getKeyword === getKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.typeAnnotation === typeAnnotation && this.block === block) { + return this; + } + + return new GetAccessorSyntax(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block, this.parsedInStrictMode()); + }; + + GetAccessorSyntax.create = function (getKeyword, propertyName, parameterList, block) { + return new GetAccessorSyntax(TypeScript.Syntax.emptyList, getKeyword, propertyName, parameterList, null, block, false); + }; + + GetAccessorSyntax.create1 = function (propertyName) { + return new GetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(64 /* GetKeyword */), propertyName, ParameterListSyntax.create1(), null, BlockSyntax.create1(), false); + }; + + GetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + GetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + GetAccessorSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + GetAccessorSyntax.prototype.withGetKeyword = function (getKeyword) { + return this.update(this.modifiers, getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, this.getKeyword, propertyName, this.parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, parameterList, this.typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, typeAnnotation, this.block); + }; + + GetAccessorSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.getKeyword, this.propertyName, this.parameterList, this.typeAnnotation, block); + }; + + GetAccessorSyntax.prototype.isTypeScriptSpecific = function () { + if (this.modifiers.childCount() > 0) { + return true; + } + if (this.parameterList.isTypeScriptSpecific()) { + return true; + } + if (this.typeAnnotation !== null) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return GetAccessorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.GetAccessorSyntax = GetAccessorSyntax; + + var SetAccessorSyntax = (function (_super) { + __extends(SetAccessorSyntax, _super); + function SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.setKeyword = setKeyword; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.block = block; + } + SetAccessorSyntax.prototype.accept = function (visitor) { + return visitor.visitSetAccessor(this); + }; + + SetAccessorSyntax.prototype.kind = function () { + return 140 /* SetAccessor */; + }; + + SetAccessorSyntax.prototype.childCount = function () { + return 5; + }; + + SetAccessorSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.setKeyword; + case 2: + return this.propertyName; + case 3: + return this.parameterList; + case 4: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SetAccessorSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + SetAccessorSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + SetAccessorSyntax.prototype.isClassElement = function () { + return true; + }; + + SetAccessorSyntax.prototype.update = function (modifiers, setKeyword, propertyName, parameterList, block) { + if (this.modifiers === modifiers && this.setKeyword === setKeyword && this.propertyName === propertyName && this.parameterList === parameterList && this.block === block) { + return this; + } + + return new SetAccessorSyntax(modifiers, setKeyword, propertyName, parameterList, block, this.parsedInStrictMode()); + }; + + SetAccessorSyntax.create = function (setKeyword, propertyName, parameterList, block) { + return new SetAccessorSyntax(TypeScript.Syntax.emptyList, setKeyword, propertyName, parameterList, block, false); + }; + + SetAccessorSyntax.create1 = function (propertyName) { + return new SetAccessorSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(68 /* SetKeyword */), propertyName, ParameterListSyntax.create1(), BlockSyntax.create1(), false); + }; + + SetAccessorSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SetAccessorSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SetAccessorSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.setKeyword, this.propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + SetAccessorSyntax.prototype.withSetKeyword = function (setKeyword) { + return this.update(this.modifiers, setKeyword, this.propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(this.modifiers, this.setKeyword, propertyName, this.parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withParameterList = function (parameterList) { + return this.update(this.modifiers, this.setKeyword, this.propertyName, parameterList, this.block); + }; + + SetAccessorSyntax.prototype.withBlock = function (block) { + return this.update(this.modifiers, this.setKeyword, this.propertyName, this.parameterList, block); + }; + + SetAccessorSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return SetAccessorSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SetAccessorSyntax = SetAccessorSyntax; + + var MemberVariableDeclarationSyntax = (function (_super) { + __extends(MemberVariableDeclarationSyntax, _super); + function MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.variableDeclarator = variableDeclarator; + this.semicolonToken = semicolonToken; + } + MemberVariableDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitMemberVariableDeclaration(this); + }; + + MemberVariableDeclarationSyntax.prototype.kind = function () { + return 136 /* MemberVariableDeclaration */; + }; + + MemberVariableDeclarationSyntax.prototype.childCount = function () { + return 3; + }; + + MemberVariableDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.variableDeclarator; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + MemberVariableDeclarationSyntax.prototype.isMemberDeclaration = function () { + return true; + }; + + MemberVariableDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + MemberVariableDeclarationSyntax.prototype.update = function (modifiers, variableDeclarator, semicolonToken) { + if (this.modifiers === modifiers && this.variableDeclarator === variableDeclarator && this.semicolonToken === semicolonToken) { + return this; + } + + return new MemberVariableDeclarationSyntax(modifiers, variableDeclarator, semicolonToken, this.parsedInStrictMode()); + }; + + MemberVariableDeclarationSyntax.create = function (variableDeclarator, semicolonToken) { + return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, semicolonToken, false); + }; + + MemberVariableDeclarationSyntax.create1 = function (variableDeclarator) { + return new MemberVariableDeclarationSyntax(TypeScript.Syntax.emptyList, variableDeclarator, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + MemberVariableDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + MemberVariableDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + MemberVariableDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.variableDeclarator, this.semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + MemberVariableDeclarationSyntax.prototype.withVariableDeclarator = function (variableDeclarator) { + return this.update(this.modifiers, variableDeclarator, this.semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.variableDeclarator, semicolonToken); + }; + + MemberVariableDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return MemberVariableDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.MemberVariableDeclarationSyntax = MemberVariableDeclarationSyntax; + + var IndexMemberDeclarationSyntax = (function (_super) { + __extends(IndexMemberDeclarationSyntax, _super); + function IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.indexSignature = indexSignature; + this.semicolonToken = semicolonToken; + } + IndexMemberDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitIndexMemberDeclaration(this); + }; + + IndexMemberDeclarationSyntax.prototype.kind = function () { + return 138 /* IndexMemberDeclaration */; + }; + + IndexMemberDeclarationSyntax.prototype.childCount = function () { + return 3; + }; + + IndexMemberDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.indexSignature; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + IndexMemberDeclarationSyntax.prototype.isClassElement = function () { + return true; + }; + + IndexMemberDeclarationSyntax.prototype.update = function (modifiers, indexSignature, semicolonToken) { + if (this.modifiers === modifiers && this.indexSignature === indexSignature && this.semicolonToken === semicolonToken) { + return this; + } + + return new IndexMemberDeclarationSyntax(modifiers, indexSignature, semicolonToken, this.parsedInStrictMode()); + }; + + IndexMemberDeclarationSyntax.create = function (indexSignature, semicolonToken) { + return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, semicolonToken, false); + }; + + IndexMemberDeclarationSyntax.create1 = function (indexSignature) { + return new IndexMemberDeclarationSyntax(TypeScript.Syntax.emptyList, indexSignature, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + IndexMemberDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + IndexMemberDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + IndexMemberDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.indexSignature, this.semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + IndexMemberDeclarationSyntax.prototype.withIndexSignature = function (indexSignature) { + return this.update(this.modifiers, indexSignature, this.semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.modifiers, this.indexSignature, semicolonToken); + }; + + IndexMemberDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return IndexMemberDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.IndexMemberDeclarationSyntax = IndexMemberDeclarationSyntax; + + var ThrowStatementSyntax = (function (_super) { + __extends(ThrowStatementSyntax, _super); + function ThrowStatementSyntax(throwKeyword, expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.throwKeyword = throwKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ThrowStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitThrowStatement(this); + }; + + ThrowStatementSyntax.prototype.kind = function () { + return 157 /* ThrowStatement */; + }; + + ThrowStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ThrowStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.throwKeyword; + case 1: + return this.expression; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ThrowStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ThrowStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ThrowStatementSyntax.prototype.update = function (throwKeyword, expression, semicolonToken) { + if (this.throwKeyword === throwKeyword && this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ThrowStatementSyntax(throwKeyword, expression, semicolonToken, this.parsedInStrictMode()); + }; + + ThrowStatementSyntax.create1 = function (expression) { + return new ThrowStatementSyntax(TypeScript.Syntax.token(36 /* ThrowKeyword */), expression, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ThrowStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ThrowStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ThrowStatementSyntax.prototype.withThrowKeyword = function (throwKeyword) { + return this.update(throwKeyword, this.expression, this.semicolonToken); + }; + + ThrowStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.throwKeyword, expression, this.semicolonToken); + }; + + ThrowStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.throwKeyword, this.expression, semicolonToken); + }; + + ThrowStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ThrowStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ThrowStatementSyntax = ThrowStatementSyntax; + + var ReturnStatementSyntax = (function (_super) { + __extends(ReturnStatementSyntax, _super); + function ReturnStatementSyntax(returnKeyword, expression, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.returnKeyword = returnKeyword; + this.expression = expression; + this.semicolonToken = semicolonToken; + } + ReturnStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitReturnStatement(this); + }; + + ReturnStatementSyntax.prototype.kind = function () { + return 150 /* ReturnStatement */; + }; + + ReturnStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ReturnStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.returnKeyword; + case 1: + return this.expression; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ReturnStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ReturnStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ReturnStatementSyntax.prototype.update = function (returnKeyword, expression, semicolonToken) { + if (this.returnKeyword === returnKeyword && this.expression === expression && this.semicolonToken === semicolonToken) { + return this; + } + + return new ReturnStatementSyntax(returnKeyword, expression, semicolonToken, this.parsedInStrictMode()); + }; + + ReturnStatementSyntax.create = function (returnKeyword, semicolonToken) { + return new ReturnStatementSyntax(returnKeyword, null, semicolonToken, false); + }; + + ReturnStatementSyntax.create1 = function () { + return new ReturnStatementSyntax(TypeScript.Syntax.token(33 /* ReturnKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ReturnStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ReturnStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ReturnStatementSyntax.prototype.withReturnKeyword = function (returnKeyword) { + return this.update(returnKeyword, this.expression, this.semicolonToken); + }; + + ReturnStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.returnKeyword, expression, this.semicolonToken); + }; + + ReturnStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.returnKeyword, this.expression, semicolonToken); + }; + + ReturnStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression !== null && this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ReturnStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ReturnStatementSyntax = ReturnStatementSyntax; + + var ObjectCreationExpressionSyntax = (function (_super) { + __extends(ObjectCreationExpressionSyntax, _super); + function ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.newKeyword = newKeyword; + this.expression = expression; + this.argumentList = argumentList; + } + ObjectCreationExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectCreationExpression(this); + }; + + ObjectCreationExpressionSyntax.prototype.kind = function () { + return 216 /* ObjectCreationExpression */; + }; + + ObjectCreationExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectCreationExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.newKeyword; + case 1: + return this.expression; + case 2: + return this.argumentList; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectCreationExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ObjectCreationExpressionSyntax.prototype.update = function (newKeyword, expression, argumentList) { + if (this.newKeyword === newKeyword && this.expression === expression && this.argumentList === argumentList) { + return this; + } + + return new ObjectCreationExpressionSyntax(newKeyword, expression, argumentList, this.parsedInStrictMode()); + }; + + ObjectCreationExpressionSyntax.create = function (newKeyword, expression) { + return new ObjectCreationExpressionSyntax(newKeyword, expression, null, false); + }; + + ObjectCreationExpressionSyntax.create1 = function (expression) { + return new ObjectCreationExpressionSyntax(TypeScript.Syntax.token(31 /* NewKeyword */), expression, null, false); + }; + + ObjectCreationExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectCreationExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectCreationExpressionSyntax.prototype.withNewKeyword = function (newKeyword) { + return this.update(newKeyword, this.expression, this.argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.newKeyword, expression, this.argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.withArgumentList = function (argumentList) { + return this.update(this.newKeyword, this.expression, argumentList); + }; + + ObjectCreationExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.argumentList !== null && this.argumentList.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ObjectCreationExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectCreationExpressionSyntax = ObjectCreationExpressionSyntax; + + var SwitchStatementSyntax = (function (_super) { + __extends(SwitchStatementSyntax, _super); + function SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.switchKeyword = switchKeyword; + this.openParenToken = openParenToken; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.openBraceToken = openBraceToken; + this.switchClauses = switchClauses; + this.closeBraceToken = closeBraceToken; + } + SwitchStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitSwitchStatement(this); + }; + + SwitchStatementSyntax.prototype.kind = function () { + return 151 /* SwitchStatement */; + }; + + SwitchStatementSyntax.prototype.childCount = function () { + return 7; + }; + + SwitchStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.switchKeyword; + case 1: + return this.openParenToken; + case 2: + return this.expression; + case 3: + return this.closeParenToken; + case 4: + return this.openBraceToken; + case 5: + return this.switchClauses; + case 6: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SwitchStatementSyntax.prototype.isStatement = function () { + return true; + }; + + SwitchStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + SwitchStatementSyntax.prototype.update = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken) { + if (this.switchKeyword === switchKeyword && this.openParenToken === openParenToken && this.expression === expression && this.closeParenToken === closeParenToken && this.openBraceToken === openBraceToken && this.switchClauses === switchClauses && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken, this.parsedInStrictMode()); + }; + + SwitchStatementSyntax.create = function (switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, closeBraceToken) { + return new SwitchStatementSyntax(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, TypeScript.Syntax.emptyList, closeBraceToken, false); + }; + + SwitchStatementSyntax.create1 = function (expression) { + return new SwitchStatementSyntax(TypeScript.Syntax.token(34 /* SwitchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptyList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + SwitchStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SwitchStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SwitchStatementSyntax.prototype.withSwitchKeyword = function (switchKeyword) { + return this.update(switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.switchKeyword, openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.switchKeyword, this.openParenToken, expression, this.closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, closeParenToken, this.openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, openBraceToken, this.switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withSwitchClauses = function (switchClauses) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, switchClauses, this.closeBraceToken); + }; + + SwitchStatementSyntax.prototype.withSwitchClause = function (switchClause) { + return this.withSwitchClauses(TypeScript.Syntax.list([switchClause])); + }; + + SwitchStatementSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.switchKeyword, this.openParenToken, this.expression, this.closeParenToken, this.openBraceToken, this.switchClauses, closeBraceToken); + }; + + SwitchStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.switchClauses.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SwitchStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SwitchStatementSyntax = SwitchStatementSyntax; + + var CaseSwitchClauseSyntax = (function (_super) { + __extends(CaseSwitchClauseSyntax, _super); + function CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.caseKeyword = caseKeyword; + this.expression = expression; + this.colonToken = colonToken; + this.statements = statements; + } + CaseSwitchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitCaseSwitchClause(this); + }; + + CaseSwitchClauseSyntax.prototype.kind = function () { + return 233 /* CaseSwitchClause */; + }; + + CaseSwitchClauseSyntax.prototype.childCount = function () { + return 4; + }; + + CaseSwitchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.caseKeyword; + case 1: + return this.expression; + case 2: + return this.colonToken; + case 3: + return this.statements; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CaseSwitchClauseSyntax.prototype.isSwitchClause = function () { + return true; + }; + + CaseSwitchClauseSyntax.prototype.update = function (caseKeyword, expression, colonToken, statements) { + if (this.caseKeyword === caseKeyword && this.expression === expression && this.colonToken === colonToken && this.statements === statements) { + return this; + } + + return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, statements, this.parsedInStrictMode()); + }; + + CaseSwitchClauseSyntax.create = function (caseKeyword, expression, colonToken) { + return new CaseSwitchClauseSyntax(caseKeyword, expression, colonToken, TypeScript.Syntax.emptyList, false); + }; + + CaseSwitchClauseSyntax.create1 = function (expression) { + return new CaseSwitchClauseSyntax(TypeScript.Syntax.token(16 /* CaseKeyword */), expression, TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false); + }; + + CaseSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CaseSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CaseSwitchClauseSyntax.prototype.withCaseKeyword = function (caseKeyword) { + return this.update(caseKeyword, this.expression, this.colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withExpression = function (expression) { + return this.update(this.caseKeyword, expression, this.colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.caseKeyword, this.expression, colonToken, this.statements); + }; + + CaseSwitchClauseSyntax.prototype.withStatements = function (statements) { + return this.update(this.caseKeyword, this.expression, this.colonToken, statements); + }; + + CaseSwitchClauseSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + CaseSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return CaseSwitchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CaseSwitchClauseSyntax = CaseSwitchClauseSyntax; + + var DefaultSwitchClauseSyntax = (function (_super) { + __extends(DefaultSwitchClauseSyntax, _super); + function DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.defaultKeyword = defaultKeyword; + this.colonToken = colonToken; + this.statements = statements; + } + DefaultSwitchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitDefaultSwitchClause(this); + }; + + DefaultSwitchClauseSyntax.prototype.kind = function () { + return 234 /* DefaultSwitchClause */; + }; + + DefaultSwitchClauseSyntax.prototype.childCount = function () { + return 3; + }; + + DefaultSwitchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.defaultKeyword; + case 1: + return this.colonToken; + case 2: + return this.statements; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DefaultSwitchClauseSyntax.prototype.isSwitchClause = function () { + return true; + }; + + DefaultSwitchClauseSyntax.prototype.update = function (defaultKeyword, colonToken, statements) { + if (this.defaultKeyword === defaultKeyword && this.colonToken === colonToken && this.statements === statements) { + return this; + } + + return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, statements, this.parsedInStrictMode()); + }; + + DefaultSwitchClauseSyntax.create = function (defaultKeyword, colonToken) { + return new DefaultSwitchClauseSyntax(defaultKeyword, colonToken, TypeScript.Syntax.emptyList, false); + }; + + DefaultSwitchClauseSyntax.create1 = function () { + return new DefaultSwitchClauseSyntax(TypeScript.Syntax.token(20 /* DefaultKeyword */), TypeScript.Syntax.token(106 /* ColonToken */), TypeScript.Syntax.emptyList, false); + }; + + DefaultSwitchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DefaultSwitchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DefaultSwitchClauseSyntax.prototype.withDefaultKeyword = function (defaultKeyword) { + return this.update(defaultKeyword, this.colonToken, this.statements); + }; + + DefaultSwitchClauseSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.defaultKeyword, colonToken, this.statements); + }; + + DefaultSwitchClauseSyntax.prototype.withStatements = function (statements) { + return this.update(this.defaultKeyword, this.colonToken, statements); + }; + + DefaultSwitchClauseSyntax.prototype.withStatement = function (statement) { + return this.withStatements(TypeScript.Syntax.list([statement])); + }; + + DefaultSwitchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statements.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DefaultSwitchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DefaultSwitchClauseSyntax = DefaultSwitchClauseSyntax; + + var BreakStatementSyntax = (function (_super) { + __extends(BreakStatementSyntax, _super); + function BreakStatementSyntax(breakKeyword, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.breakKeyword = breakKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + BreakStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitBreakStatement(this); + }; + + BreakStatementSyntax.prototype.kind = function () { + return 152 /* BreakStatement */; + }; + + BreakStatementSyntax.prototype.childCount = function () { + return 3; + }; + + BreakStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.breakKeyword; + case 1: + return this.identifier; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + BreakStatementSyntax.prototype.isStatement = function () { + return true; + }; + + BreakStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + BreakStatementSyntax.prototype.update = function (breakKeyword, identifier, semicolonToken) { + if (this.breakKeyword === breakKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new BreakStatementSyntax(breakKeyword, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + BreakStatementSyntax.create = function (breakKeyword, semicolonToken) { + return new BreakStatementSyntax(breakKeyword, null, semicolonToken, false); + }; + + BreakStatementSyntax.create1 = function () { + return new BreakStatementSyntax(TypeScript.Syntax.token(15 /* BreakKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + BreakStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + BreakStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + BreakStatementSyntax.prototype.withBreakKeyword = function (breakKeyword) { + return this.update(breakKeyword, this.identifier, this.semicolonToken); + }; + + BreakStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.breakKeyword, identifier, this.semicolonToken); + }; + + BreakStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.breakKeyword, this.identifier, semicolonToken); + }; + + BreakStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return BreakStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.BreakStatementSyntax = BreakStatementSyntax; + + var ContinueStatementSyntax = (function (_super) { + __extends(ContinueStatementSyntax, _super); + function ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.continueKeyword = continueKeyword; + this.identifier = identifier; + this.semicolonToken = semicolonToken; + } + ContinueStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitContinueStatement(this); + }; + + ContinueStatementSyntax.prototype.kind = function () { + return 153 /* ContinueStatement */; + }; + + ContinueStatementSyntax.prototype.childCount = function () { + return 3; + }; + + ContinueStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.continueKeyword; + case 1: + return this.identifier; + case 2: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ContinueStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ContinueStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ContinueStatementSyntax.prototype.update = function (continueKeyword, identifier, semicolonToken) { + if (this.continueKeyword === continueKeyword && this.identifier === identifier && this.semicolonToken === semicolonToken) { + return this; + } + + return new ContinueStatementSyntax(continueKeyword, identifier, semicolonToken, this.parsedInStrictMode()); + }; + + ContinueStatementSyntax.create = function (continueKeyword, semicolonToken) { + return new ContinueStatementSyntax(continueKeyword, null, semicolonToken, false); + }; + + ContinueStatementSyntax.create1 = function () { + return new ContinueStatementSyntax(TypeScript.Syntax.token(18 /* ContinueKeyword */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + ContinueStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ContinueStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ContinueStatementSyntax.prototype.withContinueKeyword = function (continueKeyword) { + return this.update(continueKeyword, this.identifier, this.semicolonToken); + }; + + ContinueStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.continueKeyword, identifier, this.semicolonToken); + }; + + ContinueStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.continueKeyword, this.identifier, semicolonToken); + }; + + ContinueStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return ContinueStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ContinueStatementSyntax = ContinueStatementSyntax; + + var ForStatementSyntax = (function (_super) { + __extends(ForStatementSyntax, _super); + function ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.initializer = initializer; + this.firstSemicolonToken = firstSemicolonToken; + this.condition = condition; + this.secondSemicolonToken = secondSemicolonToken; + this.incrementor = incrementor; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + ForStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitForStatement(this); + }; + + ForStatementSyntax.prototype.kind = function () { + return 154 /* ForStatement */; + }; + + ForStatementSyntax.prototype.childCount = function () { + return 10; + }; + + ForStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.forKeyword; + case 1: + return this.openParenToken; + case 2: + return this.variableDeclaration; + case 3: + return this.initializer; + case 4: + return this.firstSemicolonToken; + case 5: + return this.condition; + case 6: + return this.secondSemicolonToken; + case 7: + return this.incrementor; + case 8: + return this.closeParenToken; + case 9: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ForStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + ForStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ForStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ForStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement) { + if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.initializer === initializer && this.firstSemicolonToken === firstSemicolonToken && this.condition === condition && this.secondSemicolonToken === secondSemicolonToken && this.incrementor === incrementor && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new ForStatementSyntax(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement, this.parsedInStrictMode()); + }; + + ForStatementSyntax.create = function (forKeyword, openParenToken, firstSemicolonToken, secondSemicolonToken, closeParenToken, statement) { + return new ForStatementSyntax(forKeyword, openParenToken, null, null, firstSemicolonToken, null, secondSemicolonToken, null, closeParenToken, statement, false); + }; + + ForStatementSyntax.create1 = function (statement) { + return new ForStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(78 /* SemicolonToken */), null, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + ForStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ForStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ForStatementSyntax.prototype.withForKeyword = function (forKeyword) { + return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withInitializer = function (initializer) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withFirstSemicolonToken = function (firstSemicolonToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withSecondSemicolonToken = function (secondSemicolonToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, secondSemicolonToken, this.incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withIncrementor = function (incrementor) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, incrementor, this.closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, closeParenToken, this.statement); + }; + + ForStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.initializer, this.firstSemicolonToken, this.condition, this.secondSemicolonToken, this.incrementor, this.closeParenToken, statement); + }; + + ForStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + if (this.initializer !== null && this.initializer.isTypeScriptSpecific()) { + return true; + } + if (this.condition !== null && this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.incrementor !== null && this.incrementor.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ForStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ForStatementSyntax = ForStatementSyntax; + + var ForInStatementSyntax = (function (_super) { + __extends(ForInStatementSyntax, _super); + function ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.forKeyword = forKeyword; + this.openParenToken = openParenToken; + this.variableDeclaration = variableDeclaration; + this.left = left; + this.inKeyword = inKeyword; + this.expression = expression; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + ForInStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitForInStatement(this); + }; + + ForInStatementSyntax.prototype.kind = function () { + return 155 /* ForInStatement */; + }; + + ForInStatementSyntax.prototype.childCount = function () { + return 8; + }; + + ForInStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.forKeyword; + case 1: + return this.openParenToken; + case 2: + return this.variableDeclaration; + case 3: + return this.left; + case 4: + return this.inKeyword; + case 5: + return this.expression; + case 6: + return this.closeParenToken; + case 7: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ForInStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + ForInStatementSyntax.prototype.isStatement = function () { + return true; + }; + + ForInStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + ForInStatementSyntax.prototype.update = function (forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement) { + if (this.forKeyword === forKeyword && this.openParenToken === openParenToken && this.variableDeclaration === variableDeclaration && this.left === left && this.inKeyword === inKeyword && this.expression === expression && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new ForInStatementSyntax(forKeyword, openParenToken, variableDeclaration, left, inKeyword, expression, closeParenToken, statement, this.parsedInStrictMode()); + }; + + ForInStatementSyntax.create = function (forKeyword, openParenToken, inKeyword, expression, closeParenToken, statement) { + return new ForInStatementSyntax(forKeyword, openParenToken, null, null, inKeyword, expression, closeParenToken, statement, false); + }; + + ForInStatementSyntax.create1 = function (expression, statement) { + return new ForInStatementSyntax(TypeScript.Syntax.token(26 /* ForKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), null, null, TypeScript.Syntax.token(29 /* InKeyword */), expression, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + ForInStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ForInStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ForInStatementSyntax.prototype.withForKeyword = function (forKeyword) { + return this.update(forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.forKeyword, openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withVariableDeclaration = function (variableDeclaration) { + return this.update(this.forKeyword, this.openParenToken, variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withLeft = function (left) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, left, this.inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withInKeyword = function (inKeyword) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, inKeyword, this.expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withExpression = function (expression) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, expression, this.closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, closeParenToken, this.statement); + }; + + ForInStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.forKeyword, this.openParenToken, this.variableDeclaration, this.left, this.inKeyword, this.expression, this.closeParenToken, statement); + }; + + ForInStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.variableDeclaration !== null && this.variableDeclaration.isTypeScriptSpecific()) { + return true; + } + if (this.left !== null && this.left.isTypeScriptSpecific()) { + return true; + } + if (this.expression.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ForInStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ForInStatementSyntax = ForInStatementSyntax; + + var WhileStatementSyntax = (function (_super) { + __extends(WhileStatementSyntax, _super); + function WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + WhileStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitWhileStatement(this); + }; + + WhileStatementSyntax.prototype.kind = function () { + return 158 /* WhileStatement */; + }; + + WhileStatementSyntax.prototype.childCount = function () { + return 5; + }; + + WhileStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.whileKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + WhileStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + WhileStatementSyntax.prototype.isStatement = function () { + return true; + }; + + WhileStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + WhileStatementSyntax.prototype.update = function (whileKeyword, openParenToken, condition, closeParenToken, statement) { + if (this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new WhileStatementSyntax(whileKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode()); + }; + + WhileStatementSyntax.create1 = function (condition, statement) { + return new WhileStatementSyntax(TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + WhileStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + WhileStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + WhileStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) { + return this.update(whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.statement); + }; + + WhileStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, statement); + }; + + WhileStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return WhileStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.WhileStatementSyntax = WhileStatementSyntax; + + var WithStatementSyntax = (function (_super) { + __extends(WithStatementSyntax, _super); + function WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.withKeyword = withKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.statement = statement; + } + WithStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitWithStatement(this); + }; + + WithStatementSyntax.prototype.kind = function () { + return 163 /* WithStatement */; + }; + + WithStatementSyntax.prototype.childCount = function () { + return 5; + }; + + WithStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.withKeyword; + case 1: + return this.openParenToken; + case 2: + return this.condition; + case 3: + return this.closeParenToken; + case 4: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + WithStatementSyntax.prototype.isStatement = function () { + return true; + }; + + WithStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + WithStatementSyntax.prototype.update = function (withKeyword, openParenToken, condition, closeParenToken, statement) { + if (this.withKeyword === withKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.statement === statement) { + return this; + } + + return new WithStatementSyntax(withKeyword, openParenToken, condition, closeParenToken, statement, this.parsedInStrictMode()); + }; + + WithStatementSyntax.create1 = function (condition, statement) { + return new WithStatementSyntax(TypeScript.Syntax.token(43 /* WithKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), statement, false); + }; + + WithStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + WithStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + WithStatementSyntax.prototype.withWithKeyword = function (withKeyword) { + return this.update(withKeyword, this.openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.withKeyword, openParenToken, this.condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.withKeyword, this.openParenToken, condition, this.closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.withKeyword, this.openParenToken, this.condition, closeParenToken, this.statement); + }; + + WithStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.withKeyword, this.openParenToken, this.condition, this.closeParenToken, statement); + }; + + WithStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.condition.isTypeScriptSpecific()) { + return true; + } + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return WithStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.WithStatementSyntax = WithStatementSyntax; + + var EnumDeclarationSyntax = (function (_super) { + __extends(EnumDeclarationSyntax, _super); + function EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.modifiers = modifiers; + this.enumKeyword = enumKeyword; + this.identifier = identifier; + this.openBraceToken = openBraceToken; + this.enumElements = enumElements; + this.closeBraceToken = closeBraceToken; + } + EnumDeclarationSyntax.prototype.accept = function (visitor) { + return visitor.visitEnumDeclaration(this); + }; + + EnumDeclarationSyntax.prototype.kind = function () { + return 132 /* EnumDeclaration */; + }; + + EnumDeclarationSyntax.prototype.childCount = function () { + return 6; + }; + + EnumDeclarationSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.modifiers; + case 1: + return this.enumKeyword; + case 2: + return this.identifier; + case 3: + return this.openBraceToken; + case 4: + return this.enumElements; + case 5: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EnumDeclarationSyntax.prototype.isModuleElement = function () { + return true; + }; + + EnumDeclarationSyntax.prototype.update = function (modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken) { + if (this.modifiers === modifiers && this.enumKeyword === enumKeyword && this.identifier === identifier && this.openBraceToken === openBraceToken && this.enumElements === enumElements && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new EnumDeclarationSyntax(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken, this.parsedInStrictMode()); + }; + + EnumDeclarationSyntax.create = function (enumKeyword, identifier, openBraceToken, closeBraceToken) { + return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, enumKeyword, identifier, openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + EnumDeclarationSyntax.create1 = function (identifier) { + return new EnumDeclarationSyntax(TypeScript.Syntax.emptyList, TypeScript.Syntax.token(46 /* EnumKeyword */), identifier, TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + EnumDeclarationSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EnumDeclarationSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EnumDeclarationSyntax.prototype.withModifiers = function (modifiers) { + return this.update(modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withModifier = function (modifier) { + return this.withModifiers(TypeScript.Syntax.list([modifier])); + }; + + EnumDeclarationSyntax.prototype.withEnumKeyword = function (enumKeyword) { + return this.update(this.modifiers, enumKeyword, this.identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.modifiers, this.enumKeyword, identifier, this.openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, openBraceToken, this.enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withEnumElements = function (enumElements) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, enumElements, this.closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.withEnumElement = function (enumElement) { + return this.withEnumElements(TypeScript.Syntax.separatedList([enumElement])); + }; + + EnumDeclarationSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.modifiers, this.enumKeyword, this.identifier, this.openBraceToken, this.enumElements, closeBraceToken); + }; + + EnumDeclarationSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return EnumDeclarationSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EnumDeclarationSyntax = EnumDeclarationSyntax; + + var EnumElementSyntax = (function (_super) { + __extends(EnumElementSyntax, _super); + function EnumElementSyntax(propertyName, equalsValueClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.equalsValueClause = equalsValueClause; + } + EnumElementSyntax.prototype.accept = function (visitor) { + return visitor.visitEnumElement(this); + }; + + EnumElementSyntax.prototype.kind = function () { + return 243 /* EnumElement */; + }; + + EnumElementSyntax.prototype.childCount = function () { + return 2; + }; + + EnumElementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.equalsValueClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EnumElementSyntax.prototype.update = function (propertyName, equalsValueClause) { + if (this.propertyName === propertyName && this.equalsValueClause === equalsValueClause) { + return this; + } + + return new EnumElementSyntax(propertyName, equalsValueClause, this.parsedInStrictMode()); + }; + + EnumElementSyntax.create = function (propertyName) { + return new EnumElementSyntax(propertyName, null, false); + }; + + EnumElementSyntax.create1 = function (propertyName) { + return new EnumElementSyntax(propertyName, null, false); + }; + + EnumElementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EnumElementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EnumElementSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.equalsValueClause); + }; + + EnumElementSyntax.prototype.withEqualsValueClause = function (equalsValueClause) { + return this.update(this.propertyName, equalsValueClause); + }; + + EnumElementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.equalsValueClause !== null && this.equalsValueClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return EnumElementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EnumElementSyntax = EnumElementSyntax; + + var CastExpressionSyntax = (function (_super) { + __extends(CastExpressionSyntax, _super); + function CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.lessThanToken = lessThanToken; + this.type = type; + this.greaterThanToken = greaterThanToken; + this.expression = expression; + } + CastExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitCastExpression(this); + }; + + CastExpressionSyntax.prototype.kind = function () { + return 220 /* CastExpression */; + }; + + CastExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + CastExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.lessThanToken; + case 1: + return this.type; + case 2: + return this.greaterThanToken; + case 3: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CastExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + CastExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + CastExpressionSyntax.prototype.update = function (lessThanToken, type, greaterThanToken, expression) { + if (this.lessThanToken === lessThanToken && this.type === type && this.greaterThanToken === greaterThanToken && this.expression === expression) { + return this; + } + + return new CastExpressionSyntax(lessThanToken, type, greaterThanToken, expression, this.parsedInStrictMode()); + }; + + CastExpressionSyntax.create1 = function (type, expression) { + return new CastExpressionSyntax(TypeScript.Syntax.token(80 /* LessThanToken */), type, TypeScript.Syntax.token(81 /* GreaterThanToken */), expression, false); + }; + + CastExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CastExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CastExpressionSyntax.prototype.withLessThanToken = function (lessThanToken) { + return this.update(lessThanToken, this.type, this.greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withType = function (type) { + return this.update(this.lessThanToken, type, this.greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withGreaterThanToken = function (greaterThanToken) { + return this.update(this.lessThanToken, this.type, greaterThanToken, this.expression); + }; + + CastExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.lessThanToken, this.type, this.greaterThanToken, expression); + }; + + CastExpressionSyntax.prototype.isTypeScriptSpecific = function () { + return true; + }; + return CastExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CastExpressionSyntax = CastExpressionSyntax; + + var ObjectLiteralExpressionSyntax = (function (_super) { + __extends(ObjectLiteralExpressionSyntax, _super); + function ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.openBraceToken = openBraceToken; + this.propertyAssignments = propertyAssignments; + this.closeBraceToken = closeBraceToken; + } + ObjectLiteralExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitObjectLiteralExpression(this); + }; + + ObjectLiteralExpressionSyntax.prototype.kind = function () { + return 215 /* ObjectLiteralExpression */; + }; + + ObjectLiteralExpressionSyntax.prototype.childCount = function () { + return 3; + }; + + ObjectLiteralExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.openBraceToken; + case 1: + return this.propertyAssignments; + case 2: + return this.closeBraceToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ObjectLiteralExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + ObjectLiteralExpressionSyntax.prototype.update = function (openBraceToken, propertyAssignments, closeBraceToken) { + if (this.openBraceToken === openBraceToken && this.propertyAssignments === propertyAssignments && this.closeBraceToken === closeBraceToken) { + return this; + } + + return new ObjectLiteralExpressionSyntax(openBraceToken, propertyAssignments, closeBraceToken, this.parsedInStrictMode()); + }; + + ObjectLiteralExpressionSyntax.create = function (openBraceToken, closeBraceToken) { + return new ObjectLiteralExpressionSyntax(openBraceToken, TypeScript.Syntax.emptySeparatedList, closeBraceToken, false); + }; + + ObjectLiteralExpressionSyntax.create1 = function () { + return new ObjectLiteralExpressionSyntax(TypeScript.Syntax.token(70 /* OpenBraceToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.token(71 /* CloseBraceToken */), false); + }; + + ObjectLiteralExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + ObjectLiteralExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + ObjectLiteralExpressionSyntax.prototype.withOpenBraceToken = function (openBraceToken) { + return this.update(openBraceToken, this.propertyAssignments, this.closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.withPropertyAssignments = function (propertyAssignments) { + return this.update(this.openBraceToken, propertyAssignments, this.closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.withPropertyAssignment = function (propertyAssignment) { + return this.withPropertyAssignments(TypeScript.Syntax.separatedList([propertyAssignment])); + }; + + ObjectLiteralExpressionSyntax.prototype.withCloseBraceToken = function (closeBraceToken) { + return this.update(this.openBraceToken, this.propertyAssignments, closeBraceToken); + }; + + ObjectLiteralExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.propertyAssignments.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return ObjectLiteralExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.ObjectLiteralExpressionSyntax = ObjectLiteralExpressionSyntax; + + var SimplePropertyAssignmentSyntax = (function (_super) { + __extends(SimplePropertyAssignmentSyntax, _super); + function SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.colonToken = colonToken; + this.expression = expression; + } + SimplePropertyAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitSimplePropertyAssignment(this); + }; + + SimplePropertyAssignmentSyntax.prototype.kind = function () { + return 240 /* SimplePropertyAssignment */; + }; + + SimplePropertyAssignmentSyntax.prototype.childCount = function () { + return 3; + }; + + SimplePropertyAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.colonToken; + case 2: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SimplePropertyAssignmentSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + SimplePropertyAssignmentSyntax.prototype.update = function (propertyName, colonToken, expression) { + if (this.propertyName === propertyName && this.colonToken === colonToken && this.expression === expression) { + return this; + } + + return new SimplePropertyAssignmentSyntax(propertyName, colonToken, expression, this.parsedInStrictMode()); + }; + + SimplePropertyAssignmentSyntax.create1 = function (propertyName, expression) { + return new SimplePropertyAssignmentSyntax(propertyName, TypeScript.Syntax.token(106 /* ColonToken */), expression, false); + }; + + SimplePropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + SimplePropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + SimplePropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.colonToken, this.expression); + }; + + SimplePropertyAssignmentSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.propertyName, colonToken, this.expression); + }; + + SimplePropertyAssignmentSyntax.prototype.withExpression = function (expression) { + return this.update(this.propertyName, this.colonToken, expression); + }; + + SimplePropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return SimplePropertyAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.SimplePropertyAssignmentSyntax = SimplePropertyAssignmentSyntax; + + var FunctionPropertyAssignmentSyntax = (function (_super) { + __extends(FunctionPropertyAssignmentSyntax, _super); + function FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + } + FunctionPropertyAssignmentSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionPropertyAssignment(this); + }; + + FunctionPropertyAssignmentSyntax.prototype.kind = function () { + return 241 /* FunctionPropertyAssignment */; + }; + + FunctionPropertyAssignmentSyntax.prototype.childCount = function () { + return 3; + }; + + FunctionPropertyAssignmentSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.propertyName; + case 1: + return this.callSignature; + case 2: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionPropertyAssignmentSyntax.prototype.isPropertyAssignment = function () { + return true; + }; + + FunctionPropertyAssignmentSyntax.prototype.update = function (propertyName, callSignature, block) { + if (this.propertyName === propertyName && this.callSignature === callSignature && this.block === block) { + return this; + } + + return new FunctionPropertyAssignmentSyntax(propertyName, callSignature, block, this.parsedInStrictMode()); + }; + + FunctionPropertyAssignmentSyntax.create1 = function (propertyName) { + return new FunctionPropertyAssignmentSyntax(propertyName, CallSignatureSyntax.create1(), BlockSyntax.create1(), false); + }; + + FunctionPropertyAssignmentSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionPropertyAssignmentSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionPropertyAssignmentSyntax.prototype.withPropertyName = function (propertyName) { + return this.update(propertyName, this.callSignature, this.block); + }; + + FunctionPropertyAssignmentSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.propertyName, callSignature, this.block); + }; + + FunctionPropertyAssignmentSyntax.prototype.withBlock = function (block) { + return this.update(this.propertyName, this.callSignature, block); + }; + + FunctionPropertyAssignmentSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionPropertyAssignmentSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionPropertyAssignmentSyntax = FunctionPropertyAssignmentSyntax; + + var FunctionExpressionSyntax = (function (_super) { + __extends(FunctionExpressionSyntax, _super); + function FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.functionKeyword = functionKeyword; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + } + FunctionExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitFunctionExpression(this); + }; + + FunctionExpressionSyntax.prototype.kind = function () { + return 222 /* FunctionExpression */; + }; + + FunctionExpressionSyntax.prototype.childCount = function () { + return 4; + }; + + FunctionExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.functionKeyword; + case 1: + return this.identifier; + case 2: + return this.callSignature; + case 3: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FunctionExpressionSyntax.prototype.isPrimaryExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isMemberExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isPostfixExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + FunctionExpressionSyntax.prototype.update = function (functionKeyword, identifier, callSignature, block) { + if (this.functionKeyword === functionKeyword && this.identifier === identifier && this.callSignature === callSignature && this.block === block) { + return this; + } + + return new FunctionExpressionSyntax(functionKeyword, identifier, callSignature, block, this.parsedInStrictMode()); + }; + + FunctionExpressionSyntax.create = function (functionKeyword, callSignature, block) { + return new FunctionExpressionSyntax(functionKeyword, null, callSignature, block, false); + }; + + FunctionExpressionSyntax.create1 = function () { + return new FunctionExpressionSyntax(TypeScript.Syntax.token(27 /* FunctionKeyword */), null, CallSignatureSyntax.create1(), BlockSyntax.create1(), false); + }; + + FunctionExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FunctionExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FunctionExpressionSyntax.prototype.withFunctionKeyword = function (functionKeyword) { + return this.update(functionKeyword, this.identifier, this.callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.functionKeyword, identifier, this.callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withCallSignature = function (callSignature) { + return this.update(this.functionKeyword, this.identifier, callSignature, this.block); + }; + + FunctionExpressionSyntax.prototype.withBlock = function (block) { + return this.update(this.functionKeyword, this.identifier, this.callSignature, block); + }; + + FunctionExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.callSignature.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FunctionExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FunctionExpressionSyntax = FunctionExpressionSyntax; + + var EmptyStatementSyntax = (function (_super) { + __extends(EmptyStatementSyntax, _super); + function EmptyStatementSyntax(semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.semicolonToken = semicolonToken; + } + EmptyStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitEmptyStatement(this); + }; + + EmptyStatementSyntax.prototype.kind = function () { + return 156 /* EmptyStatement */; + }; + + EmptyStatementSyntax.prototype.childCount = function () { + return 1; + }; + + EmptyStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + EmptyStatementSyntax.prototype.isStatement = function () { + return true; + }; + + EmptyStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + EmptyStatementSyntax.prototype.update = function (semicolonToken) { + if (this.semicolonToken === semicolonToken) { + return this; + } + + return new EmptyStatementSyntax(semicolonToken, this.parsedInStrictMode()); + }; + + EmptyStatementSyntax.create1 = function () { + return new EmptyStatementSyntax(TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + EmptyStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + EmptyStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + EmptyStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(semicolonToken); + }; + + EmptyStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return EmptyStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.EmptyStatementSyntax = EmptyStatementSyntax; + + var TryStatementSyntax = (function (_super) { + __extends(TryStatementSyntax, _super); + function TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.tryKeyword = tryKeyword; + this.block = block; + this.catchClause = catchClause; + this.finallyClause = finallyClause; + } + TryStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitTryStatement(this); + }; + + TryStatementSyntax.prototype.kind = function () { + return 159 /* TryStatement */; + }; + + TryStatementSyntax.prototype.childCount = function () { + return 4; + }; + + TryStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.tryKeyword; + case 1: + return this.block; + case 2: + return this.catchClause; + case 3: + return this.finallyClause; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TryStatementSyntax.prototype.isStatement = function () { + return true; + }; + + TryStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + TryStatementSyntax.prototype.update = function (tryKeyword, block, catchClause, finallyClause) { + if (this.tryKeyword === tryKeyword && this.block === block && this.catchClause === catchClause && this.finallyClause === finallyClause) { + return this; + } + + return new TryStatementSyntax(tryKeyword, block, catchClause, finallyClause, this.parsedInStrictMode()); + }; + + TryStatementSyntax.create = function (tryKeyword, block) { + return new TryStatementSyntax(tryKeyword, block, null, null, false); + }; + + TryStatementSyntax.create1 = function () { + return new TryStatementSyntax(TypeScript.Syntax.token(38 /* TryKeyword */), BlockSyntax.create1(), null, null, false); + }; + + TryStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TryStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TryStatementSyntax.prototype.withTryKeyword = function (tryKeyword) { + return this.update(tryKeyword, this.block, this.catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withBlock = function (block) { + return this.update(this.tryKeyword, block, this.catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withCatchClause = function (catchClause) { + return this.update(this.tryKeyword, this.block, catchClause, this.finallyClause); + }; + + TryStatementSyntax.prototype.withFinallyClause = function (finallyClause) { + return this.update(this.tryKeyword, this.block, this.catchClause, finallyClause); + }; + + TryStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.block.isTypeScriptSpecific()) { + return true; + } + if (this.catchClause !== null && this.catchClause.isTypeScriptSpecific()) { + return true; + } + if (this.finallyClause !== null && this.finallyClause.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return TryStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TryStatementSyntax = TryStatementSyntax; + + var CatchClauseSyntax = (function (_super) { + __extends(CatchClauseSyntax, _super); + function CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.catchKeyword = catchKeyword; + this.openParenToken = openParenToken; + this.identifier = identifier; + this.typeAnnotation = typeAnnotation; + this.closeParenToken = closeParenToken; + this.block = block; + } + CatchClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitCatchClause(this); + }; + + CatchClauseSyntax.prototype.kind = function () { + return 236 /* CatchClause */; + }; + + CatchClauseSyntax.prototype.childCount = function () { + return 6; + }; + + CatchClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.catchKeyword; + case 1: + return this.openParenToken; + case 2: + return this.identifier; + case 3: + return this.typeAnnotation; + case 4: + return this.closeParenToken; + case 5: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + CatchClauseSyntax.prototype.update = function (catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block) { + if (this.catchKeyword === catchKeyword && this.openParenToken === openParenToken && this.identifier === identifier && this.typeAnnotation === typeAnnotation && this.closeParenToken === closeParenToken && this.block === block) { + return this; + } + + return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block, this.parsedInStrictMode()); + }; + + CatchClauseSyntax.create = function (catchKeyword, openParenToken, identifier, closeParenToken, block) { + return new CatchClauseSyntax(catchKeyword, openParenToken, identifier, null, closeParenToken, block, false); + }; + + CatchClauseSyntax.create1 = function (identifier) { + return new CatchClauseSyntax(TypeScript.Syntax.token(17 /* CatchKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), identifier, null, TypeScript.Syntax.token(73 /* CloseParenToken */), BlockSyntax.create1(), false); + }; + + CatchClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + CatchClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + CatchClauseSyntax.prototype.withCatchKeyword = function (catchKeyword) { + return this.update(catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.catchKeyword, openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withIdentifier = function (identifier) { + return this.update(this.catchKeyword, this.openParenToken, identifier, this.typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withTypeAnnotation = function (typeAnnotation) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, typeAnnotation, this.closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, closeParenToken, this.block); + }; + + CatchClauseSyntax.prototype.withBlock = function (block) { + return this.update(this.catchKeyword, this.openParenToken, this.identifier, this.typeAnnotation, this.closeParenToken, block); + }; + + CatchClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.typeAnnotation !== null && this.typeAnnotation.isTypeScriptSpecific()) { + return true; + } + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return CatchClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.CatchClauseSyntax = CatchClauseSyntax; + + var FinallyClauseSyntax = (function (_super) { + __extends(FinallyClauseSyntax, _super); + function FinallyClauseSyntax(finallyKeyword, block, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.finallyKeyword = finallyKeyword; + this.block = block; + } + FinallyClauseSyntax.prototype.accept = function (visitor) { + return visitor.visitFinallyClause(this); + }; + + FinallyClauseSyntax.prototype.kind = function () { + return 237 /* FinallyClause */; + }; + + FinallyClauseSyntax.prototype.childCount = function () { + return 2; + }; + + FinallyClauseSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.finallyKeyword; + case 1: + return this.block; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + FinallyClauseSyntax.prototype.update = function (finallyKeyword, block) { + if (this.finallyKeyword === finallyKeyword && this.block === block) { + return this; + } + + return new FinallyClauseSyntax(finallyKeyword, block, this.parsedInStrictMode()); + }; + + FinallyClauseSyntax.create1 = function () { + return new FinallyClauseSyntax(TypeScript.Syntax.token(25 /* FinallyKeyword */), BlockSyntax.create1(), false); + }; + + FinallyClauseSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + FinallyClauseSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + FinallyClauseSyntax.prototype.withFinallyKeyword = function (finallyKeyword) { + return this.update(finallyKeyword, this.block); + }; + + FinallyClauseSyntax.prototype.withBlock = function (block) { + return this.update(this.finallyKeyword, block); + }; + + FinallyClauseSyntax.prototype.isTypeScriptSpecific = function () { + if (this.block.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return FinallyClauseSyntax; + })(TypeScript.SyntaxNode); + TypeScript.FinallyClauseSyntax = FinallyClauseSyntax; + + var LabeledStatementSyntax = (function (_super) { + __extends(LabeledStatementSyntax, _super); + function LabeledStatementSyntax(identifier, colonToken, statement, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.identifier = identifier; + this.colonToken = colonToken; + this.statement = statement; + } + LabeledStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitLabeledStatement(this); + }; + + LabeledStatementSyntax.prototype.kind = function () { + return 160 /* LabeledStatement */; + }; + + LabeledStatementSyntax.prototype.childCount = function () { + return 3; + }; + + LabeledStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.identifier; + case 1: + return this.colonToken; + case 2: + return this.statement; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + LabeledStatementSyntax.prototype.isStatement = function () { + return true; + }; + + LabeledStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + LabeledStatementSyntax.prototype.update = function (identifier, colonToken, statement) { + if (this.identifier === identifier && this.colonToken === colonToken && this.statement === statement) { + return this; + } + + return new LabeledStatementSyntax(identifier, colonToken, statement, this.parsedInStrictMode()); + }; + + LabeledStatementSyntax.create1 = function (identifier, statement) { + return new LabeledStatementSyntax(identifier, TypeScript.Syntax.token(106 /* ColonToken */), statement, false); + }; + + LabeledStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + LabeledStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + LabeledStatementSyntax.prototype.withIdentifier = function (identifier) { + return this.update(identifier, this.colonToken, this.statement); + }; + + LabeledStatementSyntax.prototype.withColonToken = function (colonToken) { + return this.update(this.identifier, colonToken, this.statement); + }; + + LabeledStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.identifier, this.colonToken, statement); + }; + + LabeledStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return LabeledStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.LabeledStatementSyntax = LabeledStatementSyntax; + + var DoStatementSyntax = (function (_super) { + __extends(DoStatementSyntax, _super); + function DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.doKeyword = doKeyword; + this.statement = statement; + this.whileKeyword = whileKeyword; + this.openParenToken = openParenToken; + this.condition = condition; + this.closeParenToken = closeParenToken; + this.semicolonToken = semicolonToken; + } + DoStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitDoStatement(this); + }; + + DoStatementSyntax.prototype.kind = function () { + return 161 /* DoStatement */; + }; + + DoStatementSyntax.prototype.childCount = function () { + return 7; + }; + + DoStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.doKeyword; + case 1: + return this.statement; + case 2: + return this.whileKeyword; + case 3: + return this.openParenToken; + case 4: + return this.condition; + case 5: + return this.closeParenToken; + case 6: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DoStatementSyntax.prototype.isIterationStatement = function () { + return true; + }; + + DoStatementSyntax.prototype.isStatement = function () { + return true; + }; + + DoStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + DoStatementSyntax.prototype.update = function (doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken) { + if (this.doKeyword === doKeyword && this.statement === statement && this.whileKeyword === whileKeyword && this.openParenToken === openParenToken && this.condition === condition && this.closeParenToken === closeParenToken && this.semicolonToken === semicolonToken) { + return this; + } + + return new DoStatementSyntax(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken, this.parsedInStrictMode()); + }; + + DoStatementSyntax.create1 = function (statement, condition) { + return new DoStatementSyntax(TypeScript.Syntax.token(22 /* DoKeyword */), statement, TypeScript.Syntax.token(42 /* WhileKeyword */), TypeScript.Syntax.token(72 /* OpenParenToken */), condition, TypeScript.Syntax.token(73 /* CloseParenToken */), TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + DoStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DoStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DoStatementSyntax.prototype.withDoKeyword = function (doKeyword) { + return this.update(doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withStatement = function (statement) { + return this.update(this.doKeyword, statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withWhileKeyword = function (whileKeyword) { + return this.update(this.doKeyword, this.statement, whileKeyword, this.openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withOpenParenToken = function (openParenToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, openParenToken, this.condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withCondition = function (condition) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, condition, this.closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withCloseParenToken = function (closeParenToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, closeParenToken, this.semicolonToken); + }; + + DoStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.doKeyword, this.statement, this.whileKeyword, this.openParenToken, this.condition, this.closeParenToken, semicolonToken); + }; + + DoStatementSyntax.prototype.isTypeScriptSpecific = function () { + if (this.statement.isTypeScriptSpecific()) { + return true; + } + if (this.condition.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DoStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DoStatementSyntax = DoStatementSyntax; + + var TypeOfExpressionSyntax = (function (_super) { + __extends(TypeOfExpressionSyntax, _super); + function TypeOfExpressionSyntax(typeOfKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.typeOfKeyword = typeOfKeyword; + this.expression = expression; + } + TypeOfExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitTypeOfExpression(this); + }; + + TypeOfExpressionSyntax.prototype.kind = function () { + return 171 /* TypeOfExpression */; + }; + + TypeOfExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + TypeOfExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.typeOfKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + TypeOfExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + TypeOfExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + TypeOfExpressionSyntax.prototype.update = function (typeOfKeyword, expression) { + if (this.typeOfKeyword === typeOfKeyword && this.expression === expression) { + return this; + } + + return new TypeOfExpressionSyntax(typeOfKeyword, expression, this.parsedInStrictMode()); + }; + + TypeOfExpressionSyntax.create1 = function (expression) { + return new TypeOfExpressionSyntax(TypeScript.Syntax.token(39 /* TypeOfKeyword */), expression, false); + }; + + TypeOfExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + TypeOfExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + TypeOfExpressionSyntax.prototype.withTypeOfKeyword = function (typeOfKeyword) { + return this.update(typeOfKeyword, this.expression); + }; + + TypeOfExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.typeOfKeyword, expression); + }; + + TypeOfExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return TypeOfExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.TypeOfExpressionSyntax = TypeOfExpressionSyntax; + + var DeleteExpressionSyntax = (function (_super) { + __extends(DeleteExpressionSyntax, _super); + function DeleteExpressionSyntax(deleteKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.deleteKeyword = deleteKeyword; + this.expression = expression; + } + DeleteExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitDeleteExpression(this); + }; + + DeleteExpressionSyntax.prototype.kind = function () { + return 170 /* DeleteExpression */; + }; + + DeleteExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + DeleteExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.deleteKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DeleteExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + DeleteExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + DeleteExpressionSyntax.prototype.update = function (deleteKeyword, expression) { + if (this.deleteKeyword === deleteKeyword && this.expression === expression) { + return this; + } + + return new DeleteExpressionSyntax(deleteKeyword, expression, this.parsedInStrictMode()); + }; + + DeleteExpressionSyntax.create1 = function (expression) { + return new DeleteExpressionSyntax(TypeScript.Syntax.token(21 /* DeleteKeyword */), expression, false); + }; + + DeleteExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DeleteExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DeleteExpressionSyntax.prototype.withDeleteKeyword = function (deleteKeyword) { + return this.update(deleteKeyword, this.expression); + }; + + DeleteExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.deleteKeyword, expression); + }; + + DeleteExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return DeleteExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DeleteExpressionSyntax = DeleteExpressionSyntax; + + var VoidExpressionSyntax = (function (_super) { + __extends(VoidExpressionSyntax, _super); + function VoidExpressionSyntax(voidKeyword, expression, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.voidKeyword = voidKeyword; + this.expression = expression; + } + VoidExpressionSyntax.prototype.accept = function (visitor) { + return visitor.visitVoidExpression(this); + }; + + VoidExpressionSyntax.prototype.kind = function () { + return 172 /* VoidExpression */; + }; + + VoidExpressionSyntax.prototype.childCount = function () { + return 2; + }; + + VoidExpressionSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.voidKeyword; + case 1: + return this.expression; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + VoidExpressionSyntax.prototype.isUnaryExpression = function () { + return true; + }; + + VoidExpressionSyntax.prototype.isExpression = function () { + return true; + }; + + VoidExpressionSyntax.prototype.update = function (voidKeyword, expression) { + if (this.voidKeyword === voidKeyword && this.expression === expression) { + return this; + } + + return new VoidExpressionSyntax(voidKeyword, expression, this.parsedInStrictMode()); + }; + + VoidExpressionSyntax.create1 = function (expression) { + return new VoidExpressionSyntax(TypeScript.Syntax.token(41 /* VoidKeyword */), expression, false); + }; + + VoidExpressionSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + VoidExpressionSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + VoidExpressionSyntax.prototype.withVoidKeyword = function (voidKeyword) { + return this.update(voidKeyword, this.expression); + }; + + VoidExpressionSyntax.prototype.withExpression = function (expression) { + return this.update(this.voidKeyword, expression); + }; + + VoidExpressionSyntax.prototype.isTypeScriptSpecific = function () { + if (this.expression.isTypeScriptSpecific()) { + return true; + } + return false; + }; + return VoidExpressionSyntax; + })(TypeScript.SyntaxNode); + TypeScript.VoidExpressionSyntax = VoidExpressionSyntax; + + var DebuggerStatementSyntax = (function (_super) { + __extends(DebuggerStatementSyntax, _super); + function DebuggerStatementSyntax(debuggerKeyword, semicolonToken, parsedInStrictMode) { + _super.call(this, parsedInStrictMode); + this.debuggerKeyword = debuggerKeyword; + this.semicolonToken = semicolonToken; + } + DebuggerStatementSyntax.prototype.accept = function (visitor) { + return visitor.visitDebuggerStatement(this); + }; + + DebuggerStatementSyntax.prototype.kind = function () { + return 162 /* DebuggerStatement */; + }; + + DebuggerStatementSyntax.prototype.childCount = function () { + return 2; + }; + + DebuggerStatementSyntax.prototype.childAt = function (slot) { + switch (slot) { + case 0: + return this.debuggerKeyword; + case 1: + return this.semicolonToken; + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + DebuggerStatementSyntax.prototype.isStatement = function () { + return true; + }; + + DebuggerStatementSyntax.prototype.isModuleElement = function () { + return true; + }; + + DebuggerStatementSyntax.prototype.update = function (debuggerKeyword, semicolonToken) { + if (this.debuggerKeyword === debuggerKeyword && this.semicolonToken === semicolonToken) { + return this; + } + + return new DebuggerStatementSyntax(debuggerKeyword, semicolonToken, this.parsedInStrictMode()); + }; + + DebuggerStatementSyntax.create1 = function () { + return new DebuggerStatementSyntax(TypeScript.Syntax.token(19 /* DebuggerKeyword */), TypeScript.Syntax.token(78 /* SemicolonToken */), false); + }; + + DebuggerStatementSyntax.prototype.withLeadingTrivia = function (trivia) { + return _super.prototype.withLeadingTrivia.call(this, trivia); + }; + + DebuggerStatementSyntax.prototype.withTrailingTrivia = function (trivia) { + return _super.prototype.withTrailingTrivia.call(this, trivia); + }; + + DebuggerStatementSyntax.prototype.withDebuggerKeyword = function (debuggerKeyword) { + return this.update(debuggerKeyword, this.semicolonToken); + }; + + DebuggerStatementSyntax.prototype.withSemicolonToken = function (semicolonToken) { + return this.update(this.debuggerKeyword, semicolonToken); + }; + + DebuggerStatementSyntax.prototype.isTypeScriptSpecific = function () { + return false; + }; + return DebuggerStatementSyntax; + })(TypeScript.SyntaxNode); + TypeScript.DebuggerStatementSyntax = DebuggerStatementSyntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxRewriter = (function () { + function SyntaxRewriter() { + } + SyntaxRewriter.prototype.visitToken = function (token) { + return token; + }; + + SyntaxRewriter.prototype.visitNode = function (node) { + return node.accept(this); + }; + + SyntaxRewriter.prototype.visitNodeOrToken = function (node) { + return node.isToken() ? this.visitToken(node) : this.visitNode(node); + }; + + SyntaxRewriter.prototype.visitList = function (list) { + var newItems = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + var newItem = this.visitNodeOrToken(item); + + if (item !== newItem && newItems === null) { + newItems = []; + for (var j = 0; j < i; j++) { + newItems.push(list.childAt(j)); + } + } + + if (newItems) { + newItems.push(newItem); + } + } + + return newItems === null ? list : TypeScript.Syntax.list(newItems); + }; + + SyntaxRewriter.prototype.visitSeparatedList = function (list) { + var newItems = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + var newItem = item.isToken() ? this.visitToken(item) : this.visitNode(item); + + if (item !== newItem && newItems === null) { + newItems = []; + for (var j = 0; j < i; j++) { + newItems.push(list.childAt(j)); + } + } + + if (newItems) { + newItems.push(newItem); + } + } + + return newItems === null ? list : TypeScript.Syntax.separatedList(newItems); + }; + + SyntaxRewriter.prototype.visitSourceUnit = function (node) { + return node.update(this.visitList(node.moduleElements), this.visitToken(node.endOfFileToken)); + }; + + SyntaxRewriter.prototype.visitExternalModuleReference = function (node) { + return node.update(this.visitToken(node.requireKeyword), this.visitToken(node.openParenToken), this.visitToken(node.stringLiteral), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitModuleNameModuleReference = function (node) { + return node.update(this.visitNodeOrToken(node.moduleName)); + }; + + SyntaxRewriter.prototype.visitImportDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.importKeyword), this.visitToken(node.identifier), this.visitToken(node.equalsToken), this.visitNodeOrToken(node.moduleReference), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitExportAssignment = function (node) { + return node.update(this.visitToken(node.exportKeyword), this.visitToken(node.equalsToken), this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitClassDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.classKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitToken(node.openBraceToken), this.visitList(node.classElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitInterfaceDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.interfaceKeyword), this.visitToken(node.identifier), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitList(node.heritageClauses), this.visitNode(node.body)); + }; + + SyntaxRewriter.prototype.visitHeritageClause = function (node) { + return node.update(node.kind(), this.visitToken(node.extendsOrImplementsKeyword), this.visitSeparatedList(node.typeNames)); + }; + + SyntaxRewriter.prototype.visitModuleDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.moduleKeyword), node.name === null ? null : this.visitNodeOrToken(node.name), node.stringLiteral === null ? null : this.visitToken(node.stringLiteral), this.visitToken(node.openBraceToken), this.visitList(node.moduleElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitFunctionDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.functionKeyword), this.visitToken(node.identifier), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitVariableStatement = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclaration), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitVariableDeclaration = function (node) { + return node.update(this.visitToken(node.varKeyword), this.visitSeparatedList(node.variableDeclarators)); + }; + + SyntaxRewriter.prototype.visitVariableDeclarator = function (node) { + return node.update(this.visitToken(node.propertyName), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitEqualsValueClause = function (node) { + return node.update(this.visitToken(node.equalsToken), this.visitNodeOrToken(node.value)); + }; + + SyntaxRewriter.prototype.visitPrefixUnaryExpression = function (node) { + return node.update(node.kind(), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.operand)); + }; + + SyntaxRewriter.prototype.visitArrayLiteralExpression = function (node) { + return node.update(this.visitToken(node.openBracketToken), this.visitSeparatedList(node.expressions), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitOmittedExpression = function (node) { + return node; + }; + + SyntaxRewriter.prototype.visitParenthesizedExpression = function (node) { + return node.update(this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitSimpleArrowFunctionExpression = function (node) { + return node.update(this.visitToken(node.identifier), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + return node.update(this.visitNode(node.callSignature), this.visitToken(node.equalsGreaterThanToken), node.block === null ? null : this.visitNode(node.block), node.expression === null ? null : this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitQualifiedName = function (node) { + return node.update(this.visitNodeOrToken(node.left), this.visitToken(node.dotToken), this.visitToken(node.right)); + }; + + SyntaxRewriter.prototype.visitTypeArgumentList = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeArguments), this.visitToken(node.greaterThanToken)); + }; + + SyntaxRewriter.prototype.visitConstructorType = function (node) { + return node.update(this.visitToken(node.newKeyword), node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitFunctionType = function (node) { + return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), this.visitToken(node.equalsGreaterThanToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitObjectType = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.typeMembers), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitArrayType = function (node) { + return node.update(this.visitNodeOrToken(node.type), this.visitToken(node.openBracketToken), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitGenericType = function (node) { + return node.update(this.visitNodeOrToken(node.name), this.visitNode(node.typeArgumentList)); + }; + + SyntaxRewriter.prototype.visitTypeQuery = function (node) { + return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.name)); + }; + + SyntaxRewriter.prototype.visitTypeAnnotation = function (node) { + return node.update(this.visitToken(node.colonToken), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitBlock = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitList(node.statements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitParameter = function (node) { + return node.update(node.dotDotDotToken === null ? null : this.visitToken(node.dotDotDotToken), this.visitList(node.modifiers), this.visitToken(node.identifier), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitMemberAccessExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.dotToken), this.visitToken(node.name)); + }; + + SyntaxRewriter.prototype.visitPostfixUnaryExpression = function (node) { + return node.update(node.kind(), this.visitNodeOrToken(node.operand), this.visitToken(node.operatorToken)); + }; + + SyntaxRewriter.prototype.visitElementAccessExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.openBracketToken), this.visitNodeOrToken(node.argumentExpression), this.visitToken(node.closeBracketToken)); + }; + + SyntaxRewriter.prototype.visitInvocationExpression = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitNode(node.argumentList)); + }; + + SyntaxRewriter.prototype.visitArgumentList = function (node) { + return node.update(node.typeArgumentList === null ? null : this.visitNode(node.typeArgumentList), this.visitToken(node.openParenToken), this.visitSeparatedList(node.arguments), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitBinaryExpression = function (node) { + return node.update(node.kind(), this.visitNodeOrToken(node.left), this.visitToken(node.operatorToken), this.visitNodeOrToken(node.right)); + }; + + SyntaxRewriter.prototype.visitConditionalExpression = function (node) { + return node.update(this.visitNodeOrToken(node.condition), this.visitToken(node.questionToken), this.visitNodeOrToken(node.whenTrue), this.visitToken(node.colonToken), this.visitNodeOrToken(node.whenFalse)); + }; + + SyntaxRewriter.prototype.visitConstructSignature = function (node) { + return node.update(this.visitToken(node.newKeyword), this.visitNode(node.callSignature)); + }; + + SyntaxRewriter.prototype.visitMethodSignature = function (node) { + return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), this.visitNode(node.callSignature)); + }; + + SyntaxRewriter.prototype.visitIndexSignature = function (node) { + return node.update(this.visitToken(node.openBracketToken), this.visitNode(node.parameter), this.visitToken(node.closeBracketToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitPropertySignature = function (node) { + return node.update(this.visitToken(node.propertyName), node.questionToken === null ? null : this.visitToken(node.questionToken), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitCallSignature = function (node) { + return node.update(node.typeParameterList === null ? null : this.visitNode(node.typeParameterList), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation)); + }; + + SyntaxRewriter.prototype.visitParameterList = function (node) { + return node.update(this.visitToken(node.openParenToken), this.visitSeparatedList(node.parameters), this.visitToken(node.closeParenToken)); + }; + + SyntaxRewriter.prototype.visitTypeParameterList = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitSeparatedList(node.typeParameters), this.visitToken(node.greaterThanToken)); + }; + + SyntaxRewriter.prototype.visitTypeParameter = function (node) { + return node.update(this.visitToken(node.identifier), node.constraint === null ? null : this.visitNode(node.constraint)); + }; + + SyntaxRewriter.prototype.visitConstraint = function (node) { + return node.update(this.visitToken(node.extendsKeyword), this.visitNodeOrToken(node.type)); + }; + + SyntaxRewriter.prototype.visitElseClause = function (node) { + return node.update(this.visitToken(node.elseKeyword), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitIfStatement = function (node) { + return node.update(this.visitToken(node.ifKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement), node.elseClause === null ? null : this.visitNode(node.elseClause)); + }; + + SyntaxRewriter.prototype.visitExpressionStatement = function (node) { + return node.update(this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitConstructorDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.constructorKeyword), this.visitNode(node.parameterList), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitMemberFunctionDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.propertyName), this.visitNode(node.callSignature), node.block === null ? null : this.visitNode(node.block), node.semicolonToken === null ? null : this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitGetAccessor = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.getKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitSetAccessor = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.setKeyword), this.visitToken(node.propertyName), this.visitNode(node.parameterList), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitMemberVariableDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.variableDeclarator), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitIndexMemberDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitNode(node.indexSignature), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitThrowStatement = function (node) { + return node.update(this.visitToken(node.throwKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitReturnStatement = function (node) { + return node.update(this.visitToken(node.returnKeyword), node.expression === null ? null : this.visitNodeOrToken(node.expression), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitObjectCreationExpression = function (node) { + return node.update(this.visitToken(node.newKeyword), this.visitNodeOrToken(node.expression), node.argumentList === null ? null : this.visitNode(node.argumentList)); + }; + + SyntaxRewriter.prototype.visitSwitchStatement = function (node) { + return node.update(this.visitToken(node.switchKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitToken(node.openBraceToken), this.visitList(node.switchClauses), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitCaseSwitchClause = function (node) { + return node.update(this.visitToken(node.caseKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.colonToken), this.visitList(node.statements)); + }; + + SyntaxRewriter.prototype.visitDefaultSwitchClause = function (node) { + return node.update(this.visitToken(node.defaultKeyword), this.visitToken(node.colonToken), this.visitList(node.statements)); + }; + + SyntaxRewriter.prototype.visitBreakStatement = function (node) { + return node.update(this.visitToken(node.breakKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitContinueStatement = function (node) { + return node.update(this.visitToken(node.continueKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitForStatement = function (node) { + return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.initializer === null ? null : this.visitNodeOrToken(node.initializer), this.visitToken(node.firstSemicolonToken), node.condition === null ? null : this.visitNodeOrToken(node.condition), this.visitToken(node.secondSemicolonToken), node.incrementor === null ? null : this.visitNodeOrToken(node.incrementor), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitForInStatement = function (node) { + return node.update(this.visitToken(node.forKeyword), this.visitToken(node.openParenToken), node.variableDeclaration === null ? null : this.visitNode(node.variableDeclaration), node.left === null ? null : this.visitNodeOrToken(node.left), this.visitToken(node.inKeyword), this.visitNodeOrToken(node.expression), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitWhileStatement = function (node) { + return node.update(this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitWithStatement = function (node) { + return node.update(this.visitToken(node.withKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitEnumDeclaration = function (node) { + return node.update(this.visitList(node.modifiers), this.visitToken(node.enumKeyword), this.visitToken(node.identifier), this.visitToken(node.openBraceToken), this.visitSeparatedList(node.enumElements), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitEnumElement = function (node) { + return node.update(this.visitToken(node.propertyName), node.equalsValueClause === null ? null : this.visitNode(node.equalsValueClause)); + }; + + SyntaxRewriter.prototype.visitCastExpression = function (node) { + return node.update(this.visitToken(node.lessThanToken), this.visitNodeOrToken(node.type), this.visitToken(node.greaterThanToken), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitObjectLiteralExpression = function (node) { + return node.update(this.visitToken(node.openBraceToken), this.visitSeparatedList(node.propertyAssignments), this.visitToken(node.closeBraceToken)); + }; + + SyntaxRewriter.prototype.visitSimplePropertyAssignment = function (node) { + return node.update(this.visitToken(node.propertyName), this.visitToken(node.colonToken), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitFunctionPropertyAssignment = function (node) { + return node.update(this.visitToken(node.propertyName), this.visitNode(node.callSignature), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitFunctionExpression = function (node) { + return node.update(this.visitToken(node.functionKeyword), node.identifier === null ? null : this.visitToken(node.identifier), this.visitNode(node.callSignature), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitEmptyStatement = function (node) { + return node.update(this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitTryStatement = function (node) { + return node.update(this.visitToken(node.tryKeyword), this.visitNode(node.block), node.catchClause === null ? null : this.visitNode(node.catchClause), node.finallyClause === null ? null : this.visitNode(node.finallyClause)); + }; + + SyntaxRewriter.prototype.visitCatchClause = function (node) { + return node.update(this.visitToken(node.catchKeyword), this.visitToken(node.openParenToken), this.visitToken(node.identifier), node.typeAnnotation === null ? null : this.visitNode(node.typeAnnotation), this.visitToken(node.closeParenToken), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitFinallyClause = function (node) { + return node.update(this.visitToken(node.finallyKeyword), this.visitNode(node.block)); + }; + + SyntaxRewriter.prototype.visitLabeledStatement = function (node) { + return node.update(this.visitToken(node.identifier), this.visitToken(node.colonToken), this.visitNodeOrToken(node.statement)); + }; + + SyntaxRewriter.prototype.visitDoStatement = function (node) { + return node.update(this.visitToken(node.doKeyword), this.visitNodeOrToken(node.statement), this.visitToken(node.whileKeyword), this.visitToken(node.openParenToken), this.visitNodeOrToken(node.condition), this.visitToken(node.closeParenToken), this.visitToken(node.semicolonToken)); + }; + + SyntaxRewriter.prototype.visitTypeOfExpression = function (node) { + return node.update(this.visitToken(node.typeOfKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitDeleteExpression = function (node) { + return node.update(this.visitToken(node.deleteKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitVoidExpression = function (node) { + return node.update(this.visitToken(node.voidKeyword), this.visitNodeOrToken(node.expression)); + }; + + SyntaxRewriter.prototype.visitDebuggerStatement = function (node) { + return node.update(this.visitToken(node.debuggerKeyword), this.visitToken(node.semicolonToken)); + }; + return SyntaxRewriter; + })(); + TypeScript.SyntaxRewriter = SyntaxRewriter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxDedenter = (function (_super) { + __extends(SyntaxDedenter, _super); + function SyntaxDedenter(dedentFirstToken, dedentationAmount, minimumIndent, options) { + _super.call(this); + this.dedentationAmount = dedentationAmount; + this.minimumIndent = minimumIndent; + this.options = options; + this.lastTriviaWasNewLine = dedentFirstToken; + } + SyntaxDedenter.prototype.abort = function () { + this.lastTriviaWasNewLine = false; + this.dedentationAmount = 0; + }; + + SyntaxDedenter.prototype.isAborted = function () { + return this.dedentationAmount === 0; + }; + + SyntaxDedenter.prototype.visitToken = function (token) { + if (token.width() === 0) { + return token; + } + + var result = token; + if (this.lastTriviaWasNewLine) { + result = token.withLeadingTrivia(this.dedentTriviaList(token.leadingTrivia())); + } + + if (this.isAborted()) { + return token; + } + + this.lastTriviaWasNewLine = token.hasTrailingNewLine(); + return result; + }; + + SyntaxDedenter.prototype.dedentTriviaList = function (triviaList) { + var result = []; + var dedentNextWhitespace = true; + + for (var i = 0, n = triviaList.count(); i < n && !this.isAborted(); i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + var dedentThisTrivia = dedentNextWhitespace; + dedentNextWhitespace = false; + + if (dedentThisTrivia) { + if (trivia.kind() === 4 /* WhitespaceTrivia */) { + var hasFollowingNewLine = (i < triviaList.count() - 1) && triviaList.syntaxTriviaAt(i + 1).kind() === 5 /* NewLineTrivia */; + result.push(this.dedentWhitespace(trivia, hasFollowingNewLine)); + continue; + } else if (trivia.kind() !== 5 /* NewLineTrivia */) { + this.abort(); + break; + } + } + + if (trivia.kind() === 6 /* MultiLineCommentTrivia */) { + result.push(this.dedentMultiLineComment(trivia)); + continue; + } + + result.push(trivia); + if (trivia.kind() === 5 /* NewLineTrivia */) { + dedentNextWhitespace = true; + } + } + + if (dedentNextWhitespace) { + this.abort(); + } + + if (this.isAborted()) { + return triviaList; + } + + return TypeScript.Syntax.triviaList(result); + }; + + SyntaxDedenter.prototype.dedentSegment = function (segment, hasFollowingNewLineTrivia) { + var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment); + + if (firstNonWhitespacePosition === segment.length) { + if (hasFollowingNewLineTrivia) { + return ""; + } + } else if (TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) { + return segment.substring(firstNonWhitespacePosition); + } + + var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options); + + var newFirstNonWhitespaceColumn = TypeScript.MathPrototype.min(firstNonWhitespaceColumn, TypeScript.MathPrototype.max(firstNonWhitespaceColumn - this.dedentationAmount, this.minimumIndent)); + + if (newFirstNonWhitespaceColumn === firstNonWhitespaceColumn) { + this.abort(); + return segment; + } + + this.dedentationAmount = firstNonWhitespaceColumn - newFirstNonWhitespaceColumn; + TypeScript.Debug.assert(this.dedentationAmount >= 0); + + var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options); + + return indentationString + segment.substring(firstNonWhitespacePosition); + }; + + SyntaxDedenter.prototype.dedentWhitespace = function (trivia, hasFollowingNewLineTrivia) { + var newIndentation = this.dedentSegment(trivia.fullText(), hasFollowingNewLineTrivia); + return TypeScript.Syntax.whitespace(newIndentation); + }; + + SyntaxDedenter.prototype.dedentMultiLineComment = function (trivia) { + var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + if (segments.length === 1) { + return trivia; + } + + for (var i = 1; i < segments.length; i++) { + var segment = segments[i]; + segments[i] = this.dedentSegment(segment, false); + } + + var result = segments.join(""); + + return TypeScript.Syntax.multiLineComment(result); + }; + + SyntaxDedenter.dedentNode = function (node, dedentFirstToken, dedentAmount, minimumIndent, options) { + var dedenter = new SyntaxDedenter(dedentFirstToken, dedentAmount, minimumIndent, options); + var result = node.accept(dedenter); + + if (dedenter.isAborted()) { + return node; + } + + return result; + }; + return SyntaxDedenter; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxDedenter = SyntaxDedenter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxIndenter = (function (_super) { + __extends(SyntaxIndenter, _super); + function SyntaxIndenter(indentFirstToken, indentationAmount, options) { + _super.call(this); + this.indentationAmount = indentationAmount; + this.options = options; + this.lastTriviaWasNewLine = indentFirstToken; + this.indentationTrivia = TypeScript.Indentation.indentationTrivia(this.indentationAmount, this.options); + } + SyntaxIndenter.prototype.visitToken = function (token) { + if (token.width() === 0) { + return token; + } + + var result = token; + if (this.lastTriviaWasNewLine) { + result = token.withLeadingTrivia(this.indentTriviaList(token.leadingTrivia())); + } + + this.lastTriviaWasNewLine = token.hasTrailingNewLine(); + return result; + }; + + SyntaxIndenter.prototype.indentTriviaList = function (triviaList) { + var result = []; + + var indentNextTrivia = true; + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + var indentThisTrivia = indentNextTrivia; + indentNextTrivia = false; + + switch (trivia.kind()) { + case 6 /* MultiLineCommentTrivia */: + this.indentMultiLineComment(trivia, indentThisTrivia, result); + continue; + + case 7 /* SingleLineCommentTrivia */: + case 8 /* SkippedTokenTrivia */: + this.indentSingleLineOrSkippedText(trivia, indentThisTrivia, result); + continue; + + case 4 /* WhitespaceTrivia */: + this.indentWhitespace(trivia, indentThisTrivia, result); + continue; + + case 5 /* NewLineTrivia */: + result.push(trivia); + indentNextTrivia = true; + continue; + + default: + throw TypeScript.Errors.invalidOperation(); + } + } + + if (indentNextTrivia) { + result.push(this.indentationTrivia); + } + + return TypeScript.Syntax.triviaList(result); + }; + + SyntaxIndenter.prototype.indentSegment = function (segment) { + var firstNonWhitespacePosition = TypeScript.Indentation.firstNonWhitespacePosition(segment); + + if (firstNonWhitespacePosition < segment.length && TypeScript.CharacterInfo.isLineTerminator(segment.charCodeAt(firstNonWhitespacePosition))) { + return segment; + } + + var firstNonWhitespaceColumn = TypeScript.Indentation.columnForPositionInString(segment, firstNonWhitespacePosition, this.options); + + var newFirstNonWhitespaceColumn = firstNonWhitespaceColumn + this.indentationAmount; + + var indentationString = TypeScript.Indentation.indentationString(newFirstNonWhitespaceColumn, this.options); + + return indentationString + segment.substring(firstNonWhitespacePosition); + }; + + SyntaxIndenter.prototype.indentWhitespace = function (trivia, indentThisTrivia, result) { + if (!indentThisTrivia) { + result.push(trivia); + return; + } + + var newIndentation = this.indentSegment(trivia.fullText()); + result.push(TypeScript.Syntax.whitespace(newIndentation)); + }; + + SyntaxIndenter.prototype.indentSingleLineOrSkippedText = function (trivia, indentThisTrivia, result) { + if (indentThisTrivia) { + result.push(this.indentationTrivia); + } + + result.push(trivia); + }; + + SyntaxIndenter.prototype.indentMultiLineComment = function (trivia, indentThisTrivia, result) { + if (indentThisTrivia) { + result.push(this.indentationTrivia); + } + + var segments = TypeScript.Syntax.splitMultiLineCommentTriviaIntoMultipleLines(trivia); + + for (var i = 1; i < segments.length; i++) { + segments[i] = this.indentSegment(segments[i]); + } + + var newText = segments.join(""); + result.push(TypeScript.Syntax.multiLineComment(newText)); + }; + + SyntaxIndenter.indentNode = function (node, indentFirstToken, indentAmount, options) { + var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options); + return node.accept(indenter); + }; + + SyntaxIndenter.indentNodes = function (nodes, indentFirstToken, indentAmount, options) { + var indenter = new SyntaxIndenter(indentFirstToken, indentAmount, options); + var result = TypeScript.ArrayUtilities.select(nodes, function (n) { + return n.accept(indenter); + }); + + return result; + }; + return SyntaxIndenter; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxIndenter = SyntaxIndenter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var VariableWidthTokenWithNoTrivia = (function () { + function VariableWidthTokenWithNoTrivia(sourceText, fullStart, kind, textOrWidth) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._textOrWidth = textOrWidth; + } + VariableWidthTokenWithNoTrivia.prototype.clone = function () { + return new VariableWidthTokenWithNoTrivia(this._sourceText, this._fullStart, this.tokenKind, this._textOrWidth); + }; + + VariableWidthTokenWithNoTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithNoTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithNoTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithNoTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithNoTrivia.prototype.fullWidth = function () { + return this.width(); + }; + VariableWidthTokenWithNoTrivia.prototype.start = function () { + return this._fullStart; + }; + VariableWidthTokenWithNoTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithNoTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithNoTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithNoTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithNoTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithNoTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithNoTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithNoTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithNoTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithNoTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithNoTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithNoTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithNoTrivia; + })(); + Syntax.VariableWidthTokenWithNoTrivia = VariableWidthTokenWithNoTrivia; + + var VariableWidthTokenWithLeadingTrivia = (function () { + function VariableWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, textOrWidth) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._textOrWidth = textOrWidth; + } + VariableWidthTokenWithLeadingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithLeadingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._textOrWidth); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithLeadingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width(); + }; + VariableWidthTokenWithLeadingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithLeadingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithLeadingTrivia; + })(); + Syntax.VariableWidthTokenWithLeadingTrivia = VariableWidthTokenWithLeadingTrivia; + + var VariableWidthTokenWithTrailingTrivia = (function () { + function VariableWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, textOrWidth, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._textOrWidth = textOrWidth; + this._trailingTriviaInfo = trailingTriviaInfo; + } + VariableWidthTokenWithTrailingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._textOrWidth, this._trailingTriviaInfo); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.fullWidth = function () { + return this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.start = function () { + return this._fullStart; + }; + VariableWidthTokenWithTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + VariableWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithTrailingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithTrailingTrivia; + })(); + Syntax.VariableWidthTokenWithTrailingTrivia = VariableWidthTokenWithTrailingTrivia; + + var VariableWidthTokenWithLeadingAndTrailingTrivia = (function () { + function VariableWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, textOrWidth, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._textOrWidth = textOrWidth; + this._trailingTriviaInfo = trailingTriviaInfo; + } + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () { + return new VariableWidthTokenWithLeadingAndTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._textOrWidth, this._trailingTriviaInfo); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () { + return 0; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () { + return typeof this._textOrWidth === 'number' ? this._textOrWidth : this._textOrWidth.length; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () { + if (typeof this._textOrWidth === 'number') { + this._textOrWidth = this._sourceText.substr(this.start(), this._textOrWidth, this.tokenKind === 11 /* IdentifierName */); + } + + return this._textOrWidth; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () { + if (this._value === undefined) { + this._value = TypeScript.Syntax.value(this); + } + + return this._value; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () { + if (this._valueText === undefined) { + this._valueText = TypeScript.Syntax.valueText(this); + } + + return this._valueText; + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () { + return this; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () { + return this; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + VariableWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return VariableWidthTokenWithLeadingAndTrailingTrivia; + })(); + Syntax.VariableWidthTokenWithLeadingAndTrailingTrivia = VariableWidthTokenWithLeadingAndTrailingTrivia; + + var FixedWidthTokenWithNoTrivia = (function () { + function FixedWidthTokenWithNoTrivia(kind) { + this.tokenKind = kind; + } + FixedWidthTokenWithNoTrivia.prototype.clone = function () { + return new FixedWidthTokenWithNoTrivia(this.tokenKind); + }; + + FixedWidthTokenWithNoTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithNoTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithNoTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithNoTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithNoTrivia.prototype.fullWidth = function () { + return this.width(); + }; + FixedWidthTokenWithNoTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithNoTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithNoTrivia.prototype.fullText = function () { + return this.text(); + }; + + FixedWidthTokenWithNoTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithNoTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingComment = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithNoTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingComment = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithNoTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithNoTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithNoTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithNoTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithNoTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithNoTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithNoTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithNoTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithNoTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithNoTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithNoTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithNoTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithNoTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithNoTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithNoTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithNoTrivia; + })(); + Syntax.FixedWidthTokenWithNoTrivia = FixedWidthTokenWithNoTrivia; + + var FixedWidthTokenWithLeadingTrivia = (function () { + function FixedWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + } + FixedWidthTokenWithLeadingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithLeadingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithLeadingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width(); + }; + FixedWidthTokenWithLeadingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithLeadingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithLeadingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingTrivia = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingComment = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingNewLine = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.trailingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithLeadingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithLeadingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithLeadingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithLeadingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithLeadingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithLeadingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithLeadingTrivia; + })(); + Syntax.FixedWidthTokenWithLeadingTrivia = FixedWidthTokenWithLeadingTrivia; + + var FixedWidthTokenWithTrailingTrivia = (function () { + function FixedWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._trailingTriviaInfo = trailingTriviaInfo; + } + FixedWidthTokenWithTrailingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._trailingTriviaInfo); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.fullWidth = function () { + return this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.start = function () { + return this._fullStart; + }; + FixedWidthTokenWithTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithTrailingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingTrivia = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingComment = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingNewLine = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.leadingTriviaWidth = function () { + return 0; + }; + FixedWidthTokenWithTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithTrailingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithTrailingTrivia; + })(); + Syntax.FixedWidthTokenWithTrailingTrivia = FixedWidthTokenWithTrailingTrivia; + + var FixedWidthTokenWithLeadingAndTrailingTrivia = (function () { + function FixedWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo) { + this._sourceText = sourceText; + this._fullStart = fullStart; + this.tokenKind = kind; + this._leadingTriviaInfo = leadingTriviaInfo; + this._trailingTriviaInfo = trailingTriviaInfo; + } + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.clone = function () { + return new FixedWidthTokenWithLeadingAndTrailingTrivia(this._sourceText, this._fullStart, this.tokenKind, this._leadingTriviaInfo, this._trailingTriviaInfo); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isNode = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isToken = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isList = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isSeparatedList = function () { + return false; + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.kind = function () { + return this.tokenKind; + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childCount = function () { + return 0; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange('index'); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo) + this.width() + getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.start = function () { + return this._fullStart + getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.end = function () { + return this.start() + this.width(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.width = function () { + return this.text().length; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.text = function () { + return TypeScript.SyntaxFacts.getText(this.tokenKind); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.fullText = function () { + return this._sourceText.substr(this._fullStart, this.fullWidth(), false); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.value = function () { + return TypeScript.Syntax.value(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.valueText = function () { + return TypeScript.Syntax.valueText(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingComment = function () { + return hasTriviaComment(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingNewLine = function () { + return hasTriviaNewLine(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasLeadingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTriviaWidth = function () { + return getTriviaWidth(this._leadingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.leadingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this._fullStart, getTriviaWidth(this._leadingTriviaInfo), false); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingTrivia = function () { + return true; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingComment = function () { + return hasTriviaComment(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingNewLine = function () { + return hasTriviaNewLine(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasTrailingSkippedText = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTriviaWidth = function () { + return getTriviaWidth(this._trailingTriviaInfo); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.trailingTrivia = function () { + return TypeScript.Scanner.scanTrivia(this._sourceText, this.end(), getTriviaWidth(this._trailingTriviaInfo), true); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.hasSkippedToken = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.toJSON = function (key) { + return TypeScript.Syntax.tokenToJSON(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.firstToken = function () { + return this; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.lastToken = function () { + return this; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isTypeScriptSpecific = function () { + return false; + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isIncrementallyUnusable = function () { + return this.fullWidth() === 0 || TypeScript.SyntaxFacts.isAnyDivideOrRegularExpressionToken(this.tokenKind); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.realize = function () { + return TypeScript.Syntax.realizeToken(this); + }; + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.collectTextElements = function (elements) { + collectTokenTextElements(this, elements); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isExpression = function () { + return TypeScript.Syntax.isExpression(this); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + FixedWidthTokenWithLeadingAndTrailingTrivia.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return FixedWidthTokenWithLeadingAndTrailingTrivia; + })(); + Syntax.FixedWidthTokenWithLeadingAndTrailingTrivia = FixedWidthTokenWithLeadingAndTrailingTrivia; + + function collectTokenTextElements(token, elements) { + token.leadingTrivia().collectTextElements(elements); + elements.push(token.text()); + token.trailingTrivia().collectTextElements(elements); + } + + function fixedWidthToken(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new FixedWidthTokenWithNoTrivia(kind); + } else { + return new FixedWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new FixedWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo); + } else { + return new FixedWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, trailingTriviaInfo); + } + } + Syntax.fixedWidthToken = fixedWidthToken; + + function variableWidthToken(sourceText, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo) { + if (leadingTriviaInfo === 0) { + if (trailingTriviaInfo === 0) { + return new VariableWidthTokenWithNoTrivia(sourceText, fullStart, kind, width); + } else { + return new VariableWidthTokenWithTrailingTrivia(sourceText, fullStart, kind, width, trailingTriviaInfo); + } + } else if (trailingTriviaInfo === 0) { + return new VariableWidthTokenWithLeadingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, width); + } else { + return new VariableWidthTokenWithLeadingAndTrailingTrivia(sourceText, fullStart, kind, leadingTriviaInfo, width, trailingTriviaInfo); + } + } + Syntax.variableWidthToken = variableWidthToken; + + function getTriviaWidth(value) { + return value >>> 2 /* TriviaFullWidthShift */; + } + + function hasTriviaComment(value) { + return (value & 2 /* TriviaCommentMask */) !== 0; + } + + function hasTriviaNewLine(value) { + return (value & 1 /* TriviaNewLineMask */) !== 0; + } + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + function isExpression(token) { + switch (token.tokenKind) { + case 11 /* IdentifierName */: + case 12 /* RegularExpressionLiteral */: + case 13 /* NumericLiteral */: + case 14 /* StringLiteral */: + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 50 /* SuperKeyword */: + return true; + } + + return false; + } + Syntax.isExpression = isExpression; + + function realizeToken(token) { + return new RealizedToken(token.tokenKind, token.leadingTrivia(), token.text(), token.value(), token.valueText(), token.trailingTrivia()); + } + Syntax.realizeToken = realizeToken; + + function convertToIdentifierName(token) { + TypeScript.Debug.assert(TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)); + return new RealizedToken(11 /* IdentifierName */, token.leadingTrivia(), token.text(), token.text(), token.text(), token.trailingTrivia()); + } + Syntax.convertToIdentifierName = convertToIdentifierName; + + function tokenToJSON(token) { + var result = {}; + + for (var name in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind[name] === token.kind()) { + result.kind = name; + break; + } + } + + result.width = token.width(); + if (token.fullWidth() !== token.width()) { + result.fullWidth = token.fullWidth(); + } + + result.text = token.text(); + + var value = token.value(); + if (value !== null) { + result.value = value; + result.valueText = token.valueText(); + } + + if (token.hasLeadingTrivia()) { + result.hasLeadingTrivia = true; + } + + if (token.hasLeadingComment()) { + result.hasLeadingComment = true; + } + + if (token.hasLeadingNewLine()) { + result.hasLeadingNewLine = true; + } + + if (token.hasLeadingSkippedText()) { + result.hasLeadingSkippedText = true; + } + + if (token.hasTrailingTrivia()) { + result.hasTrailingTrivia = true; + } + + if (token.hasTrailingComment()) { + result.hasTrailingComment = true; + } + + if (token.hasTrailingNewLine()) { + result.hasTrailingNewLine = true; + } + + if (token.hasTrailingSkippedText()) { + result.hasTrailingSkippedText = true; + } + + var trivia = token.leadingTrivia(); + if (trivia.count() > 0) { + result.leadingTrivia = trivia; + } + + trivia = token.trailingTrivia(); + if (trivia.count() > 0) { + result.trailingTrivia = trivia; + } + + return result; + } + Syntax.tokenToJSON = tokenToJSON; + + function value(token) { + return value1(token.tokenKind, token.text()); + } + Syntax.value = value; + + function hexValue(text, start, length) { + var intChar = 0; + for (var i = 0; i < length; i++) { + var ch2 = text.charCodeAt(start + i); + if (!TypeScript.CharacterInfo.isHexDigit(ch2)) { + break; + } + + intChar = (intChar << 4) + TypeScript.CharacterInfo.hexValue(ch2); + } + + return intChar; + } + + var characterArray = []; + + function convertEscapes(text) { + characterArray.length = 0; + var result = ""; + + for (var i = 0, n = text.length; i < n; i++) { + var ch = text.charCodeAt(i); + + if (ch === 92 /* backslash */) { + i++; + if (i < n) { + ch = text.charCodeAt(i); + switch (ch) { + case 48 /* _0 */: + characterArray.push(0 /* nullCharacter */); + continue; + + case 98 /* b */: + characterArray.push(8 /* backspace */); + continue; + + case 102 /* f */: + characterArray.push(12 /* formFeed */); + continue; + + case 110 /* n */: + characterArray.push(10 /* lineFeed */); + continue; + + case 114 /* r */: + characterArray.push(13 /* carriageReturn */); + continue; + + case 116 /* t */: + characterArray.push(9 /* tab */); + continue; + + case 118 /* v */: + characterArray.push(11 /* verticalTab */); + continue; + + case 120 /* x */: + characterArray.push(hexValue(text, i + 1, 2)); + i += 2; + continue; + + case 117 /* u */: + characterArray.push(hexValue(text, i + 1, 4)); + i += 4; + continue; + + case 13 /* carriageReturn */: + var nextIndex = i + 1; + if (nextIndex < text.length && text.charCodeAt(nextIndex) == 10 /* lineFeed */) { + i++; + } + continue; + + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + continue; + + default: + } + } + } + + characterArray.push(ch); + + if (i && !(i % 1024)) { + result = result.concat(String.fromCharCode.apply(null, characterArray)); + characterArray.length = 0; + } + } + + if (characterArray.length) { + result = result.concat(String.fromCharCode.apply(null, characterArray)); + } + + return result; + } + + function massageEscapes(text) { + return text.indexOf("\\") >= 0 ? convertEscapes(text) : text; + } + Syntax.massageEscapes = massageEscapes; + + function value1(kind, text) { + if (kind === 11 /* IdentifierName */) { + return massageEscapes(text); + } + + switch (kind) { + case 37 /* TrueKeyword */: + return true; + case 24 /* FalseKeyword */: + return false; + case 32 /* NullKeyword */: + return null; + } + + if (TypeScript.SyntaxFacts.isAnyKeyword(kind) || TypeScript.SyntaxFacts.isAnyPunctuation(kind)) { + return TypeScript.SyntaxFacts.getText(kind); + } + + if (kind === 13 /* NumericLiteral */) { + return TypeScript.IntegerUtilities.isHexInteger(text) ? parseInt(text, 16) : parseFloat(text); + } else if (kind === 14 /* StringLiteral */) { + if (text.length > 1 && text.charCodeAt(text.length - 1) === text.charCodeAt(0)) { + return massageEscapes(text.substr(1, text.length - 2)); + } else { + return massageEscapes(text.substr(1)); + } + } else if (kind === 12 /* RegularExpressionLiteral */) { + return regularExpressionValue(text); + } else if (kind === 10 /* EndOfFileToken */ || kind === 9 /* ErrorToken */) { + return null; + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + + function regularExpressionValue(text) { + try { + var lastSlash = text.lastIndexOf("/"); + var body = text.substring(1, lastSlash); + var flags = text.substring(lastSlash + 1); + return new RegExp(body, flags); + } catch (e) { + return null; + } + } + + function valueText1(kind, text) { + var value = value1(kind, text); + return value === null ? "" : value.toString(); + } + + function valueText(token) { + var value = token.value(); + return value === null ? "" : value.toString(); + } + Syntax.valueText = valueText; + + var EmptyToken = (function () { + function EmptyToken(kind) { + this.tokenKind = kind; + } + EmptyToken.prototype.clone = function () { + return new EmptyToken(this.tokenKind); + }; + + EmptyToken.prototype.kind = function () { + return this.tokenKind; + }; + + EmptyToken.prototype.isToken = function () { + return true; + }; + EmptyToken.prototype.isNode = function () { + return false; + }; + EmptyToken.prototype.isList = function () { + return false; + }; + EmptyToken.prototype.isSeparatedList = function () { + return false; + }; + + EmptyToken.prototype.childCount = function () { + return 0; + }; + + EmptyToken.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + EmptyToken.prototype.toJSON = function (key) { + return tokenToJSON(this); + }; + EmptyToken.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + + EmptyToken.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + EmptyToken.prototype.firstToken = function () { + return this; + }; + EmptyToken.prototype.lastToken = function () { + return this; + }; + EmptyToken.prototype.isTypeScriptSpecific = function () { + return false; + }; + + EmptyToken.prototype.isIncrementallyUnusable = function () { + return true; + }; + + EmptyToken.prototype.fullWidth = function () { + return 0; + }; + EmptyToken.prototype.width = function () { + return 0; + }; + EmptyToken.prototype.text = function () { + return ""; + }; + EmptyToken.prototype.fullText = function () { + return ""; + }; + EmptyToken.prototype.value = function () { + return null; + }; + EmptyToken.prototype.valueText = function () { + return ""; + }; + + EmptyToken.prototype.hasLeadingTrivia = function () { + return false; + }; + EmptyToken.prototype.hasLeadingComment = function () { + return false; + }; + EmptyToken.prototype.hasLeadingNewLine = function () { + return false; + }; + EmptyToken.prototype.hasLeadingSkippedText = function () { + return false; + }; + EmptyToken.prototype.leadingTriviaWidth = function () { + return 0; + }; + EmptyToken.prototype.hasTrailingTrivia = function () { + return false; + }; + EmptyToken.prototype.hasTrailingComment = function () { + return false; + }; + EmptyToken.prototype.hasTrailingNewLine = function () { + return false; + }; + EmptyToken.prototype.hasTrailingSkippedText = function () { + return false; + }; + EmptyToken.prototype.hasSkippedToken = function () { + return false; + }; + + EmptyToken.prototype.trailingTriviaWidth = function () { + return 0; + }; + EmptyToken.prototype.leadingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + EmptyToken.prototype.trailingTrivia = function () { + return TypeScript.Syntax.emptyTriviaList; + }; + EmptyToken.prototype.realize = function () { + return realizeToken(this); + }; + EmptyToken.prototype.collectTextElements = function (elements) { + }; + + EmptyToken.prototype.withLeadingTrivia = function (leadingTrivia) { + return this.realize().withLeadingTrivia(leadingTrivia); + }; + + EmptyToken.prototype.withTrailingTrivia = function (trailingTrivia) { + return this.realize().withTrailingTrivia(trailingTrivia); + }; + + EmptyToken.prototype.isExpression = function () { + return isExpression(this); + }; + + EmptyToken.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + EmptyToken.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return EmptyToken; + })(); + + function emptyToken(kind) { + return new EmptyToken(kind); + } + Syntax.emptyToken = emptyToken; + + var RealizedToken = (function () { + function RealizedToken(tokenKind, leadingTrivia, text, value, valueText, trailingTrivia) { + this.tokenKind = tokenKind; + this._leadingTrivia = leadingTrivia; + this._text = text; + this._value = value; + this._valueText = valueText; + this._trailingTrivia = trailingTrivia; + } + RealizedToken.prototype.clone = function () { + return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia); + }; + + RealizedToken.prototype.kind = function () { + return this.tokenKind; + }; + RealizedToken.prototype.toJSON = function (key) { + return tokenToJSON(this); + }; + RealizedToken.prototype.firstToken = function () { + return this; + }; + RealizedToken.prototype.lastToken = function () { + return this; + }; + RealizedToken.prototype.isTypeScriptSpecific = function () { + return false; + }; + + RealizedToken.prototype.isIncrementallyUnusable = function () { + return true; + }; + + RealizedToken.prototype.accept = function (visitor) { + return visitor.visitToken(this); + }; + + RealizedToken.prototype.childCount = function () { + return 0; + }; + + RealizedToken.prototype.childAt = function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }; + + RealizedToken.prototype.isToken = function () { + return true; + }; + RealizedToken.prototype.isNode = function () { + return false; + }; + RealizedToken.prototype.isList = function () { + return false; + }; + RealizedToken.prototype.isSeparatedList = function () { + return false; + }; + RealizedToken.prototype.isTrivia = function () { + return false; + }; + RealizedToken.prototype.isTriviaList = function () { + return false; + }; + + RealizedToken.prototype.fullWidth = function () { + return this._leadingTrivia.fullWidth() + this.width() + this._trailingTrivia.fullWidth(); + }; + RealizedToken.prototype.width = function () { + return this.text().length; + }; + + RealizedToken.prototype.text = function () { + return this._text; + }; + RealizedToken.prototype.fullText = function () { + return this._leadingTrivia.fullText() + this.text() + this._trailingTrivia.fullText(); + }; + + RealizedToken.prototype.value = function () { + return this._value; + }; + RealizedToken.prototype.valueText = function () { + return this._valueText; + }; + + RealizedToken.prototype.hasLeadingTrivia = function () { + return this._leadingTrivia.count() > 0; + }; + RealizedToken.prototype.hasLeadingComment = function () { + return this._leadingTrivia.hasComment(); + }; + RealizedToken.prototype.hasLeadingNewLine = function () { + return this._leadingTrivia.hasNewLine(); + }; + RealizedToken.prototype.hasLeadingSkippedText = function () { + return this._leadingTrivia.hasSkippedToken(); + }; + RealizedToken.prototype.leadingTriviaWidth = function () { + return this._leadingTrivia.fullWidth(); + }; + + RealizedToken.prototype.hasTrailingTrivia = function () { + return this._trailingTrivia.count() > 0; + }; + RealizedToken.prototype.hasTrailingComment = function () { + return this._trailingTrivia.hasComment(); + }; + RealizedToken.prototype.hasTrailingNewLine = function () { + return this._trailingTrivia.hasNewLine(); + }; + RealizedToken.prototype.hasTrailingSkippedText = function () { + return this._trailingTrivia.hasSkippedToken(); + }; + RealizedToken.prototype.trailingTriviaWidth = function () { + return this._trailingTrivia.fullWidth(); + }; + + RealizedToken.prototype.hasSkippedToken = function () { + return this.hasLeadingSkippedText() || this.hasTrailingSkippedText(); + }; + + RealizedToken.prototype.leadingTrivia = function () { + return this._leadingTrivia; + }; + RealizedToken.prototype.trailingTrivia = function () { + return this._trailingTrivia; + }; + + RealizedToken.prototype.findTokenInternal = function (parent, position, fullStart) { + return new TypeScript.PositionedToken(parent, this, fullStart); + }; + + RealizedToken.prototype.collectTextElements = function (elements) { + this.leadingTrivia().collectTextElements(elements); + elements.push(this.text()); + this.trailingTrivia().collectTextElements(elements); + }; + + RealizedToken.prototype.withLeadingTrivia = function (leadingTrivia) { + return new RealizedToken(this.tokenKind, leadingTrivia, this._text, this._value, this._valueText, this._trailingTrivia); + }; + + RealizedToken.prototype.withTrailingTrivia = function (trailingTrivia) { + return new RealizedToken(this.tokenKind, this._leadingTrivia, this._text, this._value, this._valueText, trailingTrivia); + }; + + RealizedToken.prototype.isExpression = function () { + return isExpression(this); + }; + + RealizedToken.prototype.isPrimaryExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isMemberExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isPostfixExpression = function () { + return this.isExpression(); + }; + + RealizedToken.prototype.isUnaryExpression = function () { + return this.isExpression(); + }; + return RealizedToken; + })(); + + function token(kind, info) { + if (typeof info === "undefined") { info = null; } + var text = (info !== null && info.text !== undefined) ? info.text : TypeScript.SyntaxFacts.getText(kind); + + return new RealizedToken(kind, TypeScript.Syntax.triviaList(info === null ? null : info.leadingTrivia), text, value1(kind, text), valueText1(kind, text), TypeScript.Syntax.triviaList(info === null ? null : info.trailingTrivia)); + } + Syntax.token = token; + + function identifier(text, info) { + if (typeof info === "undefined") { info = null; } + info = info || {}; + info.text = text; + return token(11 /* IdentifierName */, info); + } + Syntax.identifier = identifier; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTokenReplacer = (function (_super) { + __extends(SyntaxTokenReplacer, _super); + function SyntaxTokenReplacer(token1, token2) { + _super.call(this); + this.token1 = token1; + this.token2 = token2; + } + SyntaxTokenReplacer.prototype.visitToken = function (token) { + if (token === this.token1) { + var result = this.token2; + this.token1 = null; + this.token2 = null; + + return result; + } + + return token; + }; + + SyntaxTokenReplacer.prototype.visitNode = function (node) { + if (this.token1 === null) { + return node; + } + + return _super.prototype.visitNode.call(this, node); + }; + + SyntaxTokenReplacer.prototype.visitList = function (list) { + if (this.token1 === null) { + return list; + } + + return _super.prototype.visitList.call(this, list); + }; + + SyntaxTokenReplacer.prototype.visitSeparatedList = function (list) { + if (this.token1 === null) { + return list; + } + + return _super.prototype.visitSeparatedList.call(this, list); + }; + return SyntaxTokenReplacer; + })(TypeScript.SyntaxRewriter); + TypeScript.SyntaxTokenReplacer = SyntaxTokenReplacer; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + var AbstractTrivia = (function () { + function AbstractTrivia(_kind) { + this._kind = _kind; + } + AbstractTrivia.prototype.fullWidth = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.fullText = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.abstract(); + }; + + AbstractTrivia.prototype.toJSON = function (key) { + var result = {}; + + for (var name in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind[name] === this._kind) { + result.kind = name; + break; + } + } + + if (this.isSkippedToken()) { + result.skippedToken = this.skippedToken(); + } else { + result.text = this.fullText(); + } + return result; + }; + + AbstractTrivia.prototype.kind = function () { + return this._kind; + }; + + AbstractTrivia.prototype.isWhitespace = function () { + return this.kind() === 4 /* WhitespaceTrivia */; + }; + + AbstractTrivia.prototype.isComment = function () { + return this.kind() === 7 /* SingleLineCommentTrivia */ || this.kind() === 6 /* MultiLineCommentTrivia */; + }; + + AbstractTrivia.prototype.isNewLine = function () { + return this.kind() === 5 /* NewLineTrivia */; + }; + + AbstractTrivia.prototype.isSkippedToken = function () { + return this.kind() === 8 /* SkippedTokenTrivia */; + }; + + AbstractTrivia.prototype.collectTextElements = function (elements) { + elements.push(this.fullText()); + }; + return AbstractTrivia; + })(); + + var NormalTrivia = (function (_super) { + __extends(NormalTrivia, _super); + function NormalTrivia(kind, _text) { + _super.call(this, kind); + this._text = _text; + } + NormalTrivia.prototype.fullWidth = function () { + return this.fullText().length; + }; + + NormalTrivia.prototype.fullText = function () { + return this._text; + }; + + NormalTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.invalidOperation(); + }; + return NormalTrivia; + })(AbstractTrivia); + + var SkippedTokenTrivia = (function (_super) { + __extends(SkippedTokenTrivia, _super); + function SkippedTokenTrivia(_skippedToken) { + _super.call(this, 8 /* SkippedTokenTrivia */); + this._skippedToken = _skippedToken; + } + SkippedTokenTrivia.prototype.fullWidth = function () { + return this.fullText().length; + }; + + SkippedTokenTrivia.prototype.fullText = function () { + return this.skippedToken().fullText(); + }; + + SkippedTokenTrivia.prototype.skippedToken = function () { + return this._skippedToken; + }; + return SkippedTokenTrivia; + })(AbstractTrivia); + + var DeferredTrivia = (function (_super) { + __extends(DeferredTrivia, _super); + function DeferredTrivia(kind, _text, _fullStart, _fullWidth) { + _super.call(this, kind); + this._text = _text; + this._fullStart = _fullStart; + this._fullWidth = _fullWidth; + this._fullText = null; + } + DeferredTrivia.prototype.fullWidth = function () { + return this._fullWidth; + }; + + DeferredTrivia.prototype.fullText = function () { + if (!this._fullText) { + this._fullText = this._text.substr(this._fullStart, this._fullWidth, false); + this._text = null; + } + + return this._fullText; + }; + + DeferredTrivia.prototype.skippedToken = function () { + throw TypeScript.Errors.invalidOperation(); + }; + return DeferredTrivia; + })(AbstractTrivia); + + function deferredTrivia(kind, text, fullStart, fullWidth) { + return new DeferredTrivia(kind, text, fullStart, fullWidth); + } + Syntax.deferredTrivia = deferredTrivia; + + function trivia(kind, text) { + return new NormalTrivia(kind, text); + } + Syntax.trivia = trivia; + + function skippedTokenTrivia(token) { + TypeScript.Debug.assert(!token.hasLeadingTrivia()); + TypeScript.Debug.assert(!token.hasTrailingTrivia()); + TypeScript.Debug.assert(token.fullWidth() > 0); + return new SkippedTokenTrivia(token); + } + Syntax.skippedTokenTrivia = skippedTokenTrivia; + + function spaces(count) { + return trivia(4 /* WhitespaceTrivia */, TypeScript.StringUtilities.repeat(" ", count)); + } + Syntax.spaces = spaces; + + function whitespace(text) { + return trivia(4 /* WhitespaceTrivia */, text); + } + Syntax.whitespace = whitespace; + + function multiLineComment(text) { + return trivia(6 /* MultiLineCommentTrivia */, text); + } + Syntax.multiLineComment = multiLineComment; + + function singleLineComment(text) { + return trivia(7 /* SingleLineCommentTrivia */, text); + } + Syntax.singleLineComment = singleLineComment; + + Syntax.spaceTrivia = spaces(1); + Syntax.lineFeedTrivia = trivia(5 /* NewLineTrivia */, "\n"); + Syntax.carriageReturnTrivia = trivia(5 /* NewLineTrivia */, "\r"); + Syntax.carriageReturnLineFeedTrivia = trivia(5 /* NewLineTrivia */, "\r\n"); + + function splitMultiLineCommentTriviaIntoMultipleLines(trivia) { + var result = []; + + var triviaText = trivia.fullText(); + var currentIndex = 0; + + for (var i = 0; i < triviaText.length; i++) { + var ch = triviaText.charCodeAt(i); + + var isCarriageReturnLineFeed = false; + switch (ch) { + case 13 /* carriageReturn */: + if (i < triviaText.length - 1 && triviaText.charCodeAt(i + 1) === 10 /* lineFeed */) { + i++; + } + + case 10 /* lineFeed */: + case 8233 /* paragraphSeparator */: + case 8232 /* lineSeparator */: + result.push(triviaText.substring(currentIndex, i + 1)); + + currentIndex = i + 1; + continue; + } + } + + result.push(triviaText.substring(currentIndex)); + return result; + } + Syntax.splitMultiLineCommentTriviaIntoMultipleLines = splitMultiLineCommentTriviaIntoMultipleLines; + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); + +var TypeScript; +(function (TypeScript) { + (function (Syntax) { + Syntax.emptyTriviaList = { + kind: function () { + return 3 /* TriviaList */; + }, + count: function () { + return 0; + }, + syntaxTriviaAt: function (index) { + throw TypeScript.Errors.argumentOutOfRange("index"); + }, + last: function () { + throw TypeScript.Errors.argumentOutOfRange("index"); + }, + fullWidth: function () { + return 0; + }, + fullText: function () { + return ""; + }, + hasComment: function () { + return false; + }, + hasNewLine: function () { + return false; + }, + hasSkippedToken: function () { + return false; + }, + toJSON: function (key) { + return []; + }, + collectTextElements: function (elements) { + }, + toArray: function () { + return []; + }, + concat: function (trivia) { + return trivia; + } + }; + + function concatTrivia(list1, list2) { + if (list1.count() === 0) { + return list2; + } + + if (list2.count() === 0) { + return list1; + } + + var trivia = list1.toArray(); + trivia.push.apply(trivia, list2.toArray()); + + return triviaList(trivia); + } + + function isComment(trivia) { + return trivia.kind() === 6 /* MultiLineCommentTrivia */ || trivia.kind() === 7 /* SingleLineCommentTrivia */; + } + + var SingletonSyntaxTriviaList = (function () { + function SingletonSyntaxTriviaList(item) { + this.item = item; + } + SingletonSyntaxTriviaList.prototype.kind = function () { + return 3 /* TriviaList */; + }; + + SingletonSyntaxTriviaList.prototype.count = function () { + return 1; + }; + + SingletonSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) { + if (index !== 0) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.item; + }; + + SingletonSyntaxTriviaList.prototype.last = function () { + return this.item; + }; + + SingletonSyntaxTriviaList.prototype.fullWidth = function () { + return this.item.fullWidth(); + }; + + SingletonSyntaxTriviaList.prototype.fullText = function () { + return this.item.fullText(); + }; + + SingletonSyntaxTriviaList.prototype.hasComment = function () { + return isComment(this.item); + }; + + SingletonSyntaxTriviaList.prototype.hasNewLine = function () { + return this.item.kind() === 5 /* NewLineTrivia */; + }; + + SingletonSyntaxTriviaList.prototype.hasSkippedToken = function () { + return this.item.kind() === 8 /* SkippedTokenTrivia */; + }; + + SingletonSyntaxTriviaList.prototype.toJSON = function (key) { + return [this.item]; + }; + + SingletonSyntaxTriviaList.prototype.collectTextElements = function (elements) { + this.item.collectTextElements(elements); + }; + + SingletonSyntaxTriviaList.prototype.toArray = function () { + return [this.item]; + }; + + SingletonSyntaxTriviaList.prototype.concat = function (trivia) { + return concatTrivia(this, trivia); + }; + return SingletonSyntaxTriviaList; + })(); + + var NormalSyntaxTriviaList = (function () { + function NormalSyntaxTriviaList(trivia) { + this.trivia = trivia; + } + NormalSyntaxTriviaList.prototype.kind = function () { + return 3 /* TriviaList */; + }; + + NormalSyntaxTriviaList.prototype.count = function () { + return this.trivia.length; + }; + + NormalSyntaxTriviaList.prototype.syntaxTriviaAt = function (index) { + if (index < 0 || index >= this.trivia.length) { + throw TypeScript.Errors.argumentOutOfRange("index"); + } + + return this.trivia[index]; + }; + + NormalSyntaxTriviaList.prototype.last = function () { + return this.trivia[this.trivia.length - 1]; + }; + + NormalSyntaxTriviaList.prototype.fullWidth = function () { + return TypeScript.ArrayUtilities.sum(this.trivia, function (t) { + return t.fullWidth(); + }); + }; + + NormalSyntaxTriviaList.prototype.fullText = function () { + var result = ""; + + for (var i = 0, n = this.trivia.length; i < n; i++) { + result += this.trivia[i].fullText(); + } + + return result; + }; + + NormalSyntaxTriviaList.prototype.hasComment = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (isComment(this.trivia[i])) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.hasNewLine = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (this.trivia[i].kind() === 5 /* NewLineTrivia */) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.hasSkippedToken = function () { + for (var i = 0; i < this.trivia.length; i++) { + if (this.trivia[i].kind() === 8 /* SkippedTokenTrivia */) { + return true; + } + } + + return false; + }; + + NormalSyntaxTriviaList.prototype.toJSON = function (key) { + return this.trivia; + }; + + NormalSyntaxTriviaList.prototype.collectTextElements = function (elements) { + for (var i = 0; i < this.trivia.length; i++) { + this.trivia[i].collectTextElements(elements); + } + }; + + NormalSyntaxTriviaList.prototype.toArray = function () { + return this.trivia.slice(0); + }; + + NormalSyntaxTriviaList.prototype.concat = function (trivia) { + return concatTrivia(this, trivia); + }; + return NormalSyntaxTriviaList; + })(); + + function triviaList(trivia) { + if (trivia === undefined || trivia === null || trivia.length === 0) { + return Syntax.emptyTriviaList; + } + + if (trivia.length === 1) { + return new SingletonSyntaxTriviaList(trivia[0]); + } + + return new NormalSyntaxTriviaList(trivia); + } + Syntax.triviaList = triviaList; + + Syntax.spaceTriviaList = triviaList([TypeScript.Syntax.spaceTrivia]); + })(TypeScript.Syntax || (TypeScript.Syntax = {})); + var Syntax = TypeScript.Syntax; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxUtilities = (function () { + function SyntaxUtilities() { + } + SyntaxUtilities.isAngleBracket = function (positionedElement) { + var element = positionedElement.element(); + var parent = positionedElement.parentElement(); + if (parent !== null && (element.kind() === 80 /* LessThanToken */ || element.kind() === 81 /* GreaterThanToken */)) { + switch (parent.kind()) { + case 228 /* TypeArgumentList */: + case 229 /* TypeParameterList */: + case 220 /* CastExpression */: + return true; + } + } + + return false; + }; + + SyntaxUtilities.getToken = function (list, kind) { + for (var i = 0, n = list.childCount(); i < n; i++) { + var token = list.childAt(i); + if (token.tokenKind === kind) { + return token; + } + } + + return null; + }; + + SyntaxUtilities.containsToken = function (list, kind) { + return SyntaxUtilities.getToken(list, kind) !== null; + }; + + SyntaxUtilities.hasExportKeyword = function (moduleElement) { + return SyntaxUtilities.getExportKeyword(moduleElement) !== null; + }; + + SyntaxUtilities.getExportKeyword = function (moduleElement) { + switch (moduleElement.kind()) { + case 130 /* ModuleDeclaration */: + case 131 /* ClassDeclaration */: + case 129 /* FunctionDeclaration */: + case 148 /* VariableStatement */: + case 132 /* EnumDeclaration */: + case 128 /* InterfaceDeclaration */: + case 133 /* ImportDeclaration */: + return SyntaxUtilities.getToken(moduleElement.modifiers, 47 /* ExportKeyword */); + default: + return null; + } + }; + + SyntaxUtilities.isAmbientDeclarationSyntax = function (positionNode) { + if (!positionNode) { + return false; + } + + var node = positionNode.node(); + switch (node.kind()) { + case 130 /* ModuleDeclaration */: + case 131 /* ClassDeclaration */: + case 129 /* FunctionDeclaration */: + case 148 /* VariableStatement */: + case 132 /* EnumDeclaration */: + if (SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + return true; + } + + case 133 /* ImportDeclaration */: + case 137 /* ConstructorDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + case 136 /* MemberVariableDeclaration */: + if (node.isClassElement() || node.isModuleElement()) { + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode()); + } + + case 243 /* EnumElement */: + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode().containingNode()); + + default: + return SyntaxUtilities.isAmbientDeclarationSyntax(positionNode.containingNode()); + } + }; + return SyntaxUtilities; + })(); + TypeScript.SyntaxUtilities = SyntaxUtilities; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxVisitor = (function () { + function SyntaxVisitor() { + } + SyntaxVisitor.prototype.defaultVisit = function (node) { + return null; + }; + + SyntaxVisitor.prototype.visitToken = function (token) { + return this.defaultVisit(token); + }; + + SyntaxVisitor.prototype.visitSourceUnit = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExternalModuleReference = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitModuleNameModuleReference = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitImportDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExportAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitClassDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitInterfaceDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitHeritageClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitModuleDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVariableDeclarator = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEqualsValueClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPrefixUnaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArrayLiteralExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitOmittedExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParenthesizedExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitQualifiedName = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeArgumentList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructorType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArrayType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitGenericType = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeQuery = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeAnnotation = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBlock = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParameter = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberAccessExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPostfixUnaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitElementAccessExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitInvocationExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitArgumentList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBinaryExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConditionalExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMethodSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIndexSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitPropertySignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCallSignature = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitParameterList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeParameterList = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeParameter = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstraint = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitElseClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIfStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitExpressionStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitConstructorDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitGetAccessor = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSetAccessor = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitMemberVariableDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitIndexMemberDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitThrowStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitReturnStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectCreationExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSwitchStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCaseSwitchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDefaultSwitchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitBreakStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitContinueStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitForStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitForInStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitWhileStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitWithStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEnumDeclaration = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEnumElement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCastExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitObjectLiteralExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitSimplePropertyAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFunctionExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitEmptyStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTryStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitCatchClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitFinallyClause = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitLabeledStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDoStatement = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitTypeOfExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDeleteExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitVoidExpression = function (node) { + return this.defaultVisit(node); + }; + + SyntaxVisitor.prototype.visitDebuggerStatement = function (node) { + return this.defaultVisit(node); + }; + return SyntaxVisitor; + })(); + TypeScript.SyntaxVisitor = SyntaxVisitor; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxWalker = (function () { + function SyntaxWalker() { + } + SyntaxWalker.prototype.visitToken = function (token) { + }; + + SyntaxWalker.prototype.visitNode = function (node) { + node.accept(this); + }; + + SyntaxWalker.prototype.visitNodeOrToken = function (nodeOrToken) { + if (nodeOrToken.isToken()) { + this.visitToken(nodeOrToken); + } else { + this.visitNode(nodeOrToken); + } + }; + + SyntaxWalker.prototype.visitOptionalToken = function (token) { + if (token === null) { + return; + } + + this.visitToken(token); + }; + + SyntaxWalker.prototype.visitOptionalNode = function (node) { + if (node === null) { + return; + } + + this.visitNode(node); + }; + + SyntaxWalker.prototype.visitOptionalNodeOrToken = function (nodeOrToken) { + if (nodeOrToken === null) { + return; + } + + this.visitNodeOrToken(nodeOrToken); + }; + + SyntaxWalker.prototype.visitList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + this.visitNodeOrToken(list.childAt(i)); + } + }; + + SyntaxWalker.prototype.visitSeparatedList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + var item = list.childAt(i); + this.visitNodeOrToken(item); + } + }; + + SyntaxWalker.prototype.visitSourceUnit = function (node) { + this.visitList(node.moduleElements); + this.visitToken(node.endOfFileToken); + }; + + SyntaxWalker.prototype.visitExternalModuleReference = function (node) { + this.visitToken(node.requireKeyword); + this.visitToken(node.openParenToken); + this.visitToken(node.stringLiteral); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitModuleNameModuleReference = function (node) { + this.visitNodeOrToken(node.moduleName); + }; + + SyntaxWalker.prototype.visitImportDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.importKeyword); + this.visitToken(node.identifier); + this.visitToken(node.equalsToken); + this.visitNodeOrToken(node.moduleReference); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitExportAssignment = function (node) { + this.visitToken(node.exportKeyword); + this.visitToken(node.equalsToken); + this.visitToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitClassDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.classKeyword); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeParameterList); + this.visitList(node.heritageClauses); + this.visitToken(node.openBraceToken); + this.visitList(node.classElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitInterfaceDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.interfaceKeyword); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeParameterList); + this.visitList(node.heritageClauses); + this.visitNode(node.body); + }; + + SyntaxWalker.prototype.visitHeritageClause = function (node) { + this.visitToken(node.extendsOrImplementsKeyword); + this.visitSeparatedList(node.typeNames); + }; + + SyntaxWalker.prototype.visitModuleDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.moduleKeyword); + this.visitOptionalNodeOrToken(node.name); + this.visitOptionalToken(node.stringLiteral); + this.visitToken(node.openBraceToken); + this.visitList(node.moduleElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitFunctionDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.functionKeyword); + this.visitToken(node.identifier); + this.visitNode(node.callSignature); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitVariableStatement = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.variableDeclaration); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitVariableDeclaration = function (node) { + this.visitToken(node.varKeyword); + this.visitSeparatedList(node.variableDeclarators); + }; + + SyntaxWalker.prototype.visitVariableDeclarator = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalNode(node.typeAnnotation); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitEqualsValueClause = function (node) { + this.visitToken(node.equalsToken); + this.visitNodeOrToken(node.value); + }; + + SyntaxWalker.prototype.visitPrefixUnaryExpression = function (node) { + this.visitToken(node.operatorToken); + this.visitNodeOrToken(node.operand); + }; + + SyntaxWalker.prototype.visitArrayLiteralExpression = function (node) { + this.visitToken(node.openBracketToken); + this.visitSeparatedList(node.expressions); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitOmittedExpression = function (node) { + }; + + SyntaxWalker.prototype.visitParenthesizedExpression = function (node) { + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitSimpleArrowFunctionExpression = function (node) { + this.visitToken(node.identifier); + this.visitToken(node.equalsGreaterThanToken); + this.visitOptionalNode(node.block); + this.visitOptionalNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + this.visitNode(node.callSignature); + this.visitToken(node.equalsGreaterThanToken); + this.visitOptionalNode(node.block); + this.visitOptionalNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitQualifiedName = function (node) { + this.visitNodeOrToken(node.left); + this.visitToken(node.dotToken); + this.visitToken(node.right); + }; + + SyntaxWalker.prototype.visitTypeArgumentList = function (node) { + this.visitToken(node.lessThanToken); + this.visitSeparatedList(node.typeArguments); + this.visitToken(node.greaterThanToken); + }; + + SyntaxWalker.prototype.visitConstructorType = function (node) { + this.visitToken(node.newKeyword); + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitToken(node.equalsGreaterThanToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitFunctionType = function (node) { + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitToken(node.equalsGreaterThanToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitObjectType = function (node) { + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.typeMembers); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitArrayType = function (node) { + this.visitNodeOrToken(node.type); + this.visitToken(node.openBracketToken); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitGenericType = function (node) { + this.visitNodeOrToken(node.name); + this.visitNode(node.typeArgumentList); + }; + + SyntaxWalker.prototype.visitTypeQuery = function (node) { + this.visitToken(node.typeOfKeyword); + this.visitNodeOrToken(node.name); + }; + + SyntaxWalker.prototype.visitTypeAnnotation = function (node) { + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitBlock = function (node) { + this.visitToken(node.openBraceToken); + this.visitList(node.statements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitParameter = function (node) { + this.visitOptionalToken(node.dotDotDotToken); + this.visitList(node.modifiers); + this.visitToken(node.identifier); + this.visitOptionalToken(node.questionToken); + this.visitOptionalNode(node.typeAnnotation); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitMemberAccessExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.dotToken); + this.visitToken(node.name); + }; + + SyntaxWalker.prototype.visitPostfixUnaryExpression = function (node) { + this.visitNodeOrToken(node.operand); + this.visitToken(node.operatorToken); + }; + + SyntaxWalker.prototype.visitElementAccessExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.openBracketToken); + this.visitNodeOrToken(node.argumentExpression); + this.visitToken(node.closeBracketToken); + }; + + SyntaxWalker.prototype.visitInvocationExpression = function (node) { + this.visitNodeOrToken(node.expression); + this.visitNode(node.argumentList); + }; + + SyntaxWalker.prototype.visitArgumentList = function (node) { + this.visitOptionalNode(node.typeArgumentList); + this.visitToken(node.openParenToken); + this.visitSeparatedList(node.arguments); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitBinaryExpression = function (node) { + this.visitNodeOrToken(node.left); + this.visitToken(node.operatorToken); + this.visitNodeOrToken(node.right); + }; + + SyntaxWalker.prototype.visitConditionalExpression = function (node) { + this.visitNodeOrToken(node.condition); + this.visitToken(node.questionToken); + this.visitNodeOrToken(node.whenTrue); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.whenFalse); + }; + + SyntaxWalker.prototype.visitConstructSignature = function (node) { + this.visitToken(node.newKeyword); + this.visitNode(node.callSignature); + }; + + SyntaxWalker.prototype.visitMethodSignature = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalToken(node.questionToken); + this.visitNode(node.callSignature); + }; + + SyntaxWalker.prototype.visitIndexSignature = function (node) { + this.visitToken(node.openBracketToken); + this.visitNode(node.parameter); + this.visitToken(node.closeBracketToken); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitPropertySignature = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalToken(node.questionToken); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitCallSignature = function (node) { + this.visitOptionalNode(node.typeParameterList); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.typeAnnotation); + }; + + SyntaxWalker.prototype.visitParameterList = function (node) { + this.visitToken(node.openParenToken); + this.visitSeparatedList(node.parameters); + this.visitToken(node.closeParenToken); + }; + + SyntaxWalker.prototype.visitTypeParameterList = function (node) { + this.visitToken(node.lessThanToken); + this.visitSeparatedList(node.typeParameters); + this.visitToken(node.greaterThanToken); + }; + + SyntaxWalker.prototype.visitTypeParameter = function (node) { + this.visitToken(node.identifier); + this.visitOptionalNode(node.constraint); + }; + + SyntaxWalker.prototype.visitConstraint = function (node) { + this.visitToken(node.extendsKeyword); + this.visitNodeOrToken(node.type); + }; + + SyntaxWalker.prototype.visitElseClause = function (node) { + this.visitToken(node.elseKeyword); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitIfStatement = function (node) { + this.visitToken(node.ifKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + this.visitOptionalNode(node.elseClause); + }; + + SyntaxWalker.prototype.visitExpressionStatement = function (node) { + this.visitNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitConstructorDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.constructorKeyword); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitMemberFunctionDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.propertyName); + this.visitNode(node.callSignature); + this.visitOptionalNode(node.block); + this.visitOptionalToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitGetAccessor = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.getKeyword); + this.visitToken(node.propertyName); + this.visitNode(node.parameterList); + this.visitOptionalNode(node.typeAnnotation); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitSetAccessor = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.setKeyword); + this.visitToken(node.propertyName); + this.visitNode(node.parameterList); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitMemberVariableDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.variableDeclarator); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitIndexMemberDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitNode(node.indexSignature); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitThrowStatement = function (node) { + this.visitToken(node.throwKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitReturnStatement = function (node) { + this.visitToken(node.returnKeyword); + this.visitOptionalNodeOrToken(node.expression); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitObjectCreationExpression = function (node) { + this.visitToken(node.newKeyword); + this.visitNodeOrToken(node.expression); + this.visitOptionalNode(node.argumentList); + }; + + SyntaxWalker.prototype.visitSwitchStatement = function (node) { + this.visitToken(node.switchKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + this.visitToken(node.openBraceToken); + this.visitList(node.switchClauses); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitCaseSwitchClause = function (node) { + this.visitToken(node.caseKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.colonToken); + this.visitList(node.statements); + }; + + SyntaxWalker.prototype.visitDefaultSwitchClause = function (node) { + this.visitToken(node.defaultKeyword); + this.visitToken(node.colonToken); + this.visitList(node.statements); + }; + + SyntaxWalker.prototype.visitBreakStatement = function (node) { + this.visitToken(node.breakKeyword); + this.visitOptionalToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitContinueStatement = function (node) { + this.visitToken(node.continueKeyword); + this.visitOptionalToken(node.identifier); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitForStatement = function (node) { + this.visitToken(node.forKeyword); + this.visitToken(node.openParenToken); + this.visitOptionalNode(node.variableDeclaration); + this.visitOptionalNodeOrToken(node.initializer); + this.visitToken(node.firstSemicolonToken); + this.visitOptionalNodeOrToken(node.condition); + this.visitToken(node.secondSemicolonToken); + this.visitOptionalNodeOrToken(node.incrementor); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitForInStatement = function (node) { + this.visitToken(node.forKeyword); + this.visitToken(node.openParenToken); + this.visitOptionalNode(node.variableDeclaration); + this.visitOptionalNodeOrToken(node.left); + this.visitToken(node.inKeyword); + this.visitNodeOrToken(node.expression); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitWhileStatement = function (node) { + this.visitToken(node.whileKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitWithStatement = function (node) { + this.visitToken(node.withKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitEnumDeclaration = function (node) { + this.visitList(node.modifiers); + this.visitToken(node.enumKeyword); + this.visitToken(node.identifier); + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.enumElements); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitEnumElement = function (node) { + this.visitToken(node.propertyName); + this.visitOptionalNode(node.equalsValueClause); + }; + + SyntaxWalker.prototype.visitCastExpression = function (node) { + this.visitToken(node.lessThanToken); + this.visitNodeOrToken(node.type); + this.visitToken(node.greaterThanToken); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitObjectLiteralExpression = function (node) { + this.visitToken(node.openBraceToken); + this.visitSeparatedList(node.propertyAssignments); + this.visitToken(node.closeBraceToken); + }; + + SyntaxWalker.prototype.visitSimplePropertyAssignment = function (node) { + this.visitToken(node.propertyName); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitFunctionPropertyAssignment = function (node) { + this.visitToken(node.propertyName); + this.visitNode(node.callSignature); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitFunctionExpression = function (node) { + this.visitToken(node.functionKeyword); + this.visitOptionalToken(node.identifier); + this.visitNode(node.callSignature); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitEmptyStatement = function (node) { + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitTryStatement = function (node) { + this.visitToken(node.tryKeyword); + this.visitNode(node.block); + this.visitOptionalNode(node.catchClause); + this.visitOptionalNode(node.finallyClause); + }; + + SyntaxWalker.prototype.visitCatchClause = function (node) { + this.visitToken(node.catchKeyword); + this.visitToken(node.openParenToken); + this.visitToken(node.identifier); + this.visitOptionalNode(node.typeAnnotation); + this.visitToken(node.closeParenToken); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitFinallyClause = function (node) { + this.visitToken(node.finallyKeyword); + this.visitNode(node.block); + }; + + SyntaxWalker.prototype.visitLabeledStatement = function (node) { + this.visitToken(node.identifier); + this.visitToken(node.colonToken); + this.visitNodeOrToken(node.statement); + }; + + SyntaxWalker.prototype.visitDoStatement = function (node) { + this.visitToken(node.doKeyword); + this.visitNodeOrToken(node.statement); + this.visitToken(node.whileKeyword); + this.visitToken(node.openParenToken); + this.visitNodeOrToken(node.condition); + this.visitToken(node.closeParenToken); + this.visitToken(node.semicolonToken); + }; + + SyntaxWalker.prototype.visitTypeOfExpression = function (node) { + this.visitToken(node.typeOfKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitDeleteExpression = function (node) { + this.visitToken(node.deleteKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitVoidExpression = function (node) { + this.visitToken(node.voidKeyword); + this.visitNodeOrToken(node.expression); + }; + + SyntaxWalker.prototype.visitDebuggerStatement = function (node) { + this.visitToken(node.debuggerKeyword); + this.visitToken(node.semicolonToken); + }; + return SyntaxWalker; + })(); + TypeScript.SyntaxWalker = SyntaxWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PositionTrackingWalker = (function (_super) { + __extends(PositionTrackingWalker, _super); + function PositionTrackingWalker() { + _super.apply(this, arguments); + this._position = 0; + } + PositionTrackingWalker.prototype.visitToken = function (token) { + this._position += token.fullWidth(); + }; + + PositionTrackingWalker.prototype.position = function () { + return this._position; + }; + + PositionTrackingWalker.prototype.skip = function (element) { + this._position += element.fullWidth(); + }; + return PositionTrackingWalker; + })(TypeScript.SyntaxWalker); + TypeScript.PositionTrackingWalker = PositionTrackingWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxInformationMap = (function (_super) { + __extends(SyntaxInformationMap, _super); + function SyntaxInformationMap(trackParents, trackPreviousToken) { + _super.call(this); + this.trackParents = trackParents; + this.trackPreviousToken = trackPreviousToken; + this.tokenToInformation = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this.elementToPosition = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this._previousToken = null; + this._previousTokenInformation = null; + this._currentPosition = 0; + this._elementToParent = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + this._parentStack = []; + this._parentStack.push(null); + } + SyntaxInformationMap.create = function (node, trackParents, trackPreviousToken) { + var map = new SyntaxInformationMap(trackParents, trackPreviousToken); + map.visitNode(node); + return map; + }; + + SyntaxInformationMap.prototype.visitNode = function (node) { + this.trackParents && this._elementToParent.add(node, TypeScript.ArrayUtilities.last(this._parentStack)); + this.elementToPosition.add(node, this._currentPosition); + + this.trackParents && this._parentStack.push(node); + _super.prototype.visitNode.call(this, node); + this.trackParents && this._parentStack.pop(); + }; + + SyntaxInformationMap.prototype.visitToken = function (token) { + this.trackParents && this._elementToParent.add(token, TypeScript.ArrayUtilities.last(this._parentStack)); + + if (this.trackPreviousToken) { + var tokenInformation = { + previousToken: this._previousToken, + nextToken: null + }; + + if (this._previousTokenInformation !== null) { + this._previousTokenInformation.nextToken = token; + } + + this._previousToken = token; + this._previousTokenInformation = tokenInformation; + + this.tokenToInformation.add(token, tokenInformation); + } + + this.elementToPosition.add(token, this._currentPosition); + this._currentPosition += token.fullWidth(); + }; + + SyntaxInformationMap.prototype.parent = function (element) { + return this._elementToParent.get(element); + }; + + SyntaxInformationMap.prototype.fullStart = function (element) { + return this.elementToPosition.get(element); + }; + + SyntaxInformationMap.prototype.start = function (element) { + return this.fullStart(element) + element.leadingTriviaWidth(); + }; + + SyntaxInformationMap.prototype.end = function (element) { + return this.start(element) + element.width(); + }; + + SyntaxInformationMap.prototype.previousToken = function (token) { + return this.tokenInformation(token).previousToken; + }; + + SyntaxInformationMap.prototype.tokenInformation = function (token) { + return this.tokenToInformation.get(token); + }; + + SyntaxInformationMap.prototype.firstTokenInLineContainingToken = function (token) { + var current = token; + while (true) { + var information = this.tokenInformation(current); + if (this.isFirstTokenInLineWorker(information)) { + break; + } + + current = information.previousToken; + } + + return current; + }; + + SyntaxInformationMap.prototype.isFirstTokenInLine = function (token) { + var information = this.tokenInformation(token); + return this.isFirstTokenInLineWorker(information); + }; + + SyntaxInformationMap.prototype.isFirstTokenInLineWorker = function (information) { + return information.previousToken === null || information.previousToken.hasTrailingNewLine(); + }; + return SyntaxInformationMap; + })(TypeScript.SyntaxWalker); + TypeScript.SyntaxInformationMap = SyntaxInformationMap; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxNodeInvariantsChecker = (function (_super) { + __extends(SyntaxNodeInvariantsChecker, _super); + function SyntaxNodeInvariantsChecker() { + _super.apply(this, arguments); + this.tokenTable = TypeScript.Collections.createHashTable(TypeScript.Collections.DefaultHashTableCapacity, TypeScript.Collections.identityHashCode); + } + SyntaxNodeInvariantsChecker.checkInvariants = function (node) { + node.accept(new SyntaxNodeInvariantsChecker()); + }; + + SyntaxNodeInvariantsChecker.prototype.visitToken = function (token) { + this.tokenTable.add(token, token); + }; + return SyntaxNodeInvariantsChecker; + })(TypeScript.SyntaxWalker); + TypeScript.SyntaxNodeInvariantsChecker = SyntaxNodeInvariantsChecker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var DepthLimitedWalker = (function (_super) { + __extends(DepthLimitedWalker, _super); + function DepthLimitedWalker(maximumDepth) { + _super.call(this); + this._depth = 0; + this._maximumDepth = 0; + this._maximumDepth = maximumDepth; + } + DepthLimitedWalker.prototype.visitNode = function (node) { + if (this._depth < this._maximumDepth) { + this._depth++; + _super.prototype.visitNode.call(this, node); + this._depth--; + } else { + this.skip(node); + } + }; + return DepthLimitedWalker; + })(TypeScript.PositionTrackingWalker); + TypeScript.DepthLimitedWalker = DepthLimitedWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (Parser) { + + + var ExpressionPrecedence; + (function (ExpressionPrecedence) { + ExpressionPrecedence[ExpressionPrecedence["CommaExpressionPrecedence"] = 1] = "CommaExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["AssignmentExpressionPrecedence"] = 2] = "AssignmentExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["ConditionalExpressionPrecedence"] = 3] = "ConditionalExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["ArrowFunctionPrecedence"] = 4] = "ArrowFunctionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["LogicalOrExpressionPrecedence"] = 5] = "LogicalOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["LogicalAndExpressionPrecedence"] = 6] = "LogicalAndExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseOrExpressionPrecedence"] = 7] = "BitwiseOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseExclusiveOrExpressionPrecedence"] = 8] = "BitwiseExclusiveOrExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["BitwiseAndExpressionPrecedence"] = 9] = "BitwiseAndExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["EqualityExpressionPrecedence"] = 10] = "EqualityExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["RelationalExpressionPrecedence"] = 11] = "RelationalExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["ShiftExpressionPrecdence"] = 12] = "ShiftExpressionPrecdence"; + ExpressionPrecedence[ExpressionPrecedence["AdditiveExpressionPrecedence"] = 13] = "AdditiveExpressionPrecedence"; + ExpressionPrecedence[ExpressionPrecedence["MultiplicativeExpressionPrecedence"] = 14] = "MultiplicativeExpressionPrecedence"; + + ExpressionPrecedence[ExpressionPrecedence["UnaryExpressionPrecedence"] = 15] = "UnaryExpressionPrecedence"; + })(ExpressionPrecedence || (ExpressionPrecedence = {})); + + var ListParsingState; + (function (ListParsingState) { + ListParsingState[ListParsingState["SourceUnit_ModuleElements"] = 1 << 0] = "SourceUnit_ModuleElements"; + ListParsingState[ListParsingState["ClassDeclaration_ClassElements"] = 1 << 1] = "ClassDeclaration_ClassElements"; + ListParsingState[ListParsingState["ModuleDeclaration_ModuleElements"] = 1 << 2] = "ModuleDeclaration_ModuleElements"; + ListParsingState[ListParsingState["SwitchStatement_SwitchClauses"] = 1 << 3] = "SwitchStatement_SwitchClauses"; + ListParsingState[ListParsingState["SwitchClause_Statements"] = 1 << 4] = "SwitchClause_Statements"; + ListParsingState[ListParsingState["Block_Statements"] = 1 << 5] = "Block_Statements"; + ListParsingState[ListParsingState["TryBlock_Statements"] = 1 << 6] = "TryBlock_Statements"; + ListParsingState[ListParsingState["CatchBlock_Statements"] = 1 << 7] = "CatchBlock_Statements"; + ListParsingState[ListParsingState["EnumDeclaration_EnumElements"] = 1 << 8] = "EnumDeclaration_EnumElements"; + ListParsingState[ListParsingState["ObjectType_TypeMembers"] = 1 << 9] = "ObjectType_TypeMembers"; + ListParsingState[ListParsingState["ClassOrInterfaceDeclaration_HeritageClauses"] = 1 << 10] = "ClassOrInterfaceDeclaration_HeritageClauses"; + ListParsingState[ListParsingState["HeritageClause_TypeNameList"] = 1 << 11] = "HeritageClause_TypeNameList"; + ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_AllowIn"] = 1 << 12] = "VariableDeclaration_VariableDeclarators_AllowIn"; + ListParsingState[ListParsingState["VariableDeclaration_VariableDeclarators_DisallowIn"] = 1 << 13] = "VariableDeclaration_VariableDeclarators_DisallowIn"; + ListParsingState[ListParsingState["ArgumentList_AssignmentExpressions"] = 1 << 14] = "ArgumentList_AssignmentExpressions"; + ListParsingState[ListParsingState["ObjectLiteralExpression_PropertyAssignments"] = 1 << 15] = "ObjectLiteralExpression_PropertyAssignments"; + ListParsingState[ListParsingState["ArrayLiteralExpression_AssignmentExpressions"] = 1 << 16] = "ArrayLiteralExpression_AssignmentExpressions"; + ListParsingState[ListParsingState["ParameterList_Parameters"] = 1 << 17] = "ParameterList_Parameters"; + ListParsingState[ListParsingState["TypeArgumentList_Types"] = 1 << 18] = "TypeArgumentList_Types"; + ListParsingState[ListParsingState["TypeParameterList_TypeParameters"] = 1 << 19] = "TypeParameterList_TypeParameters"; + + ListParsingState[ListParsingState["FirstListParsingState"] = ListParsingState.SourceUnit_ModuleElements] = "FirstListParsingState"; + ListParsingState[ListParsingState["LastListParsingState"] = ListParsingState.TypeArgumentList_Types] = "LastListParsingState"; + })(ListParsingState || (ListParsingState = {})); + + var SyntaxCursor = (function () { + function SyntaxCursor(sourceUnit) { + this._elements = []; + this._index = 0; + this._pinCount = 0; + sourceUnit.insertChildrenInto(this._elements, 0); + } + SyntaxCursor.prototype.isFinished = function () { + return this._index === this._elements.length; + }; + + SyntaxCursor.prototype.currentElement = function () { + if (this.isFinished()) { + return null; + } + + return this._elements[this._index]; + }; + + SyntaxCursor.prototype.currentNode = function () { + var element = this.currentElement(); + return element !== null && element.isNode() ? element : null; + }; + + SyntaxCursor.prototype.moveToFirstChild = function () { + if (this.isFinished()) { + return; + } + + var element = this._elements[this._index]; + if (element.isToken()) { + return; + } + + var node = element; + + this._elements.splice(this._index, 1); + + node.insertChildrenInto(this._elements, this._index); + }; + + SyntaxCursor.prototype.moveToNextSibling = function () { + if (this.isFinished()) { + return; + } + + if (this._pinCount > 0) { + this._index++; + return; + } + + this._elements.shift(); + }; + + SyntaxCursor.prototype.getAndPinCursorIndex = function () { + this._pinCount++; + return this._index; + }; + + SyntaxCursor.prototype.releaseAndUnpinCursorIndex = function (index) { + this._pinCount--; + if (this._pinCount === 0) { + } + }; + + SyntaxCursor.prototype.rewindToPinnedCursorIndex = function (index) { + this._index = index; + }; + + SyntaxCursor.prototype.pinCount = function () { + return this._pinCount; + }; + + SyntaxCursor.prototype.moveToFirstToken = function () { + var element; + + while (!this.isFinished()) { + element = this.currentElement(); + if (element.isNode()) { + this.moveToFirstChild(); + continue; + } + + return; + } + }; + + SyntaxCursor.prototype.currentToken = function () { + this.moveToFirstToken(); + if (this.isFinished()) { + return null; + } + + var element = this.currentElement(); + + return element; + }; + + SyntaxCursor.prototype.peekToken = function (n) { + this.moveToFirstToken(); + var pin = this.getAndPinCursorIndex(); + + for (var i = 0; i < n; i++) { + this.moveToNextSibling(); + this.moveToFirstToken(); + } + + var result = this.currentToken(); + this.rewindToPinnedCursorIndex(pin); + this.releaseAndUnpinCursorIndex(pin); + + return result; + }; + return SyntaxCursor; + })(); + + + + var NormalParserSource = (function () { + function NormalParserSource(fileName, text, languageVersion) { + this._previousToken = null; + this._absolutePosition = 0; + this._tokenDiagnostics = []; + this.rewindPointPool = []; + this.rewindPointPoolCount = 0; + this.slidingWindow = new TypeScript.SlidingWindow(this, TypeScript.ArrayUtilities.createArray(32, null), null); + this.scanner = new TypeScript.Scanner(fileName, text, languageVersion); + } + NormalParserSource.prototype.currentNode = function () { + return null; + }; + + NormalParserSource.prototype.moveToNextNode = function () { + throw TypeScript.Errors.invalidOperation(); + }; + + NormalParserSource.prototype.absolutePosition = function () { + return this._absolutePosition; + }; + + NormalParserSource.prototype.previousToken = function () { + return this._previousToken; + }; + + NormalParserSource.prototype.tokenDiagnostics = function () { + return this._tokenDiagnostics; + }; + + NormalParserSource.prototype.getOrCreateRewindPoint = function () { + if (this.rewindPointPoolCount === 0) { + return {}; + } + + this.rewindPointPoolCount--; + var result = this.rewindPointPool[this.rewindPointPoolCount]; + this.rewindPointPool[this.rewindPointPoolCount] = null; + return result; + }; + + NormalParserSource.prototype.getRewindPoint = function () { + var slidingWindowIndex = this.slidingWindow.getAndPinAbsoluteIndex(); + + var rewindPoint = this.getOrCreateRewindPoint(); + + rewindPoint.slidingWindowIndex = slidingWindowIndex; + rewindPoint.previousToken = this._previousToken; + rewindPoint.absolutePosition = this._absolutePosition; + + rewindPoint.pinCount = this.slidingWindow.pinCount(); + + return rewindPoint; + }; + + NormalParserSource.prototype.isPinned = function () { + return this.slidingWindow.pinCount() > 0; + }; + + NormalParserSource.prototype.rewind = function (rewindPoint) { + this.slidingWindow.rewindToPinnedIndex(rewindPoint.slidingWindowIndex); + + this._previousToken = rewindPoint.previousToken; + this._absolutePosition = rewindPoint.absolutePosition; + }; + + NormalParserSource.prototype.releaseRewindPoint = function (rewindPoint) { + this.slidingWindow.releaseAndUnpinAbsoluteIndex(rewindPoint.absoluteIndex); + + this.rewindPointPool[this.rewindPointPoolCount] = rewindPoint; + this.rewindPointPoolCount++; + }; + + NormalParserSource.prototype.fetchMoreItems = function (allowRegularExpression, sourceIndex, window, destinationIndex, spaceAvailable) { + window[destinationIndex] = this.scanner.scan(this._tokenDiagnostics, allowRegularExpression); + return 1; + }; + + NormalParserSource.prototype.peekToken = function (n) { + return this.slidingWindow.peekItemN(n); + }; + + NormalParserSource.prototype.moveToNextToken = function () { + var currentToken = this.currentToken(); + this._absolutePosition += currentToken.fullWidth(); + this._previousToken = currentToken; + + this.slidingWindow.moveToNextItem(); + }; + + NormalParserSource.prototype.currentToken = function () { + return this.slidingWindow.currentItem(false); + }; + + NormalParserSource.prototype.removeDiagnosticsOnOrAfterPosition = function (position) { + var tokenDiagnosticsLength = this._tokenDiagnostics.length; + while (tokenDiagnosticsLength > 0) { + var diagnostic = this._tokenDiagnostics[tokenDiagnosticsLength - 1]; + if (diagnostic.start() >= position) { + tokenDiagnosticsLength--; + } else { + break; + } + } + + this._tokenDiagnostics.length = tokenDiagnosticsLength; + }; + + NormalParserSource.prototype.resetToPosition = function (absolutePosition, previousToken) { + this._absolutePosition = absolutePosition; + this._previousToken = previousToken; + + this.removeDiagnosticsOnOrAfterPosition(absolutePosition); + + this.slidingWindow.disgardAllItemsFromCurrentIndexOnwards(); + + this.scanner.setAbsoluteIndex(absolutePosition); + }; + + NormalParserSource.prototype.currentTokenAllowingRegularExpression = function () { + this.resetToPosition(this._absolutePosition, this._previousToken); + + var token = this.slidingWindow.currentItem(true); + + return token; + }; + return NormalParserSource; + })(); + + var IncrementalParserSource = (function () { + function IncrementalParserSource(oldSyntaxTree, textChangeRange, newText) { + this._changeDelta = 0; + var oldSourceUnit = oldSyntaxTree.sourceUnit(); + this._oldSourceUnitCursor = new SyntaxCursor(oldSourceUnit); + + this._changeRange = IncrementalParserSource.extendToAffectedRange(textChangeRange, oldSourceUnit); + + if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) { + TypeScript.Debug.assert((oldSourceUnit.fullWidth() - this._changeRange.span().length() + this._changeRange.newLength()) === newText.length()); + } + + this._normalParserSource = new NormalParserSource(oldSyntaxTree.fileName(), newText, oldSyntaxTree.parseOptions().languageVersion()); + } + IncrementalParserSource.extendToAffectedRange = function (changeRange, sourceUnit) { + var maxLookahead = 1; + + var start = changeRange.span().start(); + + for (var i = 0; start > 0 && i <= maxLookahead; i++) { + var token = sourceUnit.findToken(start); + + var position = token.fullStart(); + + start = TypeScript.MathPrototype.max(0, position - 1); + } + + var finalSpan = TypeScript.TextSpan.fromBounds(start, changeRange.span().end()); + var finalLength = changeRange.newLength() + (changeRange.span().start() - start); + + return new TypeScript.TextChangeRange(finalSpan, finalLength); + }; + + IncrementalParserSource.prototype.absolutePosition = function () { + return this._normalParserSource.absolutePosition(); + }; + + IncrementalParserSource.prototype.previousToken = function () { + return this._normalParserSource.previousToken(); + }; + + IncrementalParserSource.prototype.tokenDiagnostics = function () { + return this._normalParserSource.tokenDiagnostics(); + }; + + IncrementalParserSource.prototype.getRewindPoint = function () { + var rewindPoint = this._normalParserSource.getRewindPoint(); + var oldSourceUnitCursorIndex = this._oldSourceUnitCursor.getAndPinCursorIndex(); + + rewindPoint.changeDelta = this._changeDelta; + rewindPoint.changeRange = this._changeRange; + rewindPoint.oldSourceUnitCursorIndex = oldSourceUnitCursorIndex; + + return rewindPoint; + }; + + IncrementalParserSource.prototype.rewind = function (rewindPoint) { + this._changeRange = rewindPoint.changeRange; + this._changeDelta = rewindPoint.changeDelta; + this._oldSourceUnitCursor.rewindToPinnedCursorIndex(rewindPoint.oldSourceUnitCursorIndex); + + this._normalParserSource.rewind(rewindPoint); + }; + + IncrementalParserSource.prototype.releaseRewindPoint = function (rewindPoint) { + this._oldSourceUnitCursor.releaseAndUnpinCursorIndex(rewindPoint.oldSourceUnitCursorIndex); + this._normalParserSource.releaseRewindPoint(rewindPoint); + }; + + IncrementalParserSource.prototype.canReadFromOldSourceUnit = function () { + if (this._normalParserSource.isPinned()) { + return false; + } + + if (this._changeRange !== null && this._changeRange.newSpan().intersectsWithPosition(this.absolutePosition())) { + return false; + } + + this.syncCursorToNewTextIfBehind(); + + return this._changeDelta === 0 && !this._oldSourceUnitCursor.isFinished(); + }; + + IncrementalParserSource.prototype.currentNode = function () { + if (this.canReadFromOldSourceUnit()) { + return this.tryGetNodeFromOldSourceUnit(); + } + + return null; + }; + + IncrementalParserSource.prototype.currentToken = function () { + if (this.canReadFromOldSourceUnit()) { + var token = this.tryGetTokenFromOldSourceUnit(); + if (token !== null) { + return token; + } + } + + return this._normalParserSource.currentToken(); + }; + + IncrementalParserSource.prototype.currentTokenAllowingRegularExpression = function () { + return this._normalParserSource.currentTokenAllowingRegularExpression(); + }; + + IncrementalParserSource.prototype.syncCursorToNewTextIfBehind = function () { + while (true) { + if (this._oldSourceUnitCursor.isFinished()) { + break; + } + + if (this._changeDelta >= 0) { + break; + } + + var currentElement = this._oldSourceUnitCursor.currentElement(); + + if (currentElement.isNode() && (currentElement.fullWidth() > Math.abs(this._changeDelta))) { + this._oldSourceUnitCursor.moveToFirstChild(); + } else { + this._oldSourceUnitCursor.moveToNextSibling(); + + this._changeDelta += currentElement.fullWidth(); + } + } + }; + + IncrementalParserSource.prototype.intersectsWithChangeRangeSpanInOriginalText = function (start, length) { + return this._changeRange !== null && this._changeRange.span().intersectsWith(start, length); + }; + + IncrementalParserSource.prototype.tryGetNodeFromOldSourceUnit = function () { + while (true) { + var node = this._oldSourceUnitCursor.currentNode(); + if (node === null) { + return null; + } + + if (!this.intersectsWithChangeRangeSpanInOriginalText(this.absolutePosition(), node.fullWidth())) { + if (!node.isIncrementallyUnusable()) { + return node; + } + } + + this._oldSourceUnitCursor.moveToFirstChild(); + } + }; + + IncrementalParserSource.prototype.canReuseTokenFromOldSourceUnit = function (position, token) { + if (token !== null) { + if (!this.intersectsWithChangeRangeSpanInOriginalText(position, token.fullWidth())) { + if (!token.isIncrementallyUnusable()) { + return true; + } + } + } + + return false; + }; + + IncrementalParserSource.prototype.tryGetTokenFromOldSourceUnit = function () { + var token = this._oldSourceUnitCursor.currentToken(); + + return this.canReuseTokenFromOldSourceUnit(this.absolutePosition(), token) ? token : null; + }; + + IncrementalParserSource.prototype.peekToken = function (n) { + if (this.canReadFromOldSourceUnit()) { + var token = this.tryPeekTokenFromOldSourceUnit(n); + if (token !== null) { + return token; + } + } + + return this._normalParserSource.peekToken(n); + }; + + IncrementalParserSource.prototype.tryPeekTokenFromOldSourceUnit = function (n) { + var currentPosition = this.absolutePosition(); + for (var i = 0; i < n; i++) { + var interimToken = this._oldSourceUnitCursor.peekToken(i); + if (!this.canReuseTokenFromOldSourceUnit(currentPosition, interimToken)) { + return null; + } + + currentPosition += interimToken.fullWidth(); + } + + var token = this._oldSourceUnitCursor.peekToken(n); + return this.canReuseTokenFromOldSourceUnit(currentPosition, token) ? token : null; + }; + + IncrementalParserSource.prototype.moveToNextNode = function () { + var currentElement = this._oldSourceUnitCursor.currentElement(); + var currentNode = this._oldSourceUnitCursor.currentNode(); + + this._oldSourceUnitCursor.moveToNextSibling(); + + var absolutePosition = this.absolutePosition() + currentNode.fullWidth(); + var previousToken = currentNode.lastToken(); + this._normalParserSource.resetToPosition(absolutePosition, previousToken); + + if (this._changeRange !== null) { + } + }; + + IncrementalParserSource.prototype.moveToNextToken = function () { + var currentToken = this.currentToken(); + + if (this._oldSourceUnitCursor.currentToken() === currentToken) { + this._oldSourceUnitCursor.moveToNextSibling(); + + var absolutePosition = this.absolutePosition() + currentToken.fullWidth(); + var previousToken = currentToken; + this._normalParserSource.resetToPosition(absolutePosition, previousToken); + + if (this._changeRange !== null) { + } + } else { + this._changeDelta -= currentToken.fullWidth(); + + this._normalParserSource.moveToNextToken(); + + if (this._changeRange !== null) { + var changeRangeSpanInNewText = this._changeRange.newSpan(); + if (this.absolutePosition() >= changeRangeSpanInNewText.end()) { + this._changeDelta += this._changeRange.newLength() - this._changeRange.span().length(); + this._changeRange = null; + } + } + } + }; + return IncrementalParserSource; + })(); + + var ParserImpl = (function () { + function ParserImpl(fileName, lineMap, source, parseOptions, newText_forDebuggingPurposesOnly) { + this.newText_forDebuggingPurposesOnly = newText_forDebuggingPurposesOnly; + this.listParsingState = 0; + this.isInStrictMode = false; + this.diagnostics = []; + this.factory = TypeScript.Syntax.normalModeFactory; + this.mergeTokensStorage = []; + this.arrayPool = []; + this.fileName = fileName; + this.lineMap = lineMap; + this.source = source; + this.parseOptions = parseOptions; + } + ParserImpl.prototype.getRewindPoint = function () { + var rewindPoint = this.source.getRewindPoint(); + + rewindPoint.diagnosticsCount = this.diagnostics.length; + + rewindPoint.isInStrictMode = this.isInStrictMode; + rewindPoint.listParsingState = this.listParsingState; + + return rewindPoint; + }; + + ParserImpl.prototype.rewind = function (rewindPoint) { + this.source.rewind(rewindPoint); + + this.diagnostics.length = rewindPoint.diagnosticsCount; + }; + + ParserImpl.prototype.releaseRewindPoint = function (rewindPoint) { + this.source.releaseRewindPoint(rewindPoint); + }; + + ParserImpl.prototype.currentTokenStart = function () { + return this.source.absolutePosition() + this.currentToken().leadingTriviaWidth(); + }; + + ParserImpl.prototype.previousTokenStart = function () { + if (this.previousToken() === null) { + return 0; + } + + return this.source.absolutePosition() - this.previousToken().fullWidth() + this.previousToken().leadingTriviaWidth(); + }; + + ParserImpl.prototype.previousTokenEnd = function () { + if (this.previousToken() === null) { + return 0; + } + + return this.previousTokenStart() + this.previousToken().width(); + }; + + ParserImpl.prototype.currentNode = function () { + var node = this.source.currentNode(); + + if (node === null || node.parsedInStrictMode() !== this.isInStrictMode) { + return null; + } + + return node; + }; + + ParserImpl.prototype.currentToken = function () { + return this.source.currentToken(); + }; + + ParserImpl.prototype.currentTokenAllowingRegularExpression = function () { + return this.source.currentTokenAllowingRegularExpression(); + }; + + ParserImpl.prototype.peekToken = function (n) { + return this.source.peekToken(n); + }; + + ParserImpl.prototype.eatAnyToken = function () { + var token = this.currentToken(); + this.moveToNextToken(); + return token; + }; + + ParserImpl.prototype.moveToNextToken = function () { + this.source.moveToNextToken(); + }; + + ParserImpl.prototype.previousToken = function () { + return this.source.previousToken(); + }; + + ParserImpl.prototype.eatNode = function () { + var node = this.source.currentNode(); + this.source.moveToNextNode(); + return node; + }; + + ParserImpl.prototype.eatToken = function (kind) { + var token = this.currentToken(); + if (token.tokenKind === kind) { + this.moveToNextToken(); + return token; + } + + return this.createMissingToken(kind, token); + }; + + ParserImpl.prototype.tryEatToken = function (kind) { + if (this.currentToken().tokenKind === kind) { + return this.eatToken(kind); + } + + return null; + }; + + ParserImpl.prototype.eatKeyword = function (kind) { + var token = this.currentToken(); + if (token.tokenKind === kind) { + this.moveToNextToken(); + return token; + } + + return this.createMissingToken(kind, token); + }; + + ParserImpl.prototype.isIdentifier = function (token) { + var tokenKind = token.tokenKind; + + if (tokenKind === 11 /* IdentifierName */) { + return true; + } + + if (tokenKind >= 51 /* FirstFutureReservedStrictKeyword */) { + if (tokenKind <= 59 /* LastFutureReservedStrictKeyword */) { + return !this.isInStrictMode; + } + + return tokenKind <= 69 /* LastTypeScriptKeyword */; + } + + return false; + }; + + ParserImpl.prototype.eatIdentifierNameToken = function () { + var token = this.currentToken(); + + if (token.tokenKind === 11 /* IdentifierName */) { + this.moveToNextToken(); + return token; + } + + if (TypeScript.SyntaxFacts.isAnyKeyword(token.tokenKind)) { + this.moveToNextToken(); + return TypeScript.Syntax.convertToIdentifierName(token); + } + + return this.createMissingToken(11 /* IdentifierName */, token); + }; + + ParserImpl.prototype.eatIdentifierToken = function () { + var token = this.currentToken(); + if (this.isIdentifier(token)) { + this.moveToNextToken(); + + if (token.tokenKind === 11 /* IdentifierName */) { + return token; + } + + return TypeScript.Syntax.convertToIdentifierName(token); + } + + return this.createMissingToken(11 /* IdentifierName */, token); + }; + + ParserImpl.prototype.canEatAutomaticSemicolon = function (allowWithoutNewLine) { + var token = this.currentToken(); + + if (token.tokenKind === 10 /* EndOfFileToken */) { + return true; + } + + if (token.tokenKind === 71 /* CloseBraceToken */) { + return true; + } + + if (allowWithoutNewLine) { + return true; + } + + if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) { + return true; + } + + return false; + }; + + ParserImpl.prototype.canEatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) { + var token = this.currentToken(); + + if (token.tokenKind === 78 /* SemicolonToken */) { + return true; + } + + return this.canEatAutomaticSemicolon(allowWithoutNewline); + }; + + ParserImpl.prototype.eatExplicitOrAutomaticSemicolon = function (allowWithoutNewline) { + var token = this.currentToken(); + + if (token.tokenKind === 78 /* SemicolonToken */) { + return this.eatToken(78 /* SemicolonToken */); + } + + if (this.canEatAutomaticSemicolon(allowWithoutNewline)) { + var semicolonToken = TypeScript.Syntax.emptyToken(78 /* SemicolonToken */); + + if (!this.parseOptions.allowAutomaticSemicolonInsertion()) { + this.addDiagnostic(new TypeScript.Diagnostic(this.fileName, this.lineMap, this.previousTokenEnd(), 0, TypeScript.DiagnosticCode.Automatic_semicolon_insertion_not_allowed, null)); + } + + return semicolonToken; + } + + return this.eatToken(78 /* SemicolonToken */); + }; + + ParserImpl.prototype.isKeyword = function (kind) { + if (kind >= 15 /* FirstKeyword */) { + if (kind <= 50 /* LastFutureReservedKeyword */) { + return true; + } + + if (this.isInStrictMode) { + return kind <= 59 /* LastFutureReservedStrictKeyword */; + } + } + + return false; + }; + + ParserImpl.prototype.createMissingToken = function (expectedKind, actual) { + var diagnostic = this.getExpectedTokenDiagnostic(expectedKind, actual); + this.addDiagnostic(diagnostic); + + return TypeScript.Syntax.emptyToken(expectedKind); + }; + + ParserImpl.prototype.getExpectedTokenDiagnostic = function (expectedKind, actual) { + var token = this.currentToken(); + + if (TypeScript.SyntaxFacts.isAnyKeyword(expectedKind) || TypeScript.SyntaxFacts.isAnyPunctuation(expectedKind)) { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(expectedKind)]); + } else { + if (actual !== null && TypeScript.SyntaxFacts.isAnyKeyword(actual.tokenKind)) { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected_0_is_a_keyword, [TypeScript.SyntaxFacts.getText(actual.tokenKind)]); + } else { + return new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Identifier_expected, null); + } + } + }; + + ParserImpl.getPrecedence = function (expressionKind) { + switch (expressionKind) { + case 173 /* CommaExpression */: + return 1 /* CommaExpressionPrecedence */; + + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + return 2 /* AssignmentExpressionPrecedence */; + + case 186 /* ConditionalExpression */: + return 3 /* ConditionalExpressionPrecedence */; + + case 187 /* LogicalOrExpression */: + return 5 /* LogicalOrExpressionPrecedence */; + + case 188 /* LogicalAndExpression */: + return 6 /* LogicalAndExpressionPrecedence */; + + case 189 /* BitwiseOrExpression */: + return 7 /* BitwiseOrExpressionPrecedence */; + + case 190 /* BitwiseExclusiveOrExpression */: + return 8 /* BitwiseExclusiveOrExpressionPrecedence */; + + case 191 /* BitwiseAndExpression */: + return 9 /* BitwiseAndExpressionPrecedence */; + + case 192 /* EqualsWithTypeConversionExpression */: + case 193 /* NotEqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + return 10 /* EqualityExpressionPrecedence */; + + case 196 /* LessThanExpression */: + case 197 /* GreaterThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 200 /* InstanceOfExpression */: + case 201 /* InExpression */: + return 11 /* RelationalExpressionPrecedence */; + + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + return 12 /* ShiftExpressionPrecdence */; + + case 208 /* AddExpression */: + case 209 /* SubtractExpression */: + return 13 /* AdditiveExpressionPrecedence */; + + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + return 14 /* MultiplicativeExpressionPrecedence */; + + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + case 166 /* BitwiseNotExpression */: + case 167 /* LogicalNotExpression */: + case 170 /* DeleteExpression */: + case 171 /* TypeOfExpression */: + case 172 /* VoidExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return 15 /* UnaryExpressionPrecedence */; + } + + throw TypeScript.Errors.invalidOperation(); + }; + + ParserImpl.prototype.addSkippedTokenAfterNodeOrToken = function (nodeOrToken, skippedToken) { + if (nodeOrToken.isToken()) { + return this.addSkippedTokenAfterToken(nodeOrToken, skippedToken); + } else if (nodeOrToken.isNode()) { + return this.addSkippedTokenAfterNode(nodeOrToken, skippedToken); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.addSkippedTokenAfterNode = function (node, skippedToken) { + var oldToken = node.lastToken(); + var newToken = this.addSkippedTokenAfterToken(oldToken, skippedToken); + + return node.replaceToken(oldToken, newToken); + }; + + ParserImpl.prototype.addSkippedTokensBeforeNode = function (node, skippedTokens) { + if (skippedTokens.length > 0) { + var oldToken = node.firstToken(); + var newToken = this.addSkippedTokensBeforeToken(oldToken, skippedTokens); + + return node.replaceToken(oldToken, newToken); + } + + return node; + }; + + ParserImpl.prototype.addSkippedTokensBeforeToken = function (token, skippedTokens) { + var leadingTrivia = []; + for (var i = 0, n = skippedTokens.length; i < n; i++) { + this.addSkippedTokenToTriviaArray(leadingTrivia, skippedTokens[i]); + } + + this.addTriviaTo(token.leadingTrivia(), leadingTrivia); + + this.returnArray(skippedTokens); + return token.withLeadingTrivia(TypeScript.Syntax.triviaList(leadingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokensAfterToken = function (token, skippedTokens) { + if (skippedTokens.length === 0) { + this.returnArray(skippedTokens); + return token; + } + + var trailingTrivia = token.trailingTrivia().toArray(); + + for (var i = 0, n = skippedTokens.length; i < n; i++) { + this.addSkippedTokenToTriviaArray(trailingTrivia, skippedTokens[i]); + } + + this.returnArray(skippedTokens); + return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokenAfterToken = function (token, skippedToken) { + var trailingTrivia = token.trailingTrivia().toArray(); + this.addSkippedTokenToTriviaArray(trailingTrivia, skippedToken); + + return token.withTrailingTrivia(TypeScript.Syntax.triviaList(trailingTrivia)); + }; + + ParserImpl.prototype.addSkippedTokenToTriviaArray = function (array, skippedToken) { + this.addTriviaTo(skippedToken.leadingTrivia(), array); + + var trimmedToken = skippedToken.withLeadingTrivia(TypeScript.Syntax.emptyTriviaList).withTrailingTrivia(TypeScript.Syntax.emptyTriviaList); + array.push(TypeScript.Syntax.skippedTokenTrivia(trimmedToken)); + + this.addTriviaTo(skippedToken.trailingTrivia(), array); + }; + + ParserImpl.prototype.addTriviaTo = function (list, array) { + for (var i = 0, n = list.count(); i < n; i++) { + array.push(list.syntaxTriviaAt(i)); + } + }; + + ParserImpl.prototype.parseSyntaxTree = function (isDeclaration) { + var sourceUnit = this.parseSourceUnit(); + + var allDiagnostics = this.source.tokenDiagnostics().concat(this.diagnostics); + allDiagnostics.sort(function (a, b) { + return a.start() - b.start(); + }); + + return new TypeScript.SyntaxTree(sourceUnit, isDeclaration, allDiagnostics, this.fileName, this.lineMap, this.parseOptions); + }; + + ParserImpl.prototype.setStrictMode = function (isInStrictMode) { + this.isInStrictMode = isInStrictMode; + this.factory = isInStrictMode ? TypeScript.Syntax.strictModeFactory : TypeScript.Syntax.normalModeFactory; + }; + + ParserImpl.prototype.parseSourceUnit = function () { + var savedIsInStrictMode = this.isInStrictMode; + + var result = this.parseSyntaxList(1 /* SourceUnit_ModuleElements */, ParserImpl.updateStrictModeState); + var moduleElements = result.list; + + this.setStrictMode(savedIsInStrictMode); + + var sourceUnit = this.factory.sourceUnit(moduleElements, this.currentToken()); + sourceUnit = this.addSkippedTokensBeforeNode(sourceUnit, result.skippedTokens); + + if (TypeScript.Debug.shouldAssert(2 /* Aggressive */)) { + TypeScript.Debug.assert(sourceUnit.fullWidth() === this.newText_forDebuggingPurposesOnly.length()); + + if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) { + TypeScript.Debug.assert(sourceUnit.fullText() === this.newText_forDebuggingPurposesOnly.substr(0, this.newText_forDebuggingPurposesOnly.length(), false)); + } + } + + return sourceUnit; + }; + + ParserImpl.updateStrictModeState = function (parser, items) { + if (!parser.isInStrictMode) { + for (var i = 0; i < items.length; i++) { + var item = items[i]; + if (!TypeScript.SyntaxFacts.isDirectivePrologueElement(item)) { + return; + } + } + + parser.setStrictMode(TypeScript.SyntaxFacts.isUseStrictDirective(items[items.length - 1])); + } + }; + + ParserImpl.prototype.isModuleElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isModuleElement()) { + return true; + } + + var modifierCount = this.modifierCount(); + return this.isImportDeclaration(modifierCount) || this.isExportAssignment() || this.isModuleDeclaration(modifierCount) || this.isInterfaceDeclaration(modifierCount) || this.isClassDeclaration(modifierCount) || this.isEnumDeclaration(modifierCount) || this.isStatement(inErrorRecovery); + }; + + ParserImpl.prototype.parseModuleElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isModuleElement()) { + return this.eatNode(); + } + + var modifierCount = this.modifierCount(); + if (this.isImportDeclaration(modifierCount)) { + return this.parseImportDeclaration(); + } else if (this.isExportAssignment()) { + return this.parseExportAssignment(); + } else if (this.isModuleDeclaration(modifierCount)) { + return this.parseModuleDeclaration(); + } else if (this.isInterfaceDeclaration(modifierCount)) { + return this.parseInterfaceDeclaration(); + } else if (this.isClassDeclaration(modifierCount)) { + return this.parseClassDeclaration(); + } else if (this.isEnumDeclaration(modifierCount)) { + return this.parseEnumDeclaration(); + } else if (this.isStatement(inErrorRecovery)) { + return this.parseStatement(inErrorRecovery); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isImportDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 49 /* ImportKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 49 /* ImportKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseImportDeclaration = function () { + var modifiers = this.parseModifiers(); + var importKeyword = this.eatKeyword(49 /* ImportKeyword */); + var identifier = this.eatIdentifierToken(); + var equalsToken = this.eatToken(107 /* EqualsToken */); + var moduleReference = this.parseModuleReference(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.importDeclaration(modifiers, importKeyword, identifier, equalsToken, moduleReference, semicolonToken); + }; + + ParserImpl.prototype.isExportAssignment = function () { + return this.currentToken().tokenKind === 47 /* ExportKeyword */ && this.peekToken(1).tokenKind === 107 /* EqualsToken */; + }; + + ParserImpl.prototype.parseExportAssignment = function () { + var exportKeyword = this.eatKeyword(47 /* ExportKeyword */); + var equalsToken = this.eatToken(107 /* EqualsToken */); + var identifier = this.eatIdentifierToken(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.exportAssignment(exportKeyword, equalsToken, identifier, semicolonToken); + }; + + ParserImpl.prototype.parseModuleReference = function () { + if (this.isExternalModuleReference()) { + return this.parseExternalModuleReference(); + } else { + return this.parseModuleNameModuleReference(); + } + }; + + ParserImpl.prototype.isExternalModuleReference = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 66 /* RequireKeyword */) { + return this.peekToken(1).tokenKind === 72 /* OpenParenToken */; + } + + return false; + }; + + ParserImpl.prototype.parseExternalModuleReference = function () { + var requireKeyword = this.eatKeyword(66 /* RequireKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var stringLiteral = this.eatToken(14 /* StringLiteral */); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.externalModuleReference(requireKeyword, openParenToken, stringLiteral, closeParenToken); + }; + + ParserImpl.prototype.parseModuleNameModuleReference = function () { + var name = this.parseName(); + return this.factory.moduleNameModuleReference(name); + }; + + ParserImpl.prototype.parseIdentifierName = function () { + var identifierName = this.eatIdentifierNameToken(); + return identifierName; + }; + + ParserImpl.prototype.tryParseTypeArgumentList = function (inExpression) { + if (this.currentToken().kind() !== 80 /* LessThanToken */) { + return null; + } + + var lessThanToken; + var greaterThanToken; + var result; + var typeArguments; + + if (!inExpression) { + lessThanToken = this.eatToken(80 /* LessThanToken */); + + result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */); + typeArguments = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + return this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken); + } + + var rewindPoint = this.getRewindPoint(); + + lessThanToken = this.eatToken(80 /* LessThanToken */); + + result = this.parseSeparatedSyntaxList(262144 /* TypeArgumentList_Types */); + typeArguments = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + if (greaterThanToken.fullWidth() === 0 || !this.canFollowTypeArgumentListInExpression(this.currentToken().kind())) { + this.rewind(rewindPoint); + + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + var typeArgumentList = this.factory.typeArgumentList(lessThanToken, typeArguments, greaterThanToken); + + return typeArgumentList; + } + }; + + ParserImpl.prototype.canFollowTypeArgumentListInExpression = function (kind) { + switch (kind) { + case 72 /* OpenParenToken */: + case 76 /* DotToken */: + + case 73 /* CloseParenToken */: + case 75 /* CloseBracketToken */: + case 106 /* ColonToken */: + case 78 /* SemicolonToken */: + case 79 /* CommaToken */: + case 105 /* QuestionToken */: + case 84 /* EqualsEqualsToken */: + case 87 /* EqualsEqualsEqualsToken */: + case 86 /* ExclamationEqualsToken */: + case 88 /* ExclamationEqualsEqualsToken */: + case 103 /* AmpersandAmpersandToken */: + case 104 /* BarBarToken */: + case 100 /* CaretToken */: + case 98 /* AmpersandToken */: + case 99 /* BarToken */: + case 71 /* CloseBraceToken */: + case 10 /* EndOfFileToken */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.parseName = function () { + var shouldContinue = this.isIdentifier(this.currentToken()); + var current = this.eatIdentifierToken(); + + while (shouldContinue && this.currentToken().tokenKind === 76 /* DotToken */) { + var dotToken = this.eatToken(76 /* DotToken */); + + var currentToken = this.currentToken(); + var identifierName; + + if (TypeScript.SyntaxFacts.isAnyKeyword(currentToken.tokenKind) && this.previousToken().hasTrailingNewLine() && !currentToken.hasTrailingNewLine() && TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.peekToken(1))) { + identifierName = this.createMissingToken(11 /* IdentifierName */, currentToken); + } else { + identifierName = this.eatIdentifierNameToken(); + } + + current = this.factory.qualifiedName(current, dotToken, identifierName); + + shouldContinue = identifierName.fullWidth() > 0; + } + + return current; + }; + + ParserImpl.prototype.isEnumDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 46 /* EnumKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 46 /* EnumKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseEnumDeclaration = function () { + var modifiers = this.parseModifiers(); + var enumKeyword = this.eatKeyword(46 /* EnumKeyword */); + var identifier = this.eatIdentifierToken(); + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + var enumElements = TypeScript.Syntax.emptySeparatedList; + + if (openBraceToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(256 /* EnumDeclaration_EnumElements */); + enumElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.enumDeclaration(modifiers, enumKeyword, identifier, openBraceToken, enumElements, closeBraceToken); + }; + + ParserImpl.prototype.isEnumElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) { + return true; + } + + return this.isPropertyName(this.currentToken(), inErrorRecovery); + }; + + ParserImpl.prototype.parseEnumElement = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 243 /* EnumElement */) { + return this.eatNode(); + } + + var propertyName = this.eatPropertyName(); + var equalsValueClause = null; + if (this.isEqualsValueClause(false)) { + equalsValueClause = this.parseEqualsValueClause(true); + } + + return this.factory.enumElement(propertyName, equalsValueClause); + }; + + ParserImpl.isModifier = function (token) { + switch (token.tokenKind) { + case 57 /* PublicKeyword */: + case 55 /* PrivateKeyword */: + case 58 /* StaticKeyword */: + case 47 /* ExportKeyword */: + case 63 /* DeclareKeyword */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.modifierCount = function () { + var modifierCount = 0; + while (true) { + if (ParserImpl.isModifier(this.peekToken(modifierCount))) { + modifierCount++; + continue; + } + + break; + } + + return modifierCount; + }; + + ParserImpl.prototype.parseModifiers = function () { + var tokens = this.getArray(); + + while (true) { + if (ParserImpl.isModifier(this.currentToken())) { + tokens.push(this.eatAnyToken()); + continue; + } + + break; + } + + var result = TypeScript.Syntax.list(tokens); + + this.returnZeroOrOneLengthArray(tokens); + + return result; + }; + + ParserImpl.prototype.isClassDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 44 /* ClassKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 44 /* ClassKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseHeritageClauses = function () { + var heritageClauses = TypeScript.Syntax.emptyList; + + if (this.isHeritageClause()) { + var result = this.parseSyntaxList(1024 /* ClassOrInterfaceDeclaration_HeritageClauses */); + heritageClauses = result.list; + TypeScript.Debug.assert(result.skippedTokens.length === 0); + } + + return heritageClauses; + }; + + ParserImpl.prototype.parseClassDeclaration = function () { + var modifiers = this.parseModifiers(); + + var classKeyword = this.eatKeyword(44 /* ClassKeyword */); + var identifier = this.eatIdentifierToken(); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var heritageClauses = this.parseHeritageClauses(); + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + var classElements = TypeScript.Syntax.emptyList; + + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(2 /* ClassDeclaration_ClassElements */); + + classElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.classDeclaration(modifiers, classKeyword, identifier, typeParameterList, heritageClauses, openBraceToken, classElements, closeBraceToken); + }; + + ParserImpl.isPublicOrPrivateKeyword = function (token) { + return token.tokenKind === 57 /* PublicKeyword */ || token.tokenKind === 55 /* PrivateKeyword */; + }; + + ParserImpl.prototype.isAccessor = function (inErrorRecovery) { + var index = this.modifierCount(); + + if (this.peekToken(index).tokenKind !== 64 /* GetKeyword */ && this.peekToken(index).tokenKind !== 68 /* SetKeyword */) { + return false; + } + + index++; + return this.isPropertyName(this.peekToken(index), inErrorRecovery); + }; + + ParserImpl.prototype.parseAccessor = function (checkForStrictMode) { + var modifiers = this.parseModifiers(); + + if (this.currentToken().tokenKind === 64 /* GetKeyword */) { + return this.parseGetMemberAccessorDeclaration(modifiers, checkForStrictMode); + } else if (this.currentToken().tokenKind === 68 /* SetKeyword */) { + return this.parseSetMemberAccessorDeclaration(modifiers, checkForStrictMode); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseGetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) { + var getKeyword = this.eatKeyword(64 /* GetKeyword */); + var propertyName = this.eatPropertyName(); + var parameterList = this.parseParameterList(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + var block = this.parseBlock(false, checkForStrictMode); + + return this.factory.getAccessor(modifiers, getKeyword, propertyName, parameterList, typeAnnotation, block); + }; + + ParserImpl.prototype.parseSetMemberAccessorDeclaration = function (modifiers, checkForStrictMode) { + var setKeyword = this.eatKeyword(68 /* SetKeyword */); + var propertyName = this.eatPropertyName(); + var parameterList = this.parseParameterList(); + var block = this.parseBlock(false, checkForStrictMode); + + return this.factory.setAccessor(modifiers, setKeyword, propertyName, parameterList, block); + }; + + ParserImpl.prototype.isClassElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isClassElement()) { + return true; + } + + return this.isConstructorDeclaration() || this.isMemberFunctionDeclaration(inErrorRecovery) || this.isAccessor(inErrorRecovery) || this.isMemberVariableDeclaration(inErrorRecovery) || this.isIndexMemberDeclaration(); + }; + + ParserImpl.prototype.parseClassElement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isClassElement()) { + return this.eatNode(); + } + + if (this.isConstructorDeclaration()) { + return this.parseConstructorDeclaration(); + } else if (this.isMemberFunctionDeclaration(inErrorRecovery)) { + return this.parseMemberFunctionDeclaration(); + } else if (this.isAccessor(inErrorRecovery)) { + return this.parseAccessor(false); + } else if (this.isMemberVariableDeclaration(inErrorRecovery)) { + return this.parseMemberVariableDeclaration(); + } else if (this.isIndexMemberDeclaration()) { + return this.parseIndexMemberDeclaration(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isConstructorDeclaration = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 62 /* ConstructorKeyword */ && this.peekToken(index + 1).tokenKind === 72 /* OpenParenToken */; + }; + + ParserImpl.prototype.parseConstructorDeclaration = function () { + var modifiers = this.parseModifiers(); + var constructorKeyword = this.eatKeyword(62 /* ConstructorKeyword */); + var parameterList = this.parseParameterList(); + + var semicolonToken = null; + var block = null; + + if (this.isBlock()) { + block = this.parseBlock(false, true); + } else { + semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.constructorDeclaration(modifiers, constructorKeyword, parameterList, block, semicolonToken); + }; + + ParserImpl.prototype.isMemberFunctionDeclaration = function (inErrorRecovery) { + var index = 0; + + while (true) { + var token = this.peekToken(index); + if (this.isPropertyName(token, inErrorRecovery) && this.isCallSignature(index + 1)) { + return true; + } + + if (ParserImpl.isModifier(token)) { + index++; + continue; + } + + return false; + } + }; + + ParserImpl.prototype.parseMemberFunctionDeclaration = function () { + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (this.isPropertyName(currentToken, false) && this.isCallSignature(1)) { + break; + } + + TypeScript.Debug.assert(ParserImpl.isModifier(currentToken)); + modifierArray.push(this.eatAnyToken()); + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var propertyName = this.eatPropertyName(); + var callSignature = this.parseCallSignature(false); + + var parseBlockEvenWithNoOpenBrace = false; + var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature); + if (newCallSignature !== callSignature) { + parseBlockEvenWithNoOpenBrace = true; + callSignature = newCallSignature; + } + + var block = null; + var semicolon = null; + + if (parseBlockEvenWithNoOpenBrace || this.isBlock()) { + block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true); + } else { + semicolon = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.memberFunctionDeclaration(modifiers, propertyName, callSignature, block, semicolon); + }; + + ParserImpl.prototype.isDefinitelyMemberVariablePropertyName = function (index) { + if (TypeScript.SyntaxFacts.isAnyKeyword(this.peekToken(index).tokenKind)) { + switch (this.peekToken(index + 1).tokenKind) { + case 78 /* SemicolonToken */: + case 107 /* EqualsToken */: + case 106 /* ColonToken */: + case 71 /* CloseBraceToken */: + case 10 /* EndOfFileToken */: + return true; + default: + return false; + } + } else { + return true; + } + }; + + ParserImpl.prototype.isMemberVariableDeclaration = function (inErrorRecovery) { + var index = 0; + + while (true) { + var token = this.peekToken(index); + if (this.isPropertyName(token, inErrorRecovery) && this.isDefinitelyMemberVariablePropertyName(index)) { + return true; + } + + if (ParserImpl.isModifier(this.peekToken(index))) { + index++; + continue; + } + + return false; + } + }; + + ParserImpl.prototype.parseMemberVariableDeclaration = function () { + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (this.isPropertyName(currentToken, false) && this.isDefinitelyMemberVariablePropertyName(0)) { + break; + } + + TypeScript.Debug.assert(ParserImpl.isModifier(currentToken)); + modifierArray.push(this.eatAnyToken()); + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var variableDeclarator = this.parseVariableDeclarator(true, true); + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.memberVariableDeclaration(modifiers, variableDeclarator, semicolon); + }; + + ParserImpl.prototype.isIndexMemberDeclaration = function () { + var index = this.modifierCount(); + return this.isIndexSignature(index); + }; + + ParserImpl.prototype.parseIndexMemberDeclaration = function () { + var modifiers = this.parseModifiers(); + var indexSignature = this.parseIndexSignature(); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.indexMemberDeclaration(modifiers, indexSignature, semicolonToken); + }; + + ParserImpl.prototype.tryAddUnexpectedEqualsGreaterThanToken = function (callSignature) { + var token0 = this.currentToken(); + + var hasEqualsGreaterThanToken = token0.tokenKind === 85 /* EqualsGreaterThanToken */; + if (hasEqualsGreaterThanToken) { + if (callSignature.lastToken()) { + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [TypeScript.SyntaxFacts.getText(70 /* OpenBraceToken */)]); + this.addDiagnostic(diagnostic); + + var token = this.eatAnyToken(); + return this.addSkippedTokenAfterNode(callSignature, token0); + } + } + + return callSignature; + }; + + ParserImpl.prototype.isFunctionDeclaration = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 27 /* FunctionKeyword */; + }; + + ParserImpl.prototype.parseFunctionDeclaration = function () { + var modifiers = this.parseModifiers(); + var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */); + var identifier = this.eatIdentifierToken(); + var callSignature = this.parseCallSignature(false); + + var parseBlockEvenWithNoOpenBrace = false; + var newCallSignature = this.tryAddUnexpectedEqualsGreaterThanToken(callSignature); + if (newCallSignature !== callSignature) { + parseBlockEvenWithNoOpenBrace = true; + callSignature = newCallSignature; + } + + var semicolonToken = null; + var block = null; + + if (parseBlockEvenWithNoOpenBrace || this.isBlock()) { + block = this.parseBlock(parseBlockEvenWithNoOpenBrace, true); + } else { + semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + } + + return this.factory.functionDeclaration(modifiers, functionKeyword, identifier, callSignature, block, semicolonToken); + }; + + ParserImpl.prototype.isModuleDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 65 /* ModuleKeyword */) { + return true; + } + + if (this.currentToken().tokenKind === 65 /* ModuleKeyword */) { + var token1 = this.peekToken(1); + return this.isIdentifier(token1) || token1.tokenKind === 14 /* StringLiteral */; + } + + return false; + }; + + ParserImpl.prototype.parseModuleDeclaration = function () { + var modifiers = this.parseModifiers(); + var moduleKeyword = this.eatKeyword(65 /* ModuleKeyword */); + + var moduleName = null; + var stringLiteral = null; + + if (this.currentToken().tokenKind === 14 /* StringLiteral */) { + stringLiteral = this.eatToken(14 /* StringLiteral */); + } else { + moduleName = this.parseName(); + } + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var moduleElements = TypeScript.Syntax.emptyList; + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(4 /* ModuleDeclaration_ModuleElements */); + moduleElements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.moduleDeclaration(modifiers, moduleKeyword, moduleName, stringLiteral, openBraceToken, moduleElements, closeBraceToken); + }; + + ParserImpl.prototype.isInterfaceDeclaration = function (modifierCount) { + if (modifierCount > 0 && this.peekToken(modifierCount).tokenKind === 52 /* InterfaceKeyword */) { + return true; + } + + return this.currentToken().tokenKind === 52 /* InterfaceKeyword */ && this.isIdentifier(this.peekToken(1)); + }; + + ParserImpl.prototype.parseInterfaceDeclaration = function () { + var modifiers = this.parseModifiers(); + var interfaceKeyword = this.eatKeyword(52 /* InterfaceKeyword */); + var identifier = this.eatIdentifierToken(); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var heritageClauses = this.parseHeritageClauses(); + + var objectType = this.parseObjectType(); + return this.factory.interfaceDeclaration(modifiers, interfaceKeyword, identifier, typeParameterList, heritageClauses, objectType); + }; + + ParserImpl.prototype.parseObjectType = function () { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var typeMembers = TypeScript.Syntax.emptySeparatedList; + if (openBraceToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(512 /* ObjectType_TypeMembers */); + typeMembers = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.objectType(openBraceToken, typeMembers, closeBraceToken); + }; + + ParserImpl.prototype.isTypeMember = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isTypeMember()) { + return true; + } + + return this.isCallSignature(0) || this.isConstructSignature() || this.isIndexSignature(0) || this.isMethodSignature(inErrorRecovery) || this.isPropertySignature(inErrorRecovery); + }; + + ParserImpl.prototype.parseTypeMember = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isTypeMember()) { + return this.eatNode(); + } + + if (this.isCallSignature(0)) { + return this.parseCallSignature(false); + } else if (this.isConstructSignature()) { + return this.parseConstructSignature(); + } else if (this.isIndexSignature(0)) { + return this.parseIndexSignature(); + } else if (this.isMethodSignature(inErrorRecovery)) { + return this.parseMethodSignature(); + } else if (this.isPropertySignature(inErrorRecovery)) { + return this.parsePropertySignature(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseConstructSignature = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + var callSignature = this.parseCallSignature(false); + + return this.factory.constructSignature(newKeyword, callSignature); + }; + + ParserImpl.prototype.parseIndexSignature = function () { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var parameter = this.parseParameter(); + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.indexSignature(openBracketToken, parameter, closeBracketToken, typeAnnotation); + }; + + ParserImpl.prototype.parseMethodSignature = function () { + var propertyName = this.eatPropertyName(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var callSignature = this.parseCallSignature(false); + + return this.factory.methodSignature(propertyName, questionToken, callSignature); + }; + + ParserImpl.prototype.parsePropertySignature = function () { + var propertyName = this.eatPropertyName(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.propertySignature(propertyName, questionToken, typeAnnotation); + }; + + ParserImpl.prototype.isCallSignature = function (tokenIndex) { + var tokenKind = this.peekToken(tokenIndex).tokenKind; + return tokenKind === 72 /* OpenParenToken */ || tokenKind === 80 /* LessThanToken */; + }; + + ParserImpl.prototype.isConstructSignature = function () { + if (this.currentToken().tokenKind !== 31 /* NewKeyword */) { + return false; + } + + var token1 = this.peekToken(1); + return token1.tokenKind === 80 /* LessThanToken */ || token1.tokenKind === 72 /* OpenParenToken */; + }; + + ParserImpl.prototype.isIndexSignature = function (tokenIndex) { + return this.peekToken(tokenIndex).tokenKind === 74 /* OpenBracketToken */; + }; + + ParserImpl.prototype.isMethodSignature = function (inErrorRecovery) { + if (this.isPropertyName(this.currentToken(), inErrorRecovery)) { + if (this.isCallSignature(1)) { + return true; + } + + if (this.peekToken(1).tokenKind === 105 /* QuestionToken */ && this.isCallSignature(2)) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.isPropertySignature = function (inErrorRecovery) { + var currentToken = this.currentToken(); + + if (ParserImpl.isModifier(currentToken) && !currentToken.hasTrailingNewLine() && this.isPropertyName(this.peekToken(1), inErrorRecovery)) { + return false; + } + + return this.isPropertyName(currentToken, inErrorRecovery); + }; + + ParserImpl.prototype.isHeritageClause = function () { + var token0 = this.currentToken(); + return token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */; + }; + + ParserImpl.prototype.isNotHeritageClauseTypeName = function () { + if (this.currentToken().tokenKind === 51 /* ImplementsKeyword */ || this.currentToken().tokenKind === 48 /* ExtendsKeyword */) { + return this.isIdentifier(this.peekToken(1)); + } + + return false; + }; + + ParserImpl.prototype.isHeritageClauseTypeName = function () { + if (this.isIdentifier(this.currentToken())) { + return !this.isNotHeritageClauseTypeName(); + } + + return false; + }; + + ParserImpl.prototype.parseHeritageClause = function () { + var extendsOrImplementsKeyword = this.eatAnyToken(); + TypeScript.Debug.assert(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ || extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + + var result = this.parseSeparatedSyntaxList(2048 /* HeritageClause_TypeNameList */); + var typeNames = result.list; + extendsOrImplementsKeyword = this.addSkippedTokensAfterToken(extendsOrImplementsKeyword, result.skippedTokens); + + return this.factory.heritageClause(extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, extendsOrImplementsKeyword, typeNames); + }; + + ParserImpl.prototype.isStatement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isStatement()) { + return true; + } + + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 57 /* PublicKeyword */: + case 55 /* PrivateKeyword */: + case 58 /* StaticKeyword */: + var token1 = this.peekToken(1); + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token1)) { + return false; + } + + break; + + case 28 /* IfKeyword */: + case 70 /* OpenBraceToken */: + case 33 /* ReturnKeyword */: + case 34 /* SwitchKeyword */: + case 36 /* ThrowKeyword */: + case 15 /* BreakKeyword */: + case 18 /* ContinueKeyword */: + case 26 /* ForKeyword */: + case 42 /* WhileKeyword */: + case 43 /* WithKeyword */: + case 22 /* DoKeyword */: + case 38 /* TryKeyword */: + case 19 /* DebuggerKeyword */: + return true; + } + + if (this.isInterfaceDeclaration(0) || this.isClassDeclaration(0) || this.isEnumDeclaration(0) || this.isModuleDeclaration(0)) { + return false; + } + + return this.isLabeledStatement(currentToken) || this.isVariableStatement() || this.isFunctionDeclaration() || this.isEmptyStatement(currentToken, inErrorRecovery) || this.isExpressionStatement(currentToken); + }; + + ParserImpl.prototype.parseStatement = function (inErrorRecovery) { + if (this.currentNode() !== null && this.currentNode().isStatement()) { + return this.eatNode(); + } + + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + switch (currentTokenKind) { + case 28 /* IfKeyword */: + return this.parseIfStatement(); + case 70 /* OpenBraceToken */: + return this.parseBlock(false, false); + case 33 /* ReturnKeyword */: + return this.parseReturnStatement(); + case 34 /* SwitchKeyword */: + return this.parseSwitchStatement(); + case 36 /* ThrowKeyword */: + return this.parseThrowStatement(); + case 15 /* BreakKeyword */: + return this.parseBreakStatement(); + case 18 /* ContinueKeyword */: + return this.parseContinueStatement(); + case 26 /* ForKeyword */: + return this.parseForOrForInStatement(); + case 42 /* WhileKeyword */: + return this.parseWhileStatement(); + case 43 /* WithKeyword */: + return this.parseWithStatement(); + case 22 /* DoKeyword */: + return this.parseDoStatement(); + case 38 /* TryKeyword */: + return this.parseTryStatement(); + case 19 /* DebuggerKeyword */: + return this.parseDebuggerStatement(); + } + + if (this.isVariableStatement()) { + return this.parseVariableStatement(); + } else if (this.isLabeledStatement(currentToken)) { + return this.parseLabeledStatement(); + } else if (this.isFunctionDeclaration()) { + return this.parseFunctionDeclaration(); + } else if (this.isEmptyStatement(currentToken, inErrorRecovery)) { + return this.parseEmptyStatement(); + } else { + return this.parseExpressionStatement(); + } + }; + + ParserImpl.prototype.parseDebuggerStatement = function () { + var debuggerKeyword = this.eatKeyword(19 /* DebuggerKeyword */); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.debuggerStatement(debuggerKeyword, semicolonToken); + }; + + ParserImpl.prototype.parseDoStatement = function () { + var doKeyword = this.eatKeyword(22 /* DoKeyword */); + var statement = this.parseStatement(false); + var whileKeyword = this.eatKeyword(42 /* WhileKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(true); + + return this.factory.doStatement(doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken); + }; + + ParserImpl.prototype.isLabeledStatement = function (currentToken) { + return this.isIdentifier(currentToken) && this.peekToken(1).tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.parseLabeledStatement = function () { + var identifier = this.eatIdentifierToken(); + var colonToken = this.eatToken(106 /* ColonToken */); + var statement = this.parseStatement(false); + + return this.factory.labeledStatement(identifier, colonToken, statement); + }; + + ParserImpl.prototype.parseTryStatement = function () { + var tryKeyword = this.eatKeyword(38 /* TryKeyword */); + + var savedListParsingState = this.listParsingState; + this.listParsingState |= 64 /* TryBlock_Statements */; + var block = this.parseBlock(false, false); + this.listParsingState = savedListParsingState; + + var catchClause = null; + if (this.isCatchClause()) { + catchClause = this.parseCatchClause(); + } + + var finallyClause = null; + if (catchClause === null || this.isFinallyClause()) { + finallyClause = this.parseFinallyClause(); + } + + return this.factory.tryStatement(tryKeyword, block, catchClause, finallyClause); + }; + + ParserImpl.prototype.isCatchClause = function () { + return this.currentToken().tokenKind === 17 /* CatchKeyword */; + }; + + ParserImpl.prototype.parseCatchClause = function () { + var catchKeyword = this.eatKeyword(17 /* CatchKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var identifier = this.eatIdentifierToken(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var savedListParsingState = this.listParsingState; + this.listParsingState |= 128 /* CatchBlock_Statements */; + var block = this.parseBlock(false, false); + this.listParsingState = savedListParsingState; + + return this.factory.catchClause(catchKeyword, openParenToken, identifier, typeAnnotation, closeParenToken, block); + }; + + ParserImpl.prototype.isFinallyClause = function () { + return this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.parseFinallyClause = function () { + var finallyKeyword = this.eatKeyword(25 /* FinallyKeyword */); + var block = this.parseBlock(false, false); + + return this.factory.finallyClause(finallyKeyword, block); + }; + + ParserImpl.prototype.parseWithStatement = function () { + var withKeyword = this.eatKeyword(43 /* WithKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.withStatement(withKeyword, openParenToken, condition, closeParenToken, statement); + }; + + ParserImpl.prototype.parseWhileStatement = function () { + var whileKeyword = this.eatKeyword(42 /* WhileKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.whileStatement(whileKeyword, openParenToken, condition, closeParenToken, statement); + }; + + ParserImpl.prototype.isEmptyStatement = function (currentToken, inErrorRecovery) { + if (inErrorRecovery) { + return false; + } + + return currentToken.tokenKind === 78 /* SemicolonToken */; + }; + + ParserImpl.prototype.parseEmptyStatement = function () { + var semicolonToken = this.eatToken(78 /* SemicolonToken */); + return this.factory.emptyStatement(semicolonToken); + }; + + ParserImpl.prototype.parseForOrForInStatement = function () { + var forKeyword = this.eatKeyword(26 /* ForKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + + var currentToken = this.currentToken(); + if (currentToken.tokenKind === 40 /* VarKeyword */) { + return this.parseForOrForInStatementWithVariableDeclaration(forKeyword, openParenToken); + } else if (currentToken.tokenKind === 78 /* SemicolonToken */) { + return this.parseForStatementWithNoVariableDeclarationOrInitializer(forKeyword, openParenToken); + } else { + return this.parseForOrForInStatementWithInitializer(forKeyword, openParenToken); + } + }; + + ParserImpl.prototype.parseForOrForInStatementWithVariableDeclaration = function (forKeyword, openParenToken) { + var variableDeclaration = this.parseVariableDeclaration(false); + + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null); + } + + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, variableDeclaration, null); + }; + + ParserImpl.prototype.parseForInStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) { + var inKeyword = this.eatKeyword(29 /* InKeyword */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.forInStatement(forKeyword, openParenToken, variableDeclaration, initializer, inKeyword, expression, closeParenToken, statement); + }; + + ParserImpl.prototype.parseForOrForInStatementWithInitializer = function (forKeyword, openParenToken) { + var initializer = this.parseExpression(false); + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return this.parseForInStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer); + } else { + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, initializer); + } + }; + + ParserImpl.prototype.parseForStatementWithNoVariableDeclarationOrInitializer = function (forKeyword, openParenToken) { + return this.parseForStatementWithVariableDeclarationOrInitializer(forKeyword, openParenToken, null, null); + }; + + ParserImpl.prototype.parseForStatementWithVariableDeclarationOrInitializer = function (forKeyword, openParenToken, variableDeclaration, initializer) { + var firstSemicolonToken = this.eatToken(78 /* SemicolonToken */); + + var condition = null; + if (this.currentToken().tokenKind !== 78 /* SemicolonToken */ && this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) { + condition = this.parseExpression(true); + } + + var secondSemicolonToken = this.eatToken(78 /* SemicolonToken */); + + var incrementor = null; + if (this.currentToken().tokenKind !== 73 /* CloseParenToken */ && this.currentToken().tokenKind !== 10 /* EndOfFileToken */) { + incrementor = this.parseExpression(true); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + return this.factory.forStatement(forKeyword, openParenToken, variableDeclaration, initializer, firstSemicolonToken, condition, secondSemicolonToken, incrementor, closeParenToken, statement); + }; + + ParserImpl.prototype.parseBreakStatement = function () { + var breakKeyword = this.eatKeyword(15 /* BreakKeyword */); + + var identifier = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + } + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + return this.factory.breakStatement(breakKeyword, identifier, semicolon); + }; + + ParserImpl.prototype.parseContinueStatement = function () { + var continueKeyword = this.eatKeyword(18 /* ContinueKeyword */); + + var identifier = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + } + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + return this.factory.continueStatement(continueKeyword, identifier, semicolon); + }; + + ParserImpl.prototype.parseSwitchStatement = function () { + var switchKeyword = this.eatKeyword(34 /* SwitchKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var switchClauses = TypeScript.Syntax.emptyList; + if (openBraceToken.width() > 0) { + var result = this.parseSyntaxList(8 /* SwitchStatement_SwitchClauses */); + switchClauses = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + return this.factory.switchStatement(switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, switchClauses, closeBraceToken); + }; + + ParserImpl.prototype.isCaseSwitchClause = function () { + return this.currentToken().tokenKind === 16 /* CaseKeyword */; + }; + + ParserImpl.prototype.isDefaultSwitchClause = function () { + return this.currentToken().tokenKind === 20 /* DefaultKeyword */; + }; + + ParserImpl.prototype.isSwitchClause = function () { + if (this.currentNode() !== null && this.currentNode().isSwitchClause()) { + return true; + } + + return this.isCaseSwitchClause() || this.isDefaultSwitchClause(); + }; + + ParserImpl.prototype.parseSwitchClause = function () { + if (this.currentNode() !== null && this.currentNode().isSwitchClause()) { + return this.eatNode(); + } + + if (this.isCaseSwitchClause()) { + return this.parseCaseSwitchClause(); + } else if (this.isDefaultSwitchClause()) { + return this.parseDefaultSwitchClause(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseCaseSwitchClause = function () { + var caseKeyword = this.eatKeyword(16 /* CaseKeyword */); + var expression = this.parseExpression(true); + var colonToken = this.eatToken(106 /* ColonToken */); + var statements = TypeScript.Syntax.emptyList; + + if (colonToken.fullWidth() > 0) { + var result = this.parseSyntaxList(16 /* SwitchClause_Statements */); + statements = result.list; + colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens); + } + + return this.factory.caseSwitchClause(caseKeyword, expression, colonToken, statements); + }; + + ParserImpl.prototype.parseDefaultSwitchClause = function () { + var defaultKeyword = this.eatKeyword(20 /* DefaultKeyword */); + var colonToken = this.eatToken(106 /* ColonToken */); + var statements = TypeScript.Syntax.emptyList; + + if (colonToken.fullWidth() > 0) { + var result = this.parseSyntaxList(16 /* SwitchClause_Statements */); + statements = result.list; + colonToken = this.addSkippedTokensAfterToken(colonToken, result.skippedTokens); + } + + return this.factory.defaultSwitchClause(defaultKeyword, colonToken, statements); + }; + + ParserImpl.prototype.parseThrowStatement = function () { + var throwKeyword = this.eatKeyword(36 /* ThrowKeyword */); + + var expression = null; + if (this.canEatExplicitOrAutomaticSemicolon(false)) { + var token = this.createMissingToken(11 /* IdentifierName */, null); + expression = token; + } else { + expression = this.parseExpression(true); + } + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.throwStatement(throwKeyword, expression, semicolonToken); + }; + + ParserImpl.prototype.parseReturnStatement = function () { + var returnKeyword = this.eatKeyword(33 /* ReturnKeyword */); + + var expression = null; + if (!this.canEatExplicitOrAutomaticSemicolon(false)) { + expression = this.parseExpression(true); + } + + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.returnStatement(returnKeyword, expression, semicolonToken); + }; + + ParserImpl.prototype.isExpressionStatement = function (currentToken) { + var kind = currentToken.tokenKind; + if (kind === 70 /* OpenBraceToken */ || kind === 27 /* FunctionKeyword */) { + return false; + } + + return this.isExpression(currentToken); + }; + + ParserImpl.prototype.isAssignmentOrOmittedExpression = function () { + var currentToken = this.currentToken(); + if (currentToken.tokenKind === 79 /* CommaToken */) { + return true; + } + + return this.isExpression(currentToken); + }; + + ParserImpl.prototype.parseAssignmentOrOmittedExpression = function () { + if (this.currentToken().tokenKind === 79 /* CommaToken */) { + return this.factory.omittedExpression(); + } + + return this.parseAssignmentExpression(true); + }; + + ParserImpl.prototype.isExpression = function (currentToken) { + switch (currentToken.tokenKind) { + case 13 /* NumericLiteral */: + case 14 /* StringLiteral */: + case 12 /* RegularExpressionLiteral */: + + case 74 /* OpenBracketToken */: + + case 72 /* OpenParenToken */: + + case 80 /* LessThanToken */: + + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + case 89 /* PlusToken */: + case 90 /* MinusToken */: + case 102 /* TildeToken */: + case 101 /* ExclamationToken */: + + case 70 /* OpenBraceToken */: + + case 85 /* EqualsGreaterThanToken */: + + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + + case 50 /* SuperKeyword */: + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + + case 31 /* NewKeyword */: + + case 21 /* DeleteKeyword */: + case 41 /* VoidKeyword */: + case 39 /* TypeOfKeyword */: + + case 27 /* FunctionKeyword */: + return true; + } + + return this.isIdentifier(currentToken); + }; + + ParserImpl.prototype.parseExpressionStatement = function () { + var expression = this.parseExpression(true); + + var semicolon = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.expressionStatement(expression, semicolon); + }; + + ParserImpl.prototype.parseIfStatement = function () { + var ifKeyword = this.eatKeyword(28 /* IfKeyword */); + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var condition = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + var statement = this.parseStatement(false); + + var elseClause = null; + if (this.isElseClause()) { + elseClause = this.parseElseClause(); + } + + return this.factory.ifStatement(ifKeyword, openParenToken, condition, closeParenToken, statement, elseClause); + }; + + ParserImpl.prototype.isElseClause = function () { + return this.currentToken().tokenKind === 23 /* ElseKeyword */; + }; + + ParserImpl.prototype.parseElseClause = function () { + var elseKeyword = this.eatKeyword(23 /* ElseKeyword */); + var statement = this.parseStatement(false); + + return this.factory.elseClause(elseKeyword, statement); + }; + + ParserImpl.prototype.isVariableStatement = function () { + var index = this.modifierCount(); + return this.peekToken(index).tokenKind === 40 /* VarKeyword */; + }; + + ParserImpl.prototype.parseVariableStatement = function () { + var modifiers = this.parseModifiers(); + var variableDeclaration = this.parseVariableDeclaration(true); + var semicolonToken = this.eatExplicitOrAutomaticSemicolon(false); + + return this.factory.variableStatement(modifiers, variableDeclaration, semicolonToken); + }; + + ParserImpl.prototype.parseVariableDeclaration = function (allowIn) { + var varKeyword = this.eatKeyword(40 /* VarKeyword */); + + var listParsingState = allowIn ? 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */ : 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */; + + var result = this.parseSeparatedSyntaxList(listParsingState); + var variableDeclarators = result.list; + varKeyword = this.addSkippedTokensAfterToken(varKeyword, result.skippedTokens); + + return this.factory.variableDeclaration(varKeyword, variableDeclarators); + }; + + ParserImpl.prototype.isVariableDeclarator = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 225 /* VariableDeclarator */) { + return true; + } + + return this.isIdentifier(this.currentToken()); + }; + + ParserImpl.prototype.canReuseVariableDeclaratorNode = function (node) { + if (node === null || node.kind() !== 225 /* VariableDeclarator */) { + return false; + } + + var variableDeclarator = node; + return variableDeclarator.equalsValueClause === null; + }; + + ParserImpl.prototype.parseVariableDeclarator = function (allowIn, allowPropertyName) { + if (this.canReuseVariableDeclaratorNode(this.currentNode())) { + return this.eatNode(); + } + + var propertyName = allowPropertyName ? this.eatPropertyName() : this.eatIdentifierToken(); + var equalsValueClause = null; + var typeAnnotation = null; + + if (propertyName.width() > 0) { + typeAnnotation = this.parseOptionalTypeAnnotation(false); + + if (this.isEqualsValueClause(false)) { + equalsValueClause = this.parseEqualsValueClause(allowIn); + } + } + + return this.factory.variableDeclarator(propertyName, typeAnnotation, equalsValueClause); + }; + + ParserImpl.prototype.isColonValueClause = function () { + return this.currentToken().tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.isEqualsValueClause = function (inParameter) { + var token0 = this.currentToken(); + if (token0.tokenKind === 107 /* EqualsToken */) { + return true; + } + + if (!this.previousToken().hasTrailingNewLine()) { + if (token0.tokenKind === 85 /* EqualsGreaterThanToken */) { + return false; + } + + if (token0.tokenKind === 70 /* OpenBraceToken */ && inParameter) { + return false; + } + + return this.isExpression(token0); + } + + return false; + }; + + ParserImpl.prototype.parseEqualsValueClause = function (allowIn) { + var equalsToken = this.eatToken(107 /* EqualsToken */); + var value = this.parseAssignmentExpression(allowIn); + + return this.factory.equalsValueClause(equalsToken, value); + }; + + ParserImpl.prototype.parseExpression = function (allowIn) { + return this.parseSubExpression(0, allowIn); + }; + + ParserImpl.prototype.parseAssignmentExpression = function (allowIn) { + return this.parseSubExpression(2 /* AssignmentExpressionPrecedence */, allowIn); + }; + + ParserImpl.prototype.parseUnaryExpressionOrLower = function () { + var currentTokenKind = this.currentToken().tokenKind; + if (TypeScript.SyntaxFacts.isPrefixUnaryExpressionOperatorToken(currentTokenKind)) { + var operatorKind = TypeScript.SyntaxFacts.getPrefixUnaryExpressionFromOperatorToken(currentTokenKind); + + var operatorToken = this.eatAnyToken(); + + var operand = this.parseUnaryExpressionOrLower(); + return this.factory.prefixUnaryExpression(operatorKind, operatorToken, operand); + } else if (currentTokenKind === 39 /* TypeOfKeyword */) { + return this.parseTypeOfExpression(); + } else if (currentTokenKind === 41 /* VoidKeyword */) { + return this.parseVoidExpression(); + } else if (currentTokenKind === 21 /* DeleteKeyword */) { + return this.parseDeleteExpression(); + } else if (currentTokenKind === 80 /* LessThanToken */) { + return this.parseCastExpression(); + } else { + return this.parsePostfixExpressionOrLower(); + } + }; + + ParserImpl.prototype.parseSubExpression = function (precedence, allowIn) { + if (precedence <= 2 /* AssignmentExpressionPrecedence */) { + if (this.isSimpleArrowFunctionExpression()) { + return this.parseSimpleArrowFunctionExpression(); + } + + var parethesizedArrowFunction = this.tryParseParenthesizedArrowFunctionExpression(); + if (parethesizedArrowFunction !== null) { + return parethesizedArrowFunction; + } + } + + var leftOperand = this.parseUnaryExpressionOrLower(); + return this.parseBinaryOrConditionalExpressions(precedence, allowIn, leftOperand); + }; + + ParserImpl.prototype.parseBinaryOrConditionalExpressions = function (precedence, allowIn, leftOperand) { + while (true) { + var token0 = this.currentToken(); + var token0Kind = token0.tokenKind; + + if (TypeScript.SyntaxFacts.isBinaryExpressionOperatorToken(token0Kind)) { + if (token0Kind === 29 /* InKeyword */ && !allowIn) { + break; + } + + var mergedToken = this.tryMergeBinaryExpressionTokens(); + var tokenKind = mergedToken === null ? token0Kind : mergedToken.syntaxKind; + + var binaryExpressionKind = TypeScript.SyntaxFacts.getBinaryExpressionFromOperatorToken(tokenKind); + var newPrecedence = ParserImpl.getPrecedence(binaryExpressionKind); + + if (newPrecedence < precedence) { + break; + } + + if (newPrecedence === precedence && !this.isRightAssociative(binaryExpressionKind)) { + break; + } + + var operatorToken = mergedToken === null ? token0 : TypeScript.Syntax.token(mergedToken.syntaxKind).withLeadingTrivia(token0.leadingTrivia()).withTrailingTrivia(this.peekToken(mergedToken.tokenCount - 1).trailingTrivia()); + + var skipCount = mergedToken === null ? 1 : mergedToken.tokenCount; + for (var i = 0; i < skipCount; i++) { + this.eatAnyToken(); + } + + leftOperand = this.factory.binaryExpression(binaryExpressionKind, leftOperand, operatorToken, this.parseSubExpression(newPrecedence, allowIn)); + continue; + } + + if (token0Kind === 105 /* QuestionToken */ && precedence <= 3 /* ConditionalExpressionPrecedence */) { + var questionToken = this.eatToken(105 /* QuestionToken */); + + var whenTrueExpression = this.parseAssignmentExpression(allowIn); + var colon = this.eatToken(106 /* ColonToken */); + + var whenFalseExpression = this.parseAssignmentExpression(allowIn); + leftOperand = this.factory.conditionalExpression(leftOperand, questionToken, whenTrueExpression, colon, whenFalseExpression); + continue; + } + + break; + } + + return leftOperand; + }; + + ParserImpl.prototype.tryMergeBinaryExpressionTokens = function () { + var token0 = this.currentToken(); + + if (token0.tokenKind === 81 /* GreaterThanToken */ && !token0.hasTrailingTrivia()) { + var storage = this.mergeTokensStorage; + storage[0] = 0 /* None */; + storage[1] = 0 /* None */; + storage[2] = 0 /* None */; + + for (var i = 0; i < storage.length; i++) { + var nextToken = this.peekToken(i + 1); + + if (!nextToken.hasLeadingTrivia()) { + storage[i] = nextToken.tokenKind; + } + + if (nextToken.hasTrailingTrivia()) { + break; + } + } + + if (storage[0] === 81 /* GreaterThanToken */) { + if (storage[1] === 81 /* GreaterThanToken */) { + if (storage[2] === 107 /* EqualsToken */) { + return { tokenCount: 4, syntaxKind: 114 /* GreaterThanGreaterThanGreaterThanEqualsToken */ }; + } else { + return { tokenCount: 3, syntaxKind: 97 /* GreaterThanGreaterThanGreaterThanToken */ }; + } + } else if (storage[1] === 107 /* EqualsToken */) { + return { tokenCount: 3, syntaxKind: 113 /* GreaterThanGreaterThanEqualsToken */ }; + } else { + return { tokenCount: 2, syntaxKind: 96 /* GreaterThanGreaterThanToken */ }; + } + } else if (storage[0] === 107 /* EqualsToken */) { + return { tokenCount: 2, syntaxKind: 83 /* GreaterThanEqualsToken */ }; + } + } + + return null; + }; + + ParserImpl.prototype.isRightAssociative = function (expressionKind) { + switch (expressionKind) { + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + return true; + default: + return false; + } + }; + + ParserImpl.prototype.parseMemberExpressionOrLower = function (inObjectCreation) { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } + + var expression = this.parsePrimaryExpression(); + if (expression === null) { + return this.eatIdentifierToken(); + } + + return this.parseMemberExpressionRest(expression, false, inObjectCreation); + }; + + ParserImpl.prototype.parseCallExpressionOrLower = function () { + var expression; + if (this.currentToken().tokenKind === 50 /* SuperKeyword */) { + expression = this.eatKeyword(50 /* SuperKeyword */); + + var currentTokenKind = this.currentToken().tokenKind; + if (currentTokenKind !== 72 /* OpenParenToken */ && currentTokenKind !== 76 /* DotToken */) { + expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken()); + } + } else { + expression = this.parseMemberExpressionOrLower(false); + } + + return this.parseMemberExpressionRest(expression, true, false); + }; + + ParserImpl.prototype.parseMemberExpressionRest = function (expression, allowArguments, inObjectCreation) { + while (true) { + var currentTokenKind = this.currentToken().tokenKind; + + switch (currentTokenKind) { + case 72 /* OpenParenToken */: + if (!allowArguments) { + return expression; + } + + expression = this.factory.invocationExpression(expression, this.parseArgumentList(null)); + continue; + + case 80 /* LessThanToken */: + if (!allowArguments) { + return expression; + } + + var argumentList = this.tryParseArgumentList(); + if (argumentList !== null) { + expression = this.factory.invocationExpression(expression, argumentList); + continue; + } + + break; + + case 74 /* OpenBracketToken */: + expression = this.parseElementAccessExpression(expression, inObjectCreation); + continue; + + case 76 /* DotToken */: + expression = this.factory.memberAccessExpression(expression, this.eatToken(76 /* DotToken */), this.eatIdentifierNameToken()); + continue; + } + + return expression; + } + }; + + ParserImpl.prototype.parseLeftHandSideExpressionOrLower = function () { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } else { + return this.parseCallExpressionOrLower(); + } + }; + + ParserImpl.prototype.parsePostfixExpressionOrLower = function () { + var expression = this.parseLeftHandSideExpressionOrLower(); + if (expression === null) { + return this.eatIdentifierToken(); + } + + var currentTokenKind = this.currentToken().tokenKind; + + switch (currentTokenKind) { + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + if (this.previousToken() !== null && this.previousToken().hasTrailingNewLine()) { + break; + } + + return this.factory.postfixUnaryExpression(TypeScript.SyntaxFacts.getPostfixUnaryExpressionFromOperatorToken(currentTokenKind), expression, this.eatAnyToken()); + } + + return expression; + }; + + ParserImpl.prototype.tryParseGenericArgumentList = function () { + var rewindPoint = this.getRewindPoint(); + + var typeArgumentList = this.tryParseTypeArgumentList(true); + var token0 = this.currentToken(); + + var isOpenParen = token0.tokenKind === 72 /* OpenParenToken */; + var isDot = token0.tokenKind === 76 /* DotToken */; + var isOpenParenOrDot = isOpenParen || isDot; + + var argumentList = null; + if (typeArgumentList === null || !isOpenParenOrDot) { + this.rewind(rewindPoint); + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + + if (isDot) { + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token0.width(), TypeScript.DiagnosticCode.A_parameter_list_must_follow_a_generic_type_argument_list_expected, null); + this.addDiagnostic(diagnostic); + + return this.factory.argumentList(typeArgumentList, TypeScript.Syntax.emptyToken(72 /* OpenParenToken */), TypeScript.Syntax.emptySeparatedList, TypeScript.Syntax.emptyToken(73 /* CloseParenToken */)); + } else { + return this.parseArgumentList(typeArgumentList); + } + } + }; + + ParserImpl.prototype.tryParseArgumentList = function () { + if (this.currentToken().tokenKind === 80 /* LessThanToken */) { + return this.tryParseGenericArgumentList(); + } + + if (this.currentToken().tokenKind === 72 /* OpenParenToken */) { + return this.parseArgumentList(null); + } + + return null; + }; + + ParserImpl.prototype.parseArgumentList = function (typeArgumentList) { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + + var _arguments = TypeScript.Syntax.emptySeparatedList; + + if (openParenToken.fullWidth() > 0) { + var result = this.parseSeparatedSyntaxList(16384 /* ArgumentList_AssignmentExpressions */); + _arguments = result.list; + openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.argumentList(typeArgumentList, openParenToken, _arguments, closeParenToken); + }; + + ParserImpl.prototype.parseElementAccessExpression = function (expression, inObjectCreation) { + var start = this.currentTokenStart(); + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var argumentExpression; + + if (this.currentToken().tokenKind === 75 /* CloseBracketToken */ && inObjectCreation) { + var end = this.currentTokenStart() + this.currentToken().width(); + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, start, end - start, TypeScript.DiagnosticCode.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead, null); + this.addDiagnostic(diagnostic); + + argumentExpression = TypeScript.Syntax.emptyToken(11 /* IdentifierName */); + } else { + argumentExpression = this.parseExpression(true); + } + + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + return this.factory.elementAccessExpression(expression, openBracketToken, argumentExpression, closeBracketToken); + }; + + ParserImpl.prototype.parsePrimaryExpression = function () { + var currentToken = this.currentToken(); + + if (this.isIdentifier(currentToken)) { + return this.eatIdentifierToken(); + } + + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 35 /* ThisKeyword */: + return this.parseThisExpression(); + + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return this.parseLiteralExpression(); + + case 32 /* NullKeyword */: + return this.parseLiteralExpression(); + + case 27 /* FunctionKeyword */: + return this.parseFunctionExpression(); + + case 13 /* NumericLiteral */: + return this.parseLiteralExpression(); + + case 12 /* RegularExpressionLiteral */: + return this.parseLiteralExpression(); + + case 14 /* StringLiteral */: + return this.parseLiteralExpression(); + + case 74 /* OpenBracketToken */: + return this.parseArrayLiteralExpression(); + + case 70 /* OpenBraceToken */: + return this.parseObjectLiteralExpression(); + + case 72 /* OpenParenToken */: + return this.parseParenthesizedExpression(); + + case 118 /* SlashToken */: + case 119 /* SlashEqualsToken */: + var result = this.tryReparseDivideAsRegularExpression(); + if (result !== null) { + return result; + } + break; + } + + return null; + }; + + ParserImpl.prototype.tryReparseDivideAsRegularExpression = function () { + var currentToken = this.currentToken(); + + if (this.previousToken() !== null) { + var previousTokenKind = this.previousToken().tokenKind; + switch (previousTokenKind) { + case 11 /* IdentifierName */: + return null; + + case 35 /* ThisKeyword */: + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return null; + + case 14 /* StringLiteral */: + case 13 /* NumericLiteral */: + case 12 /* RegularExpressionLiteral */: + case 93 /* PlusPlusToken */: + case 94 /* MinusMinusToken */: + case 75 /* CloseBracketToken */: + return null; + } + } + + currentToken = this.currentTokenAllowingRegularExpression(); + + if (currentToken.tokenKind === 118 /* SlashToken */ || currentToken.tokenKind === 119 /* SlashEqualsToken */) { + return null; + } else if (currentToken.tokenKind === 12 /* RegularExpressionLiteral */) { + return this.parseLiteralExpression(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.parseTypeOfExpression = function () { + var typeOfKeyword = this.eatKeyword(39 /* TypeOfKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.typeOfExpression(typeOfKeyword, expression); + }; + + ParserImpl.prototype.parseDeleteExpression = function () { + var deleteKeyword = this.eatKeyword(21 /* DeleteKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.deleteExpression(deleteKeyword, expression); + }; + + ParserImpl.prototype.parseVoidExpression = function () { + var voidKeyword = this.eatKeyword(41 /* VoidKeyword */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.voidExpression(voidKeyword, expression); + }; + + ParserImpl.prototype.parseFunctionExpression = function () { + var functionKeyword = this.eatKeyword(27 /* FunctionKeyword */); + var identifier = null; + + if (this.isIdentifier(this.currentToken())) { + identifier = this.eatIdentifierToken(); + } + + var callSignature = this.parseCallSignature(false); + var block = this.parseBlock(false, true); + + return this.factory.functionExpression(functionKeyword, identifier, callSignature, block); + }; + + ParserImpl.prototype.parseObjectCreationExpression = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + + var expression = this.parseObjectCreationExpressionOrLower(true); + var argumentList = this.tryParseArgumentList(); + + var result = this.factory.objectCreationExpression(newKeyword, expression, argumentList); + return this.parseMemberExpressionRest(result, true, false); + }; + + ParserImpl.prototype.parseObjectCreationExpressionOrLower = function (inObjectCreation) { + if (this.currentToken().tokenKind === 31 /* NewKeyword */) { + return this.parseObjectCreationExpression(); + } else { + return this.parseMemberExpressionOrLower(inObjectCreation); + } + }; + + ParserImpl.prototype.parseCastExpression = function () { + var lessThanToken = this.eatToken(80 /* LessThanToken */); + var type = this.parseType(); + var greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + var expression = this.parseUnaryExpressionOrLower(); + + return this.factory.castExpression(lessThanToken, type, greaterThanToken, expression); + }; + + ParserImpl.prototype.parseParenthesizedExpression = function () { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var expression = this.parseExpression(true); + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + + return this.factory.parenthesizedExpression(openParenToken, expression, closeParenToken); + }; + + ParserImpl.prototype.tryParseParenthesizedArrowFunctionExpression = function () { + var tokenKind = this.currentToken().tokenKind; + if (tokenKind !== 72 /* OpenParenToken */ && tokenKind !== 80 /* LessThanToken */) { + return null; + } + + if (this.isDefinitelyArrowFunctionExpression()) { + return this.parseParenthesizedArrowFunctionExpression(false); + } + + if (!this.isPossiblyArrowFunctionExpression()) { + return null; + } + + var rewindPoint = this.getRewindPoint(); + + var arrowFunction = this.parseParenthesizedArrowFunctionExpression(true); + if (arrowFunction === null) { + this.rewind(rewindPoint); + } + + this.releaseRewindPoint(rewindPoint); + return arrowFunction; + }; + + ParserImpl.prototype.parseParenthesizedArrowFunctionExpression = function (requireArrow) { + var currentToken = this.currentToken(); + + var callSignature = this.parseCallSignature(true); + + if (requireArrow && this.currentToken().tokenKind !== 85 /* EqualsGreaterThanToken */) { + return null; + } + + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + + var block = this.tryParseArrowFunctionBlock(); + var expression = null; + if (block === null) { + expression = this.parseAssignmentExpression(true); + } + + return this.factory.parenthesizedArrowFunctionExpression(callSignature, equalsGreaterThanToken, block, expression); + }; + + ParserImpl.prototype.tryParseArrowFunctionBlock = function () { + if (this.isBlock()) { + return this.parseBlock(false, false); + } else { + if (this.isStatement(false) && !this.isExpressionStatement(this.currentToken()) && !this.isFunctionDeclaration()) { + return this.parseBlock(true, false); + } else { + return null; + } + } + }; + + ParserImpl.prototype.isSimpleArrowFunctionExpression = function () { + if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return this.isIdentifier(this.currentToken()) && this.peekToken(1).tokenKind === 85 /* EqualsGreaterThanToken */; + }; + + ParserImpl.prototype.parseSimpleArrowFunctionExpression = function () { + var identifier = this.eatIdentifierToken(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + + var block = this.tryParseArrowFunctionBlock(); + var expression = null; + if (block === null) { + expression = this.parseAssignmentExpression(true); + } + + return this.factory.simpleArrowFunctionExpression(identifier, equalsGreaterThanToken, block, expression); + }; + + ParserImpl.prototype.isBlock = function () { + return this.currentToken().tokenKind === 70 /* OpenBraceToken */; + }; + + ParserImpl.prototype.isDefinitelyArrowFunctionExpression = function () { + var token0 = this.currentToken(); + if (token0.tokenKind !== 72 /* OpenParenToken */) { + return false; + } + + var token1 = this.peekToken(1); + var token2; + + if (token1.tokenKind === 73 /* CloseParenToken */) { + token2 = this.peekToken(2); + return token2.tokenKind === 106 /* ColonToken */ || token2.tokenKind === 85 /* EqualsGreaterThanToken */ || token2.tokenKind === 70 /* OpenBraceToken */; + } + + if (token1.tokenKind === 77 /* DotDotDotToken */) { + return true; + } + + token2 = this.peekToken(2); + if (token1.tokenKind === 57 /* PublicKeyword */ || token1.tokenKind === 55 /* PrivateKeyword */) { + if (this.isIdentifier(token2)) { + return true; + } + } + + if (!this.isIdentifier(token1)) { + return false; + } + + if (token2.tokenKind === 106 /* ColonToken */) { + return true; + } + + var token3 = this.peekToken(3); + if (token2.tokenKind === 105 /* QuestionToken */) { + if (token3.tokenKind === 106 /* ColonToken */ || token3.tokenKind === 73 /* CloseParenToken */ || token3.tokenKind === 79 /* CommaToken */) { + return true; + } + } + + if (token2.tokenKind === 73 /* CloseParenToken */) { + if (token3.tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.isPossiblyArrowFunctionExpression = function () { + var token0 = this.currentToken(); + if (token0.tokenKind !== 72 /* OpenParenToken */) { + return true; + } + + var token1 = this.peekToken(1); + + if (!this.isIdentifier(token1)) { + return false; + } + + var token2 = this.peekToken(2); + if (token2.tokenKind === 107 /* EqualsToken */) { + return true; + } + + if (token2.tokenKind === 79 /* CommaToken */) { + return true; + } + + if (token2.tokenKind === 73 /* CloseParenToken */) { + var token3 = this.peekToken(3); + if (token3.tokenKind === 106 /* ColonToken */) { + return true; + } + } + + return false; + }; + + ParserImpl.prototype.parseObjectLiteralExpression = function () { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var result = this.parseSeparatedSyntaxList(32768 /* ObjectLiteralExpression_PropertyAssignments */); + var propertyAssignments = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.objectLiteralExpression(openBraceToken, propertyAssignments, closeBraceToken); + }; + + ParserImpl.prototype.parsePropertyAssignment = function (inErrorRecovery) { + if (this.isAccessor(inErrorRecovery)) { + return this.parseAccessor(true); + } else if (this.isFunctionPropertyAssignment(inErrorRecovery)) { + return this.parseFunctionPropertyAssignment(); + } else if (this.isSimplePropertyAssignment(inErrorRecovery)) { + return this.parseSimplePropertyAssignment(); + } else { + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isPropertyAssignment = function (inErrorRecovery) { + return this.isAccessor(inErrorRecovery) || this.isFunctionPropertyAssignment(inErrorRecovery) || this.isSimplePropertyAssignment(inErrorRecovery); + }; + + ParserImpl.prototype.eatPropertyName = function () { + return TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(this.currentToken()) ? this.eatIdentifierNameToken() : this.eatAnyToken(); + }; + + ParserImpl.prototype.isFunctionPropertyAssignment = function (inErrorRecovery) { + return this.isPropertyName(this.currentToken(), inErrorRecovery) && this.isCallSignature(1); + }; + + ParserImpl.prototype.parseFunctionPropertyAssignment = function () { + var propertyName = this.eatPropertyName(); + var callSignature = this.parseCallSignature(false); + var block = this.parseBlock(false, true); + + return this.factory.functionPropertyAssignment(propertyName, callSignature, block); + }; + + ParserImpl.prototype.isSimplePropertyAssignment = function (inErrorRecovery) { + return this.isPropertyName(this.currentToken(), inErrorRecovery); + }; + + ParserImpl.prototype.parseSimplePropertyAssignment = function () { + var propertyName = this.eatPropertyName(); + var colonToken = this.eatToken(106 /* ColonToken */); + var expression = this.parseAssignmentExpression(true); + + return this.factory.simplePropertyAssignment(propertyName, colonToken, expression); + }; + + ParserImpl.prototype.isPropertyName = function (token, inErrorRecovery) { + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) { + if (inErrorRecovery) { + return this.isIdentifier(token); + } else { + return true; + } + } + + switch (token.tokenKind) { + case 14 /* StringLiteral */: + case 13 /* NumericLiteral */: + return true; + + default: + return false; + } + }; + + ParserImpl.prototype.parseArrayLiteralExpression = function () { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + + var result = this.parseSeparatedSyntaxList(65536 /* ArrayLiteralExpression_AssignmentExpressions */); + var expressions = result.list; + openBracketToken = this.addSkippedTokensAfterToken(openBracketToken, result.skippedTokens); + + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + return this.factory.arrayLiteralExpression(openBracketToken, expressions, closeBracketToken); + }; + + ParserImpl.prototype.parseLiteralExpression = function () { + return this.eatAnyToken(); + }; + + ParserImpl.prototype.parseThisExpression = function () { + return this.eatKeyword(35 /* ThisKeyword */); + }; + + ParserImpl.prototype.parseBlock = function (parseBlockEvenWithNoOpenBrace, checkForStrictMode) { + var openBraceToken = this.eatToken(70 /* OpenBraceToken */); + + var statements = TypeScript.Syntax.emptyList; + + if (parseBlockEvenWithNoOpenBrace || openBraceToken.width() > 0) { + var savedIsInStrictMode = this.isInStrictMode; + + var processItems = checkForStrictMode ? ParserImpl.updateStrictModeState : null; + var result = this.parseSyntaxList(32 /* Block_Statements */, processItems); + statements = result.list; + openBraceToken = this.addSkippedTokensAfterToken(openBraceToken, result.skippedTokens); + + this.setStrictMode(savedIsInStrictMode); + } + + var closeBraceToken = this.eatToken(71 /* CloseBraceToken */); + + return this.factory.block(openBraceToken, statements, closeBraceToken); + }; + + ParserImpl.prototype.parseCallSignature = function (requireCompleteTypeParameterList) { + var typeParameterList = this.parseOptionalTypeParameterList(requireCompleteTypeParameterList); + var parameterList = this.parseParameterList(); + var typeAnnotation = this.parseOptionalTypeAnnotation(false); + + return this.factory.callSignature(typeParameterList, parameterList, typeAnnotation); + }; + + ParserImpl.prototype.parseOptionalTypeParameterList = function (requireCompleteTypeParameterList) { + if (this.currentToken().tokenKind !== 80 /* LessThanToken */) { + return null; + } + + var rewindPoint = this.getRewindPoint(); + + var lessThanToken = this.eatToken(80 /* LessThanToken */); + + var result = this.parseSeparatedSyntaxList(524288 /* TypeParameterList_TypeParameters */); + var typeParameters = result.list; + lessThanToken = this.addSkippedTokensAfterToken(lessThanToken, result.skippedTokens); + + var greaterThanToken = this.eatToken(81 /* GreaterThanToken */); + + if (requireCompleteTypeParameterList && greaterThanToken.fullWidth() === 0) { + this.rewind(rewindPoint); + this.releaseRewindPoint(rewindPoint); + return null; + } else { + this.releaseRewindPoint(rewindPoint); + var typeParameterList = this.factory.typeParameterList(lessThanToken, typeParameters, greaterThanToken); + + return typeParameterList; + } + }; + + ParserImpl.prototype.isTypeParameter = function () { + return this.isIdentifier(this.currentToken()); + }; + + ParserImpl.prototype.parseTypeParameter = function () { + var identifier = this.eatIdentifierToken(); + var constraint = this.parseOptionalConstraint(); + + return this.factory.typeParameter(identifier, constraint); + }; + + ParserImpl.prototype.parseOptionalConstraint = function () { + if (this.currentToken().kind() !== 48 /* ExtendsKeyword */) { + return null; + } + + var extendsKeyword = this.eatKeyword(48 /* ExtendsKeyword */); + var type = this.parseType(); + + return this.factory.constraint(extendsKeyword, type); + }; + + ParserImpl.prototype.parseParameterList = function () { + var openParenToken = this.eatToken(72 /* OpenParenToken */); + var parameters = TypeScript.Syntax.emptySeparatedList; + + if (openParenToken.width() > 0) { + var result = this.parseSeparatedSyntaxList(131072 /* ParameterList_Parameters */); + parameters = result.list; + openParenToken = this.addSkippedTokensAfterToken(openParenToken, result.skippedTokens); + } + + var closeParenToken = this.eatToken(73 /* CloseParenToken */); + return this.factory.parameterList(openParenToken, parameters, closeParenToken); + }; + + ParserImpl.prototype.isTypeAnnotation = function () { + return this.currentToken().tokenKind === 106 /* ColonToken */; + }; + + ParserImpl.prototype.parseOptionalTypeAnnotation = function (allowStringLiteral) { + return this.isTypeAnnotation() ? this.parseTypeAnnotation(allowStringLiteral) : null; + }; + + ParserImpl.prototype.parseTypeAnnotation = function (allowStringLiteral) { + var colonToken = this.eatToken(106 /* ColonToken */); + var type = allowStringLiteral && this.currentToken().tokenKind === 14 /* StringLiteral */ ? this.eatToken(14 /* StringLiteral */) : this.parseType(); + + return this.factory.typeAnnotation(colonToken, type); + }; + + ParserImpl.prototype.isType = function () { + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + switch (currentTokenKind) { + case 39 /* TypeOfKeyword */: + + case 60 /* AnyKeyword */: + case 67 /* NumberKeyword */: + case 61 /* BooleanKeyword */: + case 69 /* StringKeyword */: + case 41 /* VoidKeyword */: + + case 70 /* OpenBraceToken */: + + case 72 /* OpenParenToken */: + case 80 /* LessThanToken */: + + case 31 /* NewKeyword */: + return true; + } + + return this.isIdentifier(currentToken); + }; + + ParserImpl.prototype.parseType = function () { + var currentToken = this.currentToken(); + var currentTokenKind = currentToken.tokenKind; + + if (currentTokenKind === 39 /* TypeOfKeyword */) { + return this.parseTypeQuery(); + } + + var type = this.parseNonArrayType(currentToken); + + while (this.currentToken().tokenKind === 74 /* OpenBracketToken */) { + var openBracketToken = this.eatToken(74 /* OpenBracketToken */); + var closeBracketToken = this.eatToken(75 /* CloseBracketToken */); + + type = this.factory.arrayType(type, openBracketToken, closeBracketToken); + } + + return type; + }; + + ParserImpl.prototype.isTypeQuery = function () { + return this.currentToken().tokenKind === 39 /* TypeOfKeyword */; + }; + + ParserImpl.prototype.parseTypeQuery = function () { + var typeOfKeyword = this.eatToken(39 /* TypeOfKeyword */); + var name = this.parseName(); + + return this.factory.typeQuery(typeOfKeyword, name); + }; + + ParserImpl.prototype.parseNonArrayType = function (currentToken) { + var currentTokenKind = currentToken.tokenKind; + switch (currentTokenKind) { + case 60 /* AnyKeyword */: + case 67 /* NumberKeyword */: + case 61 /* BooleanKeyword */: + case 69 /* StringKeyword */: + case 41 /* VoidKeyword */: + return this.eatAnyToken(); + + case 70 /* OpenBraceToken */: + return this.parseObjectType(); + + case 72 /* OpenParenToken */: + case 80 /* LessThanToken */: + return this.parseFunctionType(); + + case 31 /* NewKeyword */: + return this.parseConstructorType(); + } + + return this.parseNameOrGenericType(); + }; + + ParserImpl.prototype.parseNameOrGenericType = function () { + var name = this.parseName(); + var typeArgumentList = this.tryParseTypeArgumentList(false); + + return typeArgumentList === null ? name : this.factory.genericType(name, typeArgumentList); + }; + + ParserImpl.prototype.parseFunctionType = function () { + var typeParameterList = this.parseOptionalTypeParameterList(false); + var parameterList = this.parseParameterList(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + var returnType = this.parseType(); + + return this.factory.functionType(typeParameterList, parameterList, equalsGreaterThanToken, returnType); + }; + + ParserImpl.prototype.parseConstructorType = function () { + var newKeyword = this.eatKeyword(31 /* NewKeyword */); + var typeParameterList = this.parseOptionalTypeParameterList(false); + var parameterList = this.parseParameterList(); + var equalsGreaterThanToken = this.eatToken(85 /* EqualsGreaterThanToken */); + var type = this.parseType(); + + return this.factory.constructorType(newKeyword, typeParameterList, parameterList, equalsGreaterThanToken, type); + }; + + ParserImpl.prototype.isParameter = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) { + return true; + } + + var token = this.currentToken(); + var tokenKind = token.tokenKind; + if (tokenKind === 77 /* DotDotDotToken */) { + return true; + } + + if (ParserImpl.isModifier(token) && !this.isModifierUsedAsParameterIdentifier(token)) { + return true; + } + + return this.isIdentifier(token); + }; + + ParserImpl.prototype.isModifierUsedAsParameterIdentifier = function (token) { + if (this.isIdentifier(token)) { + var nextTokenKind = this.peekToken(1).tokenKind; + switch (nextTokenKind) { + case 73 /* CloseParenToken */: + case 106 /* ColonToken */: + case 107 /* EqualsToken */: + case 79 /* CommaToken */: + case 105 /* QuestionToken */: + return true; + } + } + + return false; + }; + + ParserImpl.prototype.parseParameter = function () { + if (this.currentNode() !== null && this.currentNode().kind() === 242 /* Parameter */) { + return this.eatNode(); + } + + var dotDotDotToken = this.tryEatToken(77 /* DotDotDotToken */); + + var modifierArray = this.getArray(); + + while (true) { + var currentToken = this.currentToken(); + if (ParserImpl.isModifier(currentToken) && !this.isModifierUsedAsParameterIdentifier(currentToken)) { + modifierArray.push(this.eatAnyToken()); + continue; + } + + break; + } + + var modifiers = TypeScript.Syntax.list(modifierArray); + this.returnZeroOrOneLengthArray(modifierArray); + + var identifier = this.eatIdentifierToken(); + var questionToken = this.tryEatToken(105 /* QuestionToken */); + var typeAnnotation = this.parseOptionalTypeAnnotation(true); + + var equalsValueClause = null; + if (this.isEqualsValueClause(true)) { + equalsValueClause = this.parseEqualsValueClause(true); + } + + return this.factory.parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause); + }; + + ParserImpl.prototype.parseSyntaxList = function (currentListType, processItems) { + if (typeof processItems === "undefined") { processItems = null; } + var savedListParsingState = this.listParsingState; + this.listParsingState |= currentListType; + + var result = this.parseSyntaxListWorker(currentListType, processItems); + + this.listParsingState = savedListParsingState; + + return result; + }; + + ParserImpl.prototype.parseSeparatedSyntaxList = function (currentListType) { + var savedListParsingState = this.listParsingState; + this.listParsingState |= currentListType; + + var result = this.parseSeparatedSyntaxListWorker(currentListType); + + this.listParsingState = savedListParsingState; + + return result; + }; + + ParserImpl.prototype.abortParsingListOrMoveToNextToken = function (currentListType, items, skippedTokens) { + this.reportUnexpectedTokenDiagnostic(currentListType); + + for (var state = 262144 /* LastListParsingState */; state >= 1 /* FirstListParsingState */; state >>= 1) { + if ((this.listParsingState & state) !== 0) { + if (this.isExpectedListTerminator(state) || this.isExpectedListItem(state, true)) { + return true; + } + } + } + + var skippedToken = this.currentToken(); + + this.moveToNextToken(); + + this.addSkippedTokenToList(items, skippedTokens, skippedToken); + + return false; + }; + + ParserImpl.prototype.addSkippedTokenToList = function (items, skippedTokens, skippedToken) { + for (var i = items.length - 1; i >= 0; i--) { + var item = items[i]; + var lastToken = item.lastToken(); + if (lastToken.fullWidth() > 0) { + items[i] = this.addSkippedTokenAfterNodeOrToken(item, skippedToken); + return; + } + } + + skippedTokens.push(skippedToken); + }; + + ParserImpl.prototype.tryParseExpectedListItem = function (currentListType, inErrorRecovery, items, processItems) { + if (this.isExpectedListItem(currentListType, inErrorRecovery)) { + var item = this.parseExpectedListItem(currentListType, inErrorRecovery); + + items.push(item); + + if (processItems !== null) { + processItems(this, items); + } + } + }; + + ParserImpl.prototype.listIsTerminated = function (currentListType) { + return this.isExpectedListTerminator(currentListType) || this.currentToken().tokenKind === 10 /* EndOfFileToken */; + }; + + ParserImpl.prototype.getArray = function () { + if (this.arrayPool.length > 0) { + return this.arrayPool.pop(); + } + + return []; + }; + + ParserImpl.prototype.returnZeroOrOneLengthArray = function (array) { + if (array.length <= 1) { + this.returnArray(array); + } + }; + + ParserImpl.prototype.returnArray = function (array) { + array.length = 0; + this.arrayPool.push(array); + }; + + ParserImpl.prototype.parseSyntaxListWorker = function (currentListType, processItems) { + var items = this.getArray(); + var skippedTokens = this.getArray(); + + while (true) { + var oldItemsCount = items.length; + this.tryParseExpectedListItem(currentListType, false, items, processItems); + + var newItemsCount = items.length; + if (newItemsCount === oldItemsCount) { + if (this.listIsTerminated(currentListType)) { + break; + } + + var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens); + if (abort) { + break; + } + } + } + + var result = TypeScript.Syntax.list(items); + + this.returnZeroOrOneLengthArray(items); + + return { skippedTokens: skippedTokens, list: result }; + }; + + ParserImpl.prototype.parseSeparatedSyntaxListWorker = function (currentListType) { + var items = this.getArray(); + var skippedTokens = this.getArray(); + TypeScript.Debug.assert(items.length === 0); + TypeScript.Debug.assert(skippedTokens.length === 0); + TypeScript.Debug.assert(skippedTokens !== items); + + var separatorKind = this.separatorKind(currentListType); + var allowAutomaticSemicolonInsertion = separatorKind === 78 /* SemicolonToken */; + + var inErrorRecovery = false; + var listWasTerminated = false; + while (true) { + var oldItemsCount = items.length; + + this.tryParseExpectedListItem(currentListType, inErrorRecovery, items, null); + + var newItemsCount = items.length; + if (newItemsCount === oldItemsCount) { + if (this.listIsTerminated(currentListType)) { + listWasTerminated = true; + break; + } + + var abort = this.abortParsingListOrMoveToNextToken(currentListType, items, skippedTokens); + if (abort) { + break; + } else { + inErrorRecovery = true; + continue; + } + } + + inErrorRecovery = false; + + var currentToken = this.currentToken(); + if (currentToken.tokenKind === separatorKind || currentToken.tokenKind === 79 /* CommaToken */) { + items.push(this.eatAnyToken()); + continue; + } + + if (this.listIsTerminated(currentListType)) { + listWasTerminated = true; + break; + } + + if (allowAutomaticSemicolonInsertion && this.canEatAutomaticSemicolon(false)) { + items.push(this.eatExplicitOrAutomaticSemicolon(false)); + + continue; + } + + items.push(this.eatToken(separatorKind)); + + inErrorRecovery = true; + } + + var result = TypeScript.Syntax.separatedList(items); + + this.returnZeroOrOneLengthArray(items); + + return { skippedTokens: skippedTokens, list: result }; + }; + + ParserImpl.prototype.separatorKind = function (currentListType) { + switch (currentListType) { + case 2048 /* HeritageClause_TypeNameList */: + case 16384 /* ArgumentList_AssignmentExpressions */: + case 256 /* EnumDeclaration_EnumElements */: + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + case 131072 /* ParameterList_Parameters */: + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + case 262144 /* TypeArgumentList_Types */: + case 524288 /* TypeParameterList_TypeParameters */: + return 79 /* CommaToken */; + + case 512 /* ObjectType_TypeMembers */: + return 78 /* SemicolonToken */; + + case 1 /* SourceUnit_ModuleElements */: + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + case 2 /* ClassDeclaration_ClassElements */: + case 4 /* ModuleDeclaration_ModuleElements */: + case 8 /* SwitchStatement_SwitchClauses */: + case 16 /* SwitchClause_Statements */: + case 32 /* Block_Statements */: + default: + throw TypeScript.Errors.notYetImplemented(); + } + }; + + ParserImpl.prototype.reportUnexpectedTokenDiagnostic = function (listType) { + var token = this.currentToken(); + + var diagnostic = new TypeScript.Diagnostic(this.fileName, this.lineMap, this.currentTokenStart(), token.width(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [this.getExpectedListElementType(listType)]); + this.addDiagnostic(diagnostic); + }; + + ParserImpl.prototype.addDiagnostic = function (diagnostic) { + if (this.diagnostics.length > 0 && this.diagnostics[this.diagnostics.length - 1].start() === diagnostic.start()) { + return; + } + + this.diagnostics.push(diagnostic); + }; + + ParserImpl.prototype.isExpectedListTerminator = function (currentListType) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.isExpectedSourceUnit_ModuleElementsTerminator(); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.isExpectedClassDeclaration_ClassElementsTerminator(); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.isExpectedModuleDeclaration_ModuleElementsTerminator(); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.isExpectedSwitchStatement_SwitchClausesTerminator(); + + case 16 /* SwitchClause_Statements */: + return this.isExpectedSwitchClause_StatementsTerminator(); + + case 32 /* Block_Statements */: + return this.isExpectedBlock_StatementsTerminator(); + + case 64 /* TryBlock_Statements */: + return this.isExpectedTryBlock_StatementsTerminator(); + + case 128 /* CatchBlock_Statements */: + return this.isExpectedCatchBlock_StatementsTerminator(); + + case 256 /* EnumDeclaration_EnumElements */: + return this.isExpectedEnumDeclaration_EnumElementsTerminator(); + + case 512 /* ObjectType_TypeMembers */: + return this.isExpectedObjectType_TypeMembersTerminator(); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.isExpectedArgumentList_AssignmentExpressionsTerminator(); + + case 2048 /* HeritageClause_TypeNameList */: + return this.isExpectedHeritageClause_TypeNameListTerminator(); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + return this.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator(); + + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator(); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator(); + + case 131072 /* ParameterList_Parameters */: + return this.isExpectedParameterList_ParametersTerminator(); + + case 262144 /* TypeArgumentList_Types */: + return this.isExpectedTypeArgumentList_TypesTerminator(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.isExpectedTypeParameterList_TypeParametersTerminator(); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.isExpectedLiteralExpression_AssignmentExpressionsTerminator(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isExpectedSourceUnit_ModuleElementsTerminator = function () { + return this.currentToken().tokenKind === 10 /* EndOfFileToken */; + }; + + ParserImpl.prototype.isExpectedEnumDeclaration_EnumElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedModuleDeclaration_ModuleElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedObjectType_TypeMembersTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedObjectLiteralExpression_PropertyAssignmentsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedLiteralExpression_AssignmentExpressionsTerminator = function () { + return this.currentToken().tokenKind === 75 /* CloseBracketToken */; + }; + + ParserImpl.prototype.isExpectedTypeArgumentList_TypesTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 81 /* GreaterThanToken */) { + return true; + } + + if (this.canFollowTypeArgumentListInExpression(token.tokenKind)) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedTypeParameterList_TypeParametersTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 81 /* GreaterThanToken */) { + return true; + } + + if (token.tokenKind === 72 /* OpenParenToken */ || token.tokenKind === 70 /* OpenBraceToken */ || token.tokenKind === 48 /* ExtendsKeyword */ || token.tokenKind === 51 /* ImplementsKeyword */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedParameterList_ParametersTerminator = function () { + var token = this.currentToken(); + if (token.tokenKind === 73 /* CloseParenToken */) { + return true; + } + + if (token.tokenKind === 70 /* OpenBraceToken */) { + return true; + } + + if (token.tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_DisallowInTerminator = function () { + if (this.currentToken().tokenKind === 78 /* SemicolonToken */ || this.currentToken().tokenKind === 73 /* CloseParenToken */) { + return true; + } + + if (this.currentToken().tokenKind === 29 /* InKeyword */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedVariableDeclaration_VariableDeclarators_AllowInTerminator = function () { + if (this.previousToken().tokenKind === 79 /* CommaToken */) { + return false; + } + + if (this.currentToken().tokenKind === 85 /* EqualsGreaterThanToken */) { + return true; + } + + return this.canEatExplicitOrAutomaticSemicolon(false); + }; + + ParserImpl.prototype.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 70 /* OpenBraceToken */ || token0.tokenKind === 71 /* CloseBraceToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedHeritageClause_TypeNameListTerminator = function () { + var token0 = this.currentToken(); + if (token0.tokenKind === 48 /* ExtendsKeyword */ || token0.tokenKind === 51 /* ImplementsKeyword */) { + return true; + } + + if (this.isExpectedClassOrInterfaceDeclaration_HeritageClausesTerminator()) { + return true; + } + + return false; + }; + + ParserImpl.prototype.isExpectedArgumentList_AssignmentExpressionsTerminator = function () { + var token0 = this.currentToken(); + return token0.tokenKind === 73 /* CloseParenToken */ || token0.tokenKind === 78 /* SemicolonToken */; + }; + + ParserImpl.prototype.isExpectedClassDeclaration_ClassElementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedSwitchStatement_SwitchClausesTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedSwitchClause_StatementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */ || this.isSwitchClause(); + }; + + ParserImpl.prototype.isExpectedBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 71 /* CloseBraceToken */; + }; + + ParserImpl.prototype.isExpectedTryBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 17 /* CatchKeyword */ || this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.isExpectedCatchBlock_StatementsTerminator = function () { + return this.currentToken().tokenKind === 25 /* FinallyKeyword */; + }; + + ParserImpl.prototype.isExpectedListItem = function (currentListType, inErrorRecovery) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.isModuleElement(inErrorRecovery); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.isHeritageClause(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.isClassElement(inErrorRecovery); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.isModuleElement(inErrorRecovery); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.isSwitchClause(); + + case 16 /* SwitchClause_Statements */: + return this.isStatement(inErrorRecovery); + + case 32 /* Block_Statements */: + return this.isStatement(inErrorRecovery); + + case 64 /* TryBlock_Statements */: + case 128 /* CatchBlock_Statements */: + return false; + + case 256 /* EnumDeclaration_EnumElements */: + return this.isEnumElement(inErrorRecovery); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.isVariableDeclarator(); + + case 512 /* ObjectType_TypeMembers */: + return this.isTypeMember(inErrorRecovery); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.isExpectedArgumentList_AssignmentExpression(); + + case 2048 /* HeritageClause_TypeNameList */: + return this.isHeritageClauseTypeName(); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.isPropertyAssignment(inErrorRecovery); + + case 131072 /* ParameterList_Parameters */: + return this.isParameter(); + + case 262144 /* TypeArgumentList_Types */: + return this.isType(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.isTypeParameter(); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.isAssignmentOrOmittedExpression(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.isExpectedArgumentList_AssignmentExpression = function () { + var currentToken = this.currentToken(); + if (this.isExpression(currentToken)) { + return true; + } + + if (currentToken.tokenKind === 79 /* CommaToken */) { + return true; + } + + return false; + }; + + ParserImpl.prototype.parseExpectedListItem = function (currentListType, inErrorRecovery) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return this.parseModuleElement(inErrorRecovery); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return this.parseHeritageClause(); + + case 2 /* ClassDeclaration_ClassElements */: + return this.parseClassElement(inErrorRecovery); + + case 4 /* ModuleDeclaration_ModuleElements */: + return this.parseModuleElement(inErrorRecovery); + + case 8 /* SwitchStatement_SwitchClauses */: + return this.parseSwitchClause(); + + case 16 /* SwitchClause_Statements */: + return this.parseStatement(inErrorRecovery); + + case 32 /* Block_Statements */: + return this.parseStatement(inErrorRecovery); + + case 256 /* EnumDeclaration_EnumElements */: + return this.parseEnumElement(); + + case 512 /* ObjectType_TypeMembers */: + return this.parseTypeMember(inErrorRecovery); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return this.parseAssignmentExpression(true); + + case 2048 /* HeritageClause_TypeNameList */: + return this.parseNameOrGenericType(); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + return this.parseVariableDeclarator(true, false); + + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return this.parseVariableDeclarator(false, false); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return this.parsePropertyAssignment(inErrorRecovery); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return this.parseAssignmentOrOmittedExpression(); + + case 131072 /* ParameterList_Parameters */: + return this.parseParameter(); + + case 262144 /* TypeArgumentList_Types */: + return this.parseType(); + + case 524288 /* TypeParameterList_TypeParameters */: + return this.parseTypeParameter(); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + ParserImpl.prototype.getExpectedListElementType = function (currentListType) { + switch (currentListType) { + case 1 /* SourceUnit_ModuleElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null); + + case 1024 /* ClassOrInterfaceDeclaration_HeritageClauses */: + return '{'; + + case 2 /* ClassDeclaration_ClassElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.constructor_function_accessor_or_variable, null); + + case 4 /* ModuleDeclaration_ModuleElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.module_class_interface_enum_import_or_statement, null); + + case 8 /* SwitchStatement_SwitchClauses */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.case_or_default_clause, null); + + case 16 /* SwitchClause_Statements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null); + + case 32 /* Block_Statements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.statement, null); + + case 4096 /* VariableDeclaration_VariableDeclarators_AllowIn */: + case 8192 /* VariableDeclaration_VariableDeclarators_DisallowIn */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null); + + case 256 /* EnumDeclaration_EnumElements */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null); + + case 512 /* ObjectType_TypeMembers */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.call_construct_index_property_or_function_signature, null); + + case 16384 /* ArgumentList_AssignmentExpressions */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null); + + case 2048 /* HeritageClause_TypeNameList */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null); + + case 32768 /* ObjectLiteralExpression_PropertyAssignments */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.property_or_accessor, null); + + case 131072 /* ParameterList_Parameters */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.parameter, null); + + case 262144 /* TypeArgumentList_Types */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type, null); + + case 524288 /* TypeParameterList_TypeParameters */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_parameter, null); + + case 65536 /* ArrayLiteralExpression_AssignmentExpressions */: + return TypeScript.getLocalizedText(TypeScript.DiagnosticCode.expression, null); + + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + return ParserImpl; + })(); + + function parse(fileName, text, isDeclaration, options) { + var source = new NormalParserSource(fileName, text, options.languageVersion()); + + return new ParserImpl(fileName, text.lineMap(), source, options, text).parseSyntaxTree(isDeclaration); + } + Parser.parse = parse; + + function incrementalParse(oldSyntaxTree, textChangeRange, newText) { + if (textChangeRange.isUnchanged()) { + return oldSyntaxTree; + } + + var source = new IncrementalParserSource(oldSyntaxTree, textChangeRange, newText); + + return new ParserImpl(oldSyntaxTree.fileName(), newText.lineMap(), source, oldSyntaxTree.parseOptions(), newText).parseSyntaxTree(oldSyntaxTree.isDeclaration()); + } + Parser.incrementalParse = incrementalParse; + })(TypeScript.Parser || (TypeScript.Parser = {})); + var Parser = TypeScript.Parser; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTree = (function () { + function SyntaxTree(sourceUnit, isDeclaration, diagnostics, fileName, lineMap, parseOtions) { + this._allDiagnostics = null; + this._sourceUnit = sourceUnit; + this._isDeclaration = isDeclaration; + this._parserDiagnostics = diagnostics; + this._fileName = fileName; + this._lineMap = lineMap; + this._parseOptions = parseOtions; + } + SyntaxTree.prototype.toJSON = function (key) { + var result = {}; + + result.isDeclaration = this._isDeclaration; + result.languageVersion = TypeScript.LanguageVersion[this._parseOptions.languageVersion()]; + result.parseOptions = this._parseOptions; + + if (this.diagnostics().length > 0) { + result.diagnostics = this.diagnostics(); + } + + result.sourceUnit = this._sourceUnit; + result.lineMap = this._lineMap; + + return result; + }; + + SyntaxTree.prototype.sourceUnit = function () { + return this._sourceUnit; + }; + + SyntaxTree.prototype.isDeclaration = function () { + return this._isDeclaration; + }; + + SyntaxTree.prototype.computeDiagnostics = function () { + if (this._parserDiagnostics.length > 0) { + return this._parserDiagnostics; + } + + var diagnostics = []; + this.sourceUnit().accept(new GrammarCheckerWalker(this, diagnostics)); + + return diagnostics; + }; + + SyntaxTree.prototype.diagnostics = function () { + if (this._allDiagnostics === null) { + this._allDiagnostics = this.computeDiagnostics(); + } + + return this._allDiagnostics; + }; + + SyntaxTree.prototype.fileName = function () { + return this._fileName; + }; + + SyntaxTree.prototype.lineMap = function () { + return this._lineMap; + }; + + SyntaxTree.prototype.parseOptions = function () { + return this._parseOptions; + }; + + SyntaxTree.prototype.structuralEquals = function (tree) { + return TypeScript.ArrayUtilities.sequenceEquals(this.diagnostics(), tree.diagnostics(), TypeScript.Diagnostic.equals) && this.sourceUnit().structuralEquals(tree.sourceUnit()); + }; + return SyntaxTree; + })(); + TypeScript.SyntaxTree = SyntaxTree; + + var GrammarCheckerWalker = (function (_super) { + __extends(GrammarCheckerWalker, _super); + function GrammarCheckerWalker(syntaxTree, diagnostics) { + _super.call(this); + this.syntaxTree = syntaxTree; + this.diagnostics = diagnostics; + this.inAmbientDeclaration = false; + this.inBlock = false; + this.inObjectLiteralExpression = false; + this.currentConstructor = null; + } + GrammarCheckerWalker.prototype.childFullStart = function (parent, child) { + return this.position() + TypeScript.Syntax.childOffset(parent, child); + }; + + GrammarCheckerWalker.prototype.childStart = function (parent, child) { + return this.childFullStart(parent, child) + child.leadingTriviaWidth(); + }; + + GrammarCheckerWalker.prototype.pushDiagnostic = function (start, length, diagnosticKey, args) { + if (typeof args === "undefined") { args = null; } + this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), start, length, diagnosticKey, args)); + }; + + GrammarCheckerWalker.prototype.pushDiagnostic1 = function (elementFullStart, element, diagnosticKey, args) { + if (typeof args === "undefined") { args = null; } + this.diagnostics.push(new TypeScript.Diagnostic(this.syntaxTree.fileName(), this.syntaxTree.lineMap(), elementFullStart + element.leadingTriviaWidth(), element.width(), diagnosticKey, args)); + }; + + GrammarCheckerWalker.prototype.visitCatchClause = function (node) { + if (node.typeAnnotation) { + this.pushDiagnostic(this.childStart(node, node.typeAnnotation), node.typeAnnotation.width(), TypeScript.DiagnosticCode.Catch_clause_parameter_cannot_have_a_type_annotation); + } + + _super.prototype.visitCatchClause.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkParameterListOrder = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameters); + + var seenOptionalParameter = false; + var parameterCount = node.parameters.nonSeparatorCount(); + + for (var i = 0, n = node.parameters.childCount(); i < n; i++) { + var nodeOrToken = node.parameters.childAt(i); + if (i % 2 === 0) { + var parameterIndex = i / 2; + var parameter = node.parameters.childAt(i); + + if (parameter.dotDotDotToken) { + if (parameterIndex !== (parameterCount - 1)) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_must_be_last_in_list); + return true; + } + + if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_be_optional); + return true; + } + + if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Rest_parameter_cannot_have_an_initializer); + return true; + } + } else if (parameter.questionToken || parameter.equalsValueClause) { + seenOptionalParameter = true; + + if (parameter.questionToken && parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Parameter_cannot_have_question_mark_and_initializer); + return true; + } + } else { + if (seenOptionalParameter) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Required_parameter_cannot_follow_optional_parameter); + return true; + } + } + } + + parameterFullStart += nodeOrToken.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterListAcessibilityModifiers = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameters); + + for (var i = 0, n = node.parameters.childCount(); i < n; i++) { + var nodeOrToken = node.parameters.childAt(i); + if (i % 2 === 0) { + var parameter = node.parameters.childAt(i); + + if (this.checkParameterAccessibilityModifiers(node, parameter, parameterFullStart)) { + return true; + } + } + + parameterFullStart += nodeOrToken.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterAccessibilityModifiers = function (parameterList, parameter, parameterFullStart) { + if (parameter.modifiers.childCount() > 0) { + var modifiers = parameter.modifiers; + var modifierFullStart = parameterFullStart + TypeScript.Syntax.childOffset(parameter, modifiers); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + + if (this.checkParameterAccessibilityModifier(parameterList, modifier, modifierFullStart, i)) { + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkParameterAccessibilityModifier = function (parameterList, modifier, modifierFullStart, modifierIndex) { + if (modifier.tokenKind !== 57 /* PublicKeyword */ && modifier.tokenKind !== 55 /* PrivateKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_parameter, [modifier.text()]); + return true; + } else { + if (modifierIndex > 0) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return true; + } + + if (this.inAmbientDeclaration) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_an_ambient_context); + return true; + } else if (this.currentConstructor && !this.currentConstructor.block && this.currentConstructor.parameterList === parameterList) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_cannot_be_used_in_a_constructor_overload); + return true; + } else if (this.currentConstructor === null || this.currentConstructor.parameterList !== parameterList) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Parameter_property_declarations_can_only_be_used_in_constructors); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForTrailingSeparator = function (parent, list) { + if (list.childCount() === 0 || list.childCount() % 2 === 1) { + return false; + } + + var currentElementFullStart = this.childFullStart(parent, list); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var child = list.childAt(i); + if (i === n - 1) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode.Trailing_separator_not_allowed); + } + + currentElementFullStart += child.fullWidth(); + } + + return true; + }; + + GrammarCheckerWalker.prototype.checkForAtLeastOneElement = function (parent, list, expected) { + if (list.childCount() > 0) { + return false; + } + + var listFullStart = this.childFullStart(parent, list); + var tokenAtStart = this.syntaxTree.sourceUnit().findToken(listFullStart); + + this.pushDiagnostic1(listFullStart, tokenAtStart.token(), TypeScript.DiagnosticCode.Unexpected_token_0_expected, [expected]); + + return true; + }; + + GrammarCheckerWalker.prototype.visitParameterList = function (node) { + if (this.checkParameterListAcessibilityModifiers(node) || this.checkParameterListOrder(node) || this.checkForTrailingSeparator(node, node.parameters)) { + this.skip(node); + return; + } + + _super.prototype.visitParameterList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitHeritageClause = function (node) { + if (this.checkForTrailingSeparator(node, node.typeNames) || this.checkForAtLeastOneElement(node, node.typeNames, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.type_name, null))) { + this.skip(node); + return; + } + + _super.prototype.visitHeritageClause.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitArgumentList = function (node) { + if (this.checkForTrailingSeparator(node, node.arguments)) { + this.skip(node); + return; + } + + _super.prototype.visitArgumentList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitVariableDeclaration = function (node) { + if (this.checkForTrailingSeparator(node, node.variableDeclarators) || this.checkForAtLeastOneElement(node, node.variableDeclarators, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitVariableDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTypeArgumentList = function (node) { + if (this.checkForTrailingSeparator(node, node.typeArguments) || this.checkForAtLeastOneElement(node, node.typeArguments, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitTypeArgumentList.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTypeParameterList = function (node) { + if (this.checkForTrailingSeparator(node, node.typeParameters) || this.checkForAtLeastOneElement(node, node.typeParameters, TypeScript.getLocalizedText(TypeScript.DiagnosticCode.identifier, null))) { + this.skip(node); + return; + } + + _super.prototype.visitTypeParameterList.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkIndexSignatureParameter = function (node) { + var parameterFullStart = this.childFullStart(node, node.parameter); + var parameter = node.parameter; + + if (parameter.dotDotDotToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signatures_cannot_have_rest_parameters); + return true; + } else if (parameter.modifiers.childCount() > 0) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_accessibility_modifiers); + return true; + } else if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_a_question_mark); + return true; + } else if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_cannot_have_an_initializer); + return true; + } else if (!parameter.typeAnnotation) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_must_have_a_type_annotation); + return true; + } else if (parameter.typeAnnotation.type.kind() !== 69 /* StringKeyword */ && parameter.typeAnnotation.type.kind() !== 67 /* NumberKeyword */) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.Index_signature_parameter_type_must_be_string_or_number); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitIndexSignature = function (node) { + if (this.checkIndexSignatureParameter(node)) { + this.skip(node); + return; + } + + if (!node.typeAnnotation) { + this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.Index_signature_must_have_a_type_annotation); + this.skip(node); + return; + } + + _super.prototype.visitIndexSignature.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkClassDeclarationHeritageClauses = function (node) { + var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses); + + var seenExtendsClause = false; + var seenImplementsClause = false; + + for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) { + TypeScript.Debug.assert(i <= 2); + var heritageClause = node.heritageClauses.childAt(i); + + if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) { + if (seenExtendsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen); + return true; + } + + if (seenImplementsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_must_precede_implements_clause); + return true; + } + + if (heritageClause.typeNames.nonSeparatorCount() > 1) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Classes_can_only_extend_a_single_class); + return true; + } + + seenExtendsClause = true; + } else { + TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + if (seenImplementsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.implements_clause_already_seen); + return true; + } + + seenImplementsClause = true; + } + + heritageClauseFullStart += heritageClause.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifier = function (modifiers) { + if (this.inAmbientDeclaration) { + var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */); + + if (declareToken) { + this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_for_code_already_in_an_ambient_context); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForRequiredDeclareModifier = function (moduleElement, typeKeyword, modifiers) { + if (!this.inAmbientDeclaration && this.syntaxTree.isDeclaration()) { + if (!TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) { + this.pushDiagnostic1(this.childFullStart(moduleElement, typeKeyword), typeKeyword.firstToken(), TypeScript.DiagnosticCode.declare_modifier_required_for_top_level_element); + return true; + } + } + }; + + GrammarCheckerWalker.prototype.checkFunctionOverloads = function (node, moduleElements) { + if (!this.inAmbientDeclaration && !this.syntaxTree.isDeclaration()) { + var moduleElementFullStart = this.childFullStart(node, moduleElements); + + var inFunctionOverloadChain = false; + var functionOverloadChainName = null; + + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + var lastElement = i === (n - 1); + + if (inFunctionOverloadChain) { + if (moduleElement.kind() !== 129 /* FunctionDeclaration */) { + this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + + var functionDeclaration = moduleElement; + if (functionDeclaration.identifier.valueText() !== functionOverloadChainName) { + var identifierFullStart = moduleElementFullStart + TypeScript.Syntax.childOffset(moduleElement, functionDeclaration.identifier); + this.pushDiagnostic1(identifierFullStart, functionDeclaration.identifier, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]); + return true; + } + } + + if (moduleElement.kind() === 129 /* FunctionDeclaration */) { + functionDeclaration = moduleElement; + if (!TypeScript.SyntaxUtilities.containsToken(functionDeclaration.modifiers, 63 /* DeclareKeyword */)) { + inFunctionOverloadChain = functionDeclaration.block === null; + functionOverloadChainName = functionDeclaration.identifier.valueText(); + + if (lastElement && inFunctionOverloadChain) { + this.pushDiagnostic1(moduleElementFullStart, moduleElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + } else { + inFunctionOverloadChain = false; + functionOverloadChainName = ""; + } + } + + moduleElementFullStart += moduleElement.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkClassOverloads = function (node) { + if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + var classElementFullStart = this.childFullStart(node, node.classElements); + + var inFunctionOverloadChain = false; + var inConstructorOverloadChain = false; + + var functionOverloadChainName = null; + var isInStaticOverloadChain = null; + var memberFunctionDeclaration = null; + + for (var i = 0, n = node.classElements.childCount(); i < n; i++) { + var classElement = node.classElements.childAt(i); + var lastElement = i === (n - 1); + var isStaticOverload = null; + + if (inFunctionOverloadChain) { + if (classElement.kind() !== 135 /* MemberFunctionDeclaration */) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + + memberFunctionDeclaration = classElement; + if (memberFunctionDeclaration.propertyName.valueText() !== functionOverloadChainName) { + var propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName); + this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, TypeScript.DiagnosticCode.Function_overload_name_must_be_0, [functionOverloadChainName]); + return true; + } + isStaticOverload = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */); + if (isStaticOverload !== isInStaticOverloadChain) { + propertyNameFullStart = classElementFullStart + TypeScript.Syntax.childOffset(classElement, memberFunctionDeclaration.propertyName); + var diagnostic = isInStaticOverloadChain ? TypeScript.DiagnosticCode.Function_overload_must_be_static : TypeScript.DiagnosticCode.Function_overload_must_not_be_static; + this.pushDiagnostic1(propertyNameFullStart, memberFunctionDeclaration.propertyName, diagnostic, null); + return true; + } + } else if (inConstructorOverloadChain) { + if (classElement.kind() !== 137 /* ConstructorDeclaration */) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected); + return true; + } + } + + if (classElement.kind() === 135 /* MemberFunctionDeclaration */) { + memberFunctionDeclaration = classElement; + + inFunctionOverloadChain = memberFunctionDeclaration.block === null; + functionOverloadChainName = memberFunctionDeclaration.propertyName.valueText(); + isInStaticOverloadChain = TypeScript.SyntaxUtilities.containsToken(memberFunctionDeclaration.modifiers, 58 /* StaticKeyword */); + + if (lastElement && inFunctionOverloadChain) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Function_implementation_expected); + return true; + } + } else if (classElement.kind() === 137 /* ConstructorDeclaration */) { + var constructorDeclaration = classElement; + + inConstructorOverloadChain = constructorDeclaration.block === null; + if (lastElement && inConstructorOverloadChain) { + this.pushDiagnostic1(classElementFullStart, classElement.firstToken(), TypeScript.DiagnosticCode.Constructor_implementation_expected); + return true; + } + } + + classElementFullStart += classElement.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForReservedName = function (parent, name, diagnosticKey) { + var nameFullStart = this.childFullStart(parent, name); + var token; + var tokenFullStart; + + var current = name; + while (current !== null) { + if (current.kind() === 121 /* QualifiedName */) { + var qualifiedName = current; + token = qualifiedName.right; + tokenFullStart = nameFullStart + this.childFullStart(qualifiedName, token); + current = qualifiedName.left; + } else { + TypeScript.Debug.assert(current.kind() === 11 /* IdentifierName */); + token = current; + tokenFullStart = nameFullStart; + current = null; + } + + switch (token.valueText()) { + case "any": + case "number": + case "boolean": + case "string": + case "void": + this.pushDiagnostic(tokenFullStart + token.leadingTriviaWidth(), token.width(), diagnosticKey, [token.valueText()]); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitClassDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Class_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.classKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkClassDeclarationHeritageClauses(node) || this.checkClassOverloads(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitClassDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkInterfaceDeclarationHeritageClauses = function (node) { + var heritageClauseFullStart = this.childFullStart(node, node.heritageClauses); + + var seenExtendsClause = false; + + for (var i = 0, n = node.heritageClauses.childCount(); i < n; i++) { + TypeScript.Debug.assert(i <= 1); + var heritageClause = node.heritageClauses.childAt(i); + + if (heritageClause.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */) { + if (seenExtendsClause) { + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.extends_clause_already_seen); + return true; + } + + seenExtendsClause = true; + } else { + TypeScript.Debug.assert(heritageClause.extendsOrImplementsKeyword.tokenKind === 51 /* ImplementsKeyword */); + this.pushDiagnostic1(heritageClauseFullStart, heritageClause, TypeScript.DiagnosticCode.Interface_declaration_cannot_have_implements_clause); + return true; + } + + heritageClauseFullStart += heritageClause.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkInterfaceModifiers = function (modifiers) { + var modifierFullStart = this.position(); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + if (modifier.tokenKind === 63 /* DeclareKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.declare_modifier_cannot_appear_on_an_interface_declaration); + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitInterfaceDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Interface_name_cannot_be_0) || this.checkInterfaceModifiers(node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkInterfaceDeclarationHeritageClauses(node)) { + this.skip(node); + return; + } + + _super.prototype.visitInterfaceDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkClassElementModifiers = function (list) { + var modifierFullStart = this.position(); + + var seenAccessibilityModifier = false; + var seenStaticModifier = false; + + for (var i = 0, n = list.childCount(); i < n; i++) { + var modifier = list.childAt(i); + if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */) { + if (seenAccessibilityModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return true; + } + + if (seenStaticModifier) { + var previousToken = list.childAt(i - 1); + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [modifier.text(), previousToken.text()]); + return true; + } + + seenAccessibilityModifier = true; + } else if (modifier.tokenKind === 58 /* StaticKeyword */) { + if (seenStaticModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]); + return true; + } + + seenStaticModifier = true; + } else { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_class_element, [modifier.text()]); + return true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitMemberVariableDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitMemberVariableDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitMemberFunctionDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitMemberFunctionDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkGetAccessorParameter = function (node, getKeyword, parameterList) { + var getKeywordFullStart = this.childFullStart(node, getKeyword); + if (parameterList.parameters.childCount() !== 0) { + this.pushDiagnostic1(getKeywordFullStart, getKeyword, TypeScript.DiagnosticCode.get_accessor_cannot_have_parameters); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitIndexMemberDeclaration = function (node) { + if (this.checkIndexMemberModifiers(node)) { + this.skip(node); + return; + } + + _super.prototype.visitIndexMemberDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkIndexMemberModifiers = function (node) { + if (node.modifiers.childCount() > 0) { + var modifierFullStart = this.childFullStart(node, node.modifiers); + this.pushDiagnostic1(modifierFullStart, node.modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkEcmaScriptVersionIsAtLeast = function (parent, node, languageVersion, diagnosticKey) { + if (this.syntaxTree.parseOptions().languageVersion() < languageVersion) { + var nodeFullStart = this.childFullStart(parent, node); + this.pushDiagnostic1(nodeFullStart, node, diagnosticKey); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitObjectLiteralExpression = function (node) { + var savedInObjectLiteralExpression = this.inObjectLiteralExpression; + this.inObjectLiteralExpression = true; + _super.prototype.visitObjectLiteralExpression.call(this, node); + this.inObjectLiteralExpression = savedInObjectLiteralExpression; + }; + + GrammarCheckerWalker.prototype.visitGetAccessor = function (node) { + if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.getKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkGetAccessorParameter(node, node.getKeyword, node.parameterList)) { + this.skip(node); + return; + } + + _super.prototype.visitGetAccessor.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkForAccessorDeclarationInAmbientContext = function (accessor) { + if (this.inAmbientDeclaration) { + this.pushDiagnostic1(this.position(), accessor, TypeScript.DiagnosticCode.Accessors_are_not_allowed_in_ambient_contexts, null); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkSetAccessorParameter = function (node, setKeyword, parameterList) { + var setKeywordFullStart = this.childFullStart(node, setKeyword); + if (parameterList.parameters.childCount() !== 1) { + this.pushDiagnostic1(setKeywordFullStart, setKeyword, TypeScript.DiagnosticCode.set_accessor_must_have_one_and_only_one_parameter); + return true; + } + + var parameterListFullStart = this.childFullStart(node, parameterList); + var parameterFullStart = parameterListFullStart + TypeScript.Syntax.childOffset(parameterList, parameterList.openParenToken); + var parameter = parameterList.parameters.childAt(0); + + if (parameter.questionToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_be_optional); + return true; + } + + if (parameter.equalsValueClause) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_parameter_cannot_have_an_initializer); + return true; + } + + if (parameter.dotDotDotToken) { + this.pushDiagnostic1(parameterFullStart, parameter, TypeScript.DiagnosticCode.set_accessor_cannot_have_rest_parameter); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitSetAccessor = function (node) { + if (this.checkForAccessorDeclarationInAmbientContext(node) || this.checkEcmaScriptVersionIsAtLeast(node, node.setKeyword, 1 /* EcmaScript5 */, TypeScript.DiagnosticCode.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkClassElementModifiers(node.modifiers) || this.checkSetAccessorParameter(node, node.setKeyword, node.parameterList)) { + this.skip(node); + return; + } + + _super.prototype.visitSetAccessor.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitEnumDeclaration = function (node) { + if (this.checkForReservedName(node, node.identifier, TypeScript.DiagnosticCode.Enum_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.enumKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers), this.checkEnumElements(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitEnumDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkEnumElements = function (node) { + var enumElementFullStart = this.childFullStart(node, node.enumElements); + + var seenComputedValue = false; + for (var i = 0, n = node.enumElements.childCount(); i < n; i++) { + var child = node.enumElements.childAt(i); + + if (i % 2 === 0) { + var enumElement = child; + + if (!enumElement.equalsValueClause && seenComputedValue) { + this.pushDiagnostic1(enumElementFullStart, enumElement, TypeScript.DiagnosticCode.Enum_member_must_have_initializer, null); + return true; + } + + if (enumElement.equalsValueClause) { + var value = enumElement.equalsValueClause.value; + if (!TypeScript.Syntax.isIntegerLiteral(value)) { + seenComputedValue = true; + } + } + } + + enumElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitEnumElement = function (node) { + if (this.inAmbientDeclaration && node.equalsValueClause) { + var expression = node.equalsValueClause.value; + if (!TypeScript.Syntax.isIntegerLiteral(expression)) { + this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Ambient_enum_elements_can_only_have_integer_literal_initializers); + this.skip(node); + return; + } + } + + _super.prototype.visitEnumElement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitInvocationExpression = function (node) { + if (node.expression.kind() === 50 /* SuperKeyword */ && node.argumentList.typeArgumentList !== null) { + this.pushDiagnostic1(this.position(), node, TypeScript.DiagnosticCode.super_invocation_cannot_have_type_arguments); + } + + _super.prototype.visitInvocationExpression.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkModuleElementModifiers = function (modifiers) { + var modifierFullStart = this.position(); + var seenExportModifier = false; + var seenDeclareModifier = false; + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var modifier = modifiers.childAt(i); + if (modifier.tokenKind === 57 /* PublicKeyword */ || modifier.tokenKind === 55 /* PrivateKeyword */ || modifier.tokenKind === 58 /* StaticKeyword */) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_module_element, [modifier.text()]); + return true; + } + + if (modifier.tokenKind === 63 /* DeclareKeyword */) { + if (seenDeclareModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode.Accessibility_modifier_already_seen); + return; + } + + seenDeclareModifier = true; + } else if (modifier.tokenKind === 47 /* ExportKeyword */) { + if (seenExportModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_already_seen, [modifier.text()]); + return; + } + + if (seenDeclareModifier) { + this.pushDiagnostic1(modifierFullStart, modifier, TypeScript.DiagnosticCode._0_modifier_must_precede_1_modifier, [TypeScript.SyntaxFacts.getText(47 /* ExportKeyword */), TypeScript.SyntaxFacts.getText(63 /* DeclareKeyword */)]); + return; + } + + seenExportModifier = true; + } + + modifierFullStart += modifier.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedImportDeclaration = function (node) { + var currentElementFullStart = this.childFullStart(node, node.moduleElements); + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var child = node.moduleElements.childAt(i); + if (child.kind() === 133 /* ImportDeclaration */) { + var importDeclaration = child; + if (importDeclaration.moduleReference.kind() === 245 /* ExternalModuleReference */) { + if (node.stringLiteral === null) { + this.pushDiagnostic1(currentElementFullStart, importDeclaration, TypeScript.DiagnosticCode.Import_declarations_in_an_internal_module_cannot_reference_an_external_module, null); + } + } + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedDeclareModifierOnImportDeclaration = function (modifiers) { + var declareToken = TypeScript.SyntaxUtilities.getToken(modifiers, 63 /* DeclareKeyword */); + + if (declareToken) { + this.pushDiagnostic1(this.childFullStart(modifiers, declareToken), declareToken, TypeScript.DiagnosticCode.declare_modifier_not_allowed_on_import_declaration); + return true; + } + }; + + GrammarCheckerWalker.prototype.visitImportDeclaration = function (node) { + if (this.checkForDisallowedDeclareModifierOnImportDeclaration(node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + _super.prototype.visitImportDeclaration.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitModuleDeclaration = function (node) { + if (this.checkForReservedName(node, node.name, TypeScript.DiagnosticCode.Module_name_cannot_be_0) || this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForRequiredDeclareModifier(node, node.moduleKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers) || this.checkForDisallowedImportDeclaration(node) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) { + this.skip(node); + return; + } + + if (!TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */) && this.checkFunctionOverloads(node, node.moduleElements)) { + this.skip(node); + return; + } + + if (node.stringLiteral) { + if (!this.inAmbientDeclaration && !TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */)) { + var stringLiteralFullStart = this.childFullStart(node, node.stringLiteral); + this.pushDiagnostic1(stringLiteralFullStart, node.stringLiteral, TypeScript.DiagnosticCode.Only_ambient_modules_can_use_quoted_names); + this.skip(node); + return; + } + } + + if (!node.stringLiteral && this.checkForDisallowedExportAssignment(node)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitModuleDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedExports = function (node, moduleElements) { + var seenExportedElement = false; + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + + if (TypeScript.SyntaxUtilities.hasExportKeyword(child)) { + seenExportedElement = true; + break; + } + } + + var moduleElementFullStart = this.childFullStart(node, moduleElements); + if (seenExportedElement) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + + if (child.kind() === 134 /* ExportAssignment */) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_not_allowed_in_module_with_exported_element); + return true; + } + + moduleElementFullStart += child.fullWidth(); + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.checkForMultipleExportAssignments = function (node, moduleElements) { + var moduleElementFullStart = this.childFullStart(node, moduleElements); + var seenExportAssignment = false; + var errorFound = false; + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var child = moduleElements.childAt(i); + if (child.kind() === 134 /* ExportAssignment */) { + if (seenExportAssignment) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Module_cannot_have_multiple_export_assignments); + errorFound = true; + } + seenExportAssignment = true; + } + + moduleElementFullStart += child.fullWidth(); + } + + return errorFound; + }; + + GrammarCheckerWalker.prototype.checkForDisallowedExportAssignment = function (node) { + var moduleElementFullStart = this.childFullStart(node, node.moduleElements); + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var child = node.moduleElements.childAt(i); + + if (child.kind() === 134 /* ExportAssignment */) { + this.pushDiagnostic1(moduleElementFullStart, child, TypeScript.DiagnosticCode.Export_assignment_cannot_be_used_in_internal_modules); + + return true; + } + + moduleElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitBlock = function (node) { + if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) { + this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Implementations_are_not_allowed_in_ambient_contexts); + this.skip(node); + return; + } + + if (this.checkFunctionOverloads(node, node.statements)) { + this.skip(node); + return; + } + + var savedInBlock = this.inBlock; + this.inBlock = true; + _super.prototype.visitBlock.call(this, node); + this.inBlock = savedInBlock; + }; + + GrammarCheckerWalker.prototype.checkForStatementInAmbientContxt = function (node) { + if (this.inAmbientDeclaration || this.syntaxTree.isDeclaration()) { + this.pushDiagnostic1(this.position(), node.firstToken(), TypeScript.DiagnosticCode.Statements_are_not_allowed_in_ambient_contexts); + return true; + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitBreakStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitBreakStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitContinueStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitContinueStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitDebuggerStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitDebuggerStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitDoStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitDoStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitEmptyStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitEmptyStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitExpressionStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitExpressionStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitForInStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitForInStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitForStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitForStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitIfStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitIfStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitLabeledStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitLabeledStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitReturnStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitReturnStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitSwitchStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitSwitchStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitThrowStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitThrowStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitTryStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitTryStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitWhileStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitWhileStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitWithStatement = function (node) { + if (this.checkForStatementInAmbientContxt(node)) { + this.skip(node); + return; + } + + _super.prototype.visitWithStatement.call(this, node); + }; + + GrammarCheckerWalker.prototype.checkForDisallowedModifiers = function (parent, modifiers) { + if (this.inBlock || this.inObjectLiteralExpression) { + if (modifiers.childCount() > 0) { + var modifierFullStart = this.childFullStart(parent, modifiers); + this.pushDiagnostic1(modifierFullStart, modifiers.childAt(0), TypeScript.DiagnosticCode.Modifiers_cannot_appear_here); + return true; + } + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitFunctionDeclaration = function (node) { + if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.functionKeyword, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitFunctionDeclaration.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitVariableStatement = function (node) { + if (this.checkForDisallowedDeclareModifier(node.modifiers) || this.checkForDisallowedModifiers(node, node.modifiers) || this.checkForRequiredDeclareModifier(node, node.variableDeclaration, node.modifiers) || this.checkModuleElementModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = this.inAmbientDeclaration || this.syntaxTree.isDeclaration() || TypeScript.SyntaxUtilities.containsToken(node.modifiers, 63 /* DeclareKeyword */); + _super.prototype.visitVariableStatement.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.checkListSeparators = function (parent, list, kind) { + var currentElementFullStart = this.childFullStart(parent, list); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var child = list.childAt(i); + if (i % 2 === 1 && child.kind() !== kind) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_expected, [TypeScript.SyntaxFacts.getText(kind)]); + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitObjectType = function (node) { + if (this.checkListSeparators(node, node.typeMembers, 78 /* SemicolonToken */)) { + this.skip(node); + return; + } + + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitObjectType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitArrayType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitArrayType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitFunctionType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitFunctionType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitConstructorType = function (node) { + var savedInAmbientDeclaration = this.inAmbientDeclaration; + this.inAmbientDeclaration = true; + _super.prototype.visitConstructorType.call(this, node); + this.inAmbientDeclaration = savedInAmbientDeclaration; + }; + + GrammarCheckerWalker.prototype.visitVariableDeclarator = function (node) { + if (this.inAmbientDeclaration && node.equalsValueClause) { + this.pushDiagnostic1(this.childFullStart(node, node.equalsValueClause), node.equalsValueClause.firstToken(), TypeScript.DiagnosticCode.Initializers_are_not_allowed_in_ambient_contexts); + this.skip(node); + return; + } + + _super.prototype.visitVariableDeclarator.call(this, node); + }; + + GrammarCheckerWalker.prototype.visitConstructorDeclaration = function (node) { + if (this.checkClassElementModifiers(node.modifiers) || this.checkConstructorModifiers(node.modifiers)) { + this.skip(node); + return; + } + + var savedCurrentConstructor = this.currentConstructor; + this.currentConstructor = node; + _super.prototype.visitConstructorDeclaration.call(this, node); + this.currentConstructor = savedCurrentConstructor; + }; + + GrammarCheckerWalker.prototype.checkConstructorModifiers = function (modifiers) { + var currentElementFullStart = this.position(); + + for (var i = 0, n = modifiers.childCount(); i < n; i++) { + var child = modifiers.childAt(i); + if (child.kind() !== 57 /* PublicKeyword */) { + this.pushDiagnostic1(currentElementFullStart, child, TypeScript.DiagnosticCode._0_modifier_cannot_appear_on_a_constructor_declaration, [TypeScript.SyntaxFacts.getText(child.kind())]); + return true; + } + + currentElementFullStart += child.fullWidth(); + } + + return false; + }; + + GrammarCheckerWalker.prototype.visitSourceUnit = function (node) { + if (this.checkFunctionOverloads(node, node.moduleElements) || this.checkForDisallowedExports(node, node.moduleElements) || this.checkForMultipleExportAssignments(node, node.moduleElements)) { + this.skip(node); + return; + } + + _super.prototype.visitSourceUnit.call(this, node); + }; + return GrammarCheckerWalker; + })(TypeScript.PositionTrackingWalker); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Unicode = (function () { + function Unicode() { + } + Unicode.lookupInUnicodeMap = function (code, map) { + if (code < map[0]) { + return false; + } + + var lo = 0; + var hi = map.length; + var mid; + + while (lo + 1 < hi) { + mid = lo + (hi - lo) / 2; + + mid -= mid % 2; + if (map[mid] <= code && code <= map[mid + 1]) { + return true; + } + + if (code < map[mid]) { + hi = mid; + } else { + lo = mid + 2; + } + } + + return false; + }; + + Unicode.isIdentifierStart = function (code, languageVersion) { + if (languageVersion === 0 /* EcmaScript3 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierStart); + } else if (languageVersion === 1 /* EcmaScript5 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierStart); + } else { + throw TypeScript.Errors.argumentOutOfRange("languageVersion"); + } + }; + + Unicode.isIdentifierPart = function (code, languageVersion) { + if (languageVersion === 0 /* EcmaScript3 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES3IdentifierPart); + } else if (languageVersion === 1 /* EcmaScript5 */) { + return Unicode.lookupInUnicodeMap(code, Unicode.unicodeES5IdentifierPart); + } else { + throw TypeScript.Errors.argumentOutOfRange("languageVersion"); + } + }; + Unicode.unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + Unicode.unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + + Unicode.unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + Unicode.unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500]; + return Unicode; + })(); + TypeScript.Unicode = Unicode; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (CompilerDiagnostics) { + CompilerDiagnostics.debug = false; + + CompilerDiagnostics.diagnosticWriter = null; + + CompilerDiagnostics.analysisPass = 0; + + function Alert(output) { + if (CompilerDiagnostics.diagnosticWriter) { + CompilerDiagnostics.diagnosticWriter.Alert(output); + } + } + CompilerDiagnostics.Alert = Alert; + + function debugPrint(s) { + if (CompilerDiagnostics.debug) { + Alert(s); + } + } + CompilerDiagnostics.debugPrint = debugPrint; + + function assert(condition, s) { + if (CompilerDiagnostics.debug) { + if (!condition) { + Alert(s); + } + } + } + CompilerDiagnostics.assert = assert; + })(TypeScript.CompilerDiagnostics || (TypeScript.CompilerDiagnostics = {})); + var CompilerDiagnostics = TypeScript.CompilerDiagnostics; + + var NullLogger = (function () { + function NullLogger() { + } + NullLogger.prototype.information = function () { + return false; + }; + NullLogger.prototype.debug = function () { + return false; + }; + NullLogger.prototype.warning = function () { + return false; + }; + NullLogger.prototype.error = function () { + return false; + }; + NullLogger.prototype.fatal = function () { + return false; + }; + NullLogger.prototype.log = function (s) { + }; + return NullLogger; + })(); + TypeScript.NullLogger = NullLogger; + + function timeFunction(logger, funcDescription, func) { + var start = (new Date()).getTime(); + var result = func(); + var end = (new Date()).getTime(); + logger.log(funcDescription + " completed in " + (end - start) + " msec"); + return result; + } + TypeScript.timeFunction = timeFunction; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Document = (function () { + function Document(_compiler, _semanticInfoChain, fileName, referencedFiles, _scriptSnapshot, byteOrderMark, version, isOpen, _syntaxTree, _topLevelDecl) { + this._compiler = _compiler; + this._semanticInfoChain = _semanticInfoChain; + this.fileName = fileName; + this.referencedFiles = referencedFiles; + this._scriptSnapshot = _scriptSnapshot; + this.byteOrderMark = byteOrderMark; + this.version = version; + this.isOpen = isOpen; + this._syntaxTree = _syntaxTree; + this._topLevelDecl = _topLevelDecl; + this._diagnostics = null; + this._bloomFilter = null; + this._sourceUnit = null; + this._lineMap = null; + this._declASTMap = []; + this._astDeclMap = []; + this._isExternalModule = undefined; + this._amdDependencies = undefined; + } + Document.prototype.invalidate = function () { + this._declASTMap.length = 0; + this._astDeclMap.length = 0; + this._topLevelDecl = null; + + this._syntaxTree = null; + this._sourceUnit = null; + this._diagnostics = null; + this._bloomFilter = null; + }; + + Document.prototype.isDeclareFile = function () { + return TypeScript.isDTSFile(this.fileName); + }; + + Document.prototype.cacheSyntaxTreeInfo = function (syntaxTree) { + var start = new Date().getTime(); + this._diagnostics = syntaxTree.diagnostics(); + TypeScript.syntaxDiagnosticsTime += new Date().getTime() - start; + + this._lineMap = syntaxTree.lineMap(); + + var sourceUnit = syntaxTree.sourceUnit(); + var leadingComments = this.getLeadingComments(sourceUnit); + + this._isExternalModule = this.hasImplicitImport(leadingComments) || this.hasTopLevelImportOrExport(sourceUnit); + + var amdDependencies = []; + for (var i = 0, n = leadingComments.length; i < n; i++) { + var trivia = leadingComments[i]; + var amdDependency = this.getAmdDependency(trivia.fullText()); + if (amdDependency) { + amdDependencies.push(amdDependency); + } + } + + this._amdDependencies = amdDependencies; + }; + + Document.prototype.getLeadingComments = function (node) { + var firstToken = node.firstToken(); + var result = []; + + if (firstToken.hasLeadingComment()) { + var leadingTrivia = firstToken.leadingTrivia(); + + for (var i = 0, n = leadingTrivia.count(); i < n; i++) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + + if (trivia.isComment()) { + result.push(trivia); + } + } + } + + return result; + }; + + Document.prototype.getAmdDependency = function (comment) { + var amdDependencyRegEx = /^\/\/\/\s*/gim; + var match = implicitImportRegEx.exec(comment); + + if (match) { + return true; + } + + return false; + }; + + Document.prototype.hasTopLevelImportOrExport = function (node) { + var firstToken; + + for (var i = 0, n = node.moduleElements.childCount(); i < n; i++) { + var moduleElement = node.moduleElements.childAt(i); + + firstToken = moduleElement.firstToken(); + if (firstToken !== null && firstToken.tokenKind === 47 /* ExportKeyword */) { + return true; + } + + if (moduleElement.kind() === 133 /* ImportDeclaration */) { + var importDecl = moduleElement; + if (importDecl.moduleReference.kind() === 245 /* ExternalModuleReference */) { + return true; + } + } + } + + return false; + }; + + Document.prototype.sourceUnit = function () { + if (!this._sourceUnit) { + var start = new Date().getTime(); + var syntaxTree = this.syntaxTree(); + this._sourceUnit = TypeScript.SyntaxTreeToAstVisitor.visit(syntaxTree, this.fileName, this._compiler.compilationSettings(), this.isOpen); + TypeScript.astTranslationTime += new Date().getTime() - start; + + if (!this.isOpen) { + this._syntaxTree = null; + } + } + + return this._sourceUnit; + }; + + Document.prototype.diagnostics = function () { + if (this._diagnostics === null) { + this.syntaxTree(); + TypeScript.Debug.assert(this._diagnostics); + } + + return this._diagnostics; + }; + + Document.prototype.lineMap = function () { + if (this._lineMap === null) { + this.syntaxTree(); + TypeScript.Debug.assert(this._lineMap); + } + + return this._lineMap; + }; + + Document.prototype.isExternalModule = function () { + if (this._isExternalModule === undefined) { + this.syntaxTree(); + TypeScript.Debug.assert(this._isExternalModule !== undefined); + } + + return this._isExternalModule; + }; + + Document.prototype.amdDependencies = function () { + if (this._amdDependencies === undefined) { + this.syntaxTree(); + TypeScript.Debug.assert(this._amdDependencies !== undefined); + } + + return this._amdDependencies; + }; + + Document.prototype.syntaxTree = function () { + var result = this._syntaxTree; + if (!result) { + var start = new Date().getTime(); + + result = TypeScript.Parser.parse(this.fileName, TypeScript.SimpleText.fromScriptSnapshot(this._scriptSnapshot), TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())); + + TypeScript.syntaxTreeParseTime += new Date().getTime() - start; + + if (this.isOpen || !this._sourceUnit) { + this._syntaxTree = result; + } + } + + this.cacheSyntaxTreeInfo(result); + return result; + }; + + Document.prototype.bloomFilter = function () { + if (!this._bloomFilter) { + var identifiers = TypeScript.createIntrinsicsObject(); + var pre = function (cur) { + if (TypeScript.isValidAstNode(cur)) { + if (cur.kind() === 11 /* IdentifierName */) { + var nodeText = cur.valueText(); + + identifiers[nodeText] = true; + } + } + }; + + TypeScript.getAstWalkerFactory().simpleWalk(this.sourceUnit(), pre, null, identifiers); + + var identifierCount = 0; + for (var name in identifiers) { + if (identifiers[name]) { + identifierCount++; + } + } + + this._bloomFilter = new TypeScript.BloomFilter(identifierCount); + this._bloomFilter.addKeys(identifiers); + } + return this._bloomFilter; + }; + + Document.prototype.emitToOwnOutputFile = function () { + return !this._compiler.compilationSettings().outFileOption() || this.isExternalModule(); + }; + + Document.prototype.update = function (scriptSnapshot, version, isOpen, textChangeRange) { + var oldSyntaxTree = this._syntaxTree; + + if (textChangeRange !== null && TypeScript.Debug.shouldAssert(1 /* Normal */)) { + var oldText = this._scriptSnapshot; + var newText = scriptSnapshot; + + TypeScript.Debug.assert((oldText.getLength() - textChangeRange.span().length() + textChangeRange.newLength()) === newText.getLength()); + + if (TypeScript.Debug.shouldAssert(3 /* VeryAggressive */)) { + var oldTextPrefix = oldText.getText(0, textChangeRange.span().start()); + var newTextPrefix = newText.getText(0, textChangeRange.span().start()); + TypeScript.Debug.assert(oldTextPrefix === newTextPrefix); + + var oldTextSuffix = oldText.getText(textChangeRange.span().end(), oldText.getLength()); + var newTextSuffix = newText.getText(textChangeRange.newSpan().end(), newText.getLength()); + TypeScript.Debug.assert(oldTextSuffix === newTextSuffix); + } + } + + var text = TypeScript.SimpleText.fromScriptSnapshot(scriptSnapshot); + + var newSyntaxTree = textChangeRange === null || oldSyntaxTree === null ? TypeScript.Parser.parse(this.fileName, text, TypeScript.isDTSFile(this.fileName), TypeScript.getParseOptions(this._compiler.compilationSettings())) : TypeScript.Parser.incrementalParse(oldSyntaxTree, textChangeRange, text); + + return new Document(this._compiler, this._semanticInfoChain, this.fileName, this.referencedFiles, scriptSnapshot, this.byteOrderMark, version, isOpen, newSyntaxTree, null); + }; + + Document.create = function (compiler, semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) { + return new Document(compiler, semanticInfoChain, fileName, referencedFiles, scriptSnapshot, byteOrderMark, version, isOpen, null, null); + }; + + Document.prototype.topLevelDecl = function () { + if (this._topLevelDecl === null) { + this._topLevelDecl = TypeScript.DeclarationCreator.create(this, this._semanticInfoChain, this._compiler.compilationSettings()); + } + + return this._topLevelDecl; + }; + + Document.prototype._getDeclForAST = function (ast) { + this.topLevelDecl(); + return this._astDeclMap[ast.syntaxID()]; + }; + + Document.prototype.getEnclosingDecl = function (ast) { + if (ast.kind() === 120 /* SourceUnit */) { + return this._getDeclForAST(ast); + } + + ast = ast.parent; + var decl = null; + while (ast) { + decl = this._getDeclForAST(ast); + + if (decl) { + break; + } + + ast = ast.parent; + } + + return decl._getEnclosingDeclFromParentDecl(); + }; + + Document.prototype._setDeclForAST = function (ast, decl) { + TypeScript.Debug.assert(decl.fileName() === this.fileName); + this._astDeclMap[ast.syntaxID()] = decl; + }; + + Document.prototype._getASTForDecl = function (decl) { + return this._declASTMap[decl.declID]; + }; + + Document.prototype._setASTForDecl = function (decl, ast) { + TypeScript.Debug.assert(decl.fileName() === this.fileName); + this._declASTMap[decl.declID] = ast; + }; + return Document; + })(); + TypeScript.Document = Document; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function hasFlag(val, flag) { + return (val & flag) !== 0; + } + TypeScript.hasFlag = hasFlag; + + (function (TypeRelationshipFlags) { + TypeRelationshipFlags[TypeRelationshipFlags["SuccessfulComparison"] = 0] = "SuccessfulComparison"; + TypeRelationshipFlags[TypeRelationshipFlags["RequiredPropertyIsMissing"] = 1 << 1] = "RequiredPropertyIsMissing"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleSignatures"] = 1 << 2] = "IncompatibleSignatures"; + TypeRelationshipFlags[TypeRelationshipFlags["SourceSignatureHasTooManyParameters"] = 3] = "SourceSignatureHasTooManyParameters"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleReturnTypes"] = 1 << 4] = "IncompatibleReturnTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatiblePropertyTypes"] = 1 << 5] = "IncompatiblePropertyTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["IncompatibleParameterTypes"] = 1 << 6] = "IncompatibleParameterTypes"; + TypeRelationshipFlags[TypeRelationshipFlags["InconsistantPropertyAccesibility"] = 1 << 7] = "InconsistantPropertyAccesibility"; + })(TypeScript.TypeRelationshipFlags || (TypeScript.TypeRelationshipFlags = {})); + var TypeRelationshipFlags = TypeScript.TypeRelationshipFlags; + + (function (ModuleGenTarget) { + ModuleGenTarget[ModuleGenTarget["Unspecified"] = 0] = "Unspecified"; + ModuleGenTarget[ModuleGenTarget["Synchronous"] = 1] = "Synchronous"; + ModuleGenTarget[ModuleGenTarget["Asynchronous"] = 2] = "Asynchronous"; + })(TypeScript.ModuleGenTarget || (TypeScript.ModuleGenTarget = {})); + var ModuleGenTarget = TypeScript.ModuleGenTarget; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var proto = "__proto__"; + + var BlockIntrinsics = (function () { + function BlockIntrinsics() { + this.prototype = undefined; + this.toString = undefined; + this.toLocaleString = undefined; + this.valueOf = undefined; + this.hasOwnProperty = undefined; + this.propertyIsEnumerable = undefined; + this.isPrototypeOf = undefined; + this["constructor"] = undefined; + + this[proto] = null; + this[proto] = undefined; + } + return BlockIntrinsics; + })(); + + function createIntrinsicsObject() { + return new BlockIntrinsics(); + } + TypeScript.createIntrinsicsObject = createIntrinsicsObject; + + var StringHashTable = (function () { + function StringHashTable() { + this.itemCount = 0; + this.table = createIntrinsicsObject(); + } + StringHashTable.prototype.getAllKeys = function () { + var result = []; + + for (var k in this.table) { + if (this.table[k] !== undefined) { + result.push(k); + } + } + + return result; + }; + + StringHashTable.prototype.add = function (key, data) { + if (this.table[key] !== undefined) { + return false; + } + + this.table[key] = data; + this.itemCount++; + return true; + }; + + StringHashTable.prototype.addOrUpdate = function (key, data) { + if (this.table[key] !== undefined) { + this.table[key] = data; + return false; + } + + this.table[key] = data; + this.itemCount++; + return true; + }; + + StringHashTable.prototype.map = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + fn(k, this.table[k], context); + } + } + }; + + StringHashTable.prototype.every = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + if (!fn(k, this.table[k], context)) { + return false; + } + } + } + + return true; + }; + + StringHashTable.prototype.some = function (fn, context) { + for (var k in this.table) { + var data = this.table[k]; + + if (data !== undefined) { + if (fn(k, this.table[k], context)) { + return true; + } + } + } + + return false; + }; + + StringHashTable.prototype.count = function () { + return this.itemCount; + }; + + StringHashTable.prototype.lookup = function (key) { + var data = this.table[key]; + return data === undefined ? null : data; + }; + + StringHashTable.prototype.remove = function (key) { + if (this.table[key] !== undefined) { + this.table[key] = undefined; + this.itemCount--; + } + }; + return StringHashTable; + })(); + TypeScript.StringHashTable = StringHashTable; + + var IdentiferNameHashTable = (function (_super) { + __extends(IdentiferNameHashTable, _super); + function IdentiferNameHashTable() { + _super.apply(this, arguments); + } + IdentiferNameHashTable.prototype.getAllKeys = function () { + var result = []; + + _super.prototype.map.call(this, function (k, v, c) { + if (v !== undefined) { + result.push(k.substring(1)); + } + }, null); + + return result; + }; + + IdentiferNameHashTable.prototype.add = function (key, data) { + return _super.prototype.add.call(this, "#" + key, data); + }; + + IdentiferNameHashTable.prototype.addOrUpdate = function (key, data) { + return _super.prototype.addOrUpdate.call(this, "#" + key, data); + }; + + IdentiferNameHashTable.prototype.map = function (fn, context) { + return _super.prototype.map.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.every = function (fn, context) { + return _super.prototype.every.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.some = function (fn, context) { + return _super.prototype.some.call(this, function (k, v, c) { + return fn(k.substring(1), v, c); + }, context); + }; + + IdentiferNameHashTable.prototype.lookup = function (key) { + return _super.prototype.lookup.call(this, "#" + key); + }; + return IdentiferNameHashTable; + })(StringHashTable); + TypeScript.IdentiferNameHashTable = IdentiferNameHashTable; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function scriptIsElided(sourceUnit) { + return TypeScript.isDTSFile(sourceUnit.fileName()) || moduleMembersAreElided(sourceUnit.moduleElements); + } + TypeScript.scriptIsElided = scriptIsElided; + + function moduleIsElided(declaration) { + return TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) || moduleMembersAreElided(declaration.moduleElements); + } + TypeScript.moduleIsElided = moduleIsElided; + + function moduleMembersAreElided(members) { + for (var i = 0, n = members.childCount(); i < n; i++) { + var member = members.childAt(i); + + if (member.kind() === 130 /* ModuleDeclaration */) { + if (!moduleIsElided(member)) { + return false; + } + } else if (member.kind() !== 128 /* InterfaceDeclaration */) { + return false; + } + } + + return true; + } + + function enumIsElided(declaration) { + if (TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) { + return true; + } + + return false; + } + TypeScript.enumIsElided = enumIsElided; + + function importDeclarationIsElided(importDeclAST, semanticInfoChain, compilationSettings) { + if (typeof compilationSettings === "undefined") { compilationSettings = null; } + var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */; + var importDecl = semanticInfoChain.getDeclForAST(importDeclAST); + var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */); + var isAmdCodeGen = compilationSettings && compilationSettings.moduleGenTarget() == 2 /* Asynchronous */; + + if (!isExternalModuleReference || isExported || !isAmdCodeGen) { + var importSymbol = importDecl.getSymbol(); + if (importDeclAST.moduleReference.kind() !== 245 /* ExternalModuleReference */) { + if (importSymbol.getExportAssignedValueSymbol()) { + return true; + } + var containerSymbol = importSymbol.getExportAssignedContainerSymbol(); + if (containerSymbol && containerSymbol.getInstanceSymbol()) { + return true; + } + } + + return importSymbol.isUsedAsValue(); + } + + return false; + } + TypeScript.importDeclarationIsElided = importDeclarationIsElided; + + function isValidAstNode(ast) { + if (!ast) + return false; + + if (ast.start() === -1 || ast.end() === -1) + return false; + + return true; + } + TypeScript.isValidAstNode = isValidAstNode; + + function getAstAtPosition(script, pos, useTrailingTriviaAsLimChar, forceInclusive) { + if (typeof useTrailingTriviaAsLimChar === "undefined") { useTrailingTriviaAsLimChar = true; } + if (typeof forceInclusive === "undefined") { forceInclusive = false; } + var top = null; + + var pre = function (cur, walker) { + if (isValidAstNode(cur)) { + var isInvalid1 = cur.kind() === 149 /* ExpressionStatement */ && cur.width() === 0; + + if (isInvalid1) { + walker.options.goChildren = false; + } else { + var inclusive = forceInclusive || cur.kind() === 11 /* IdentifierName */ || cur.kind() === 212 /* MemberAccessExpression */ || cur.kind() === 121 /* QualifiedName */ || cur.kind() === 224 /* VariableDeclaration */ || cur.kind() === 225 /* VariableDeclarator */ || cur.kind() === 213 /* InvocationExpression */ || pos === script.end() + script.trailingTriviaWidth(); + + var minChar = cur.start(); + var limChar = cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0) + (inclusive ? 1 : 0); + if (pos >= minChar && pos < limChar) { + if ((cur.kind() !== 1 /* List */ && cur.kind() !== 2 /* SeparatedList */) || cur.end() > cur.start()) { + if (top === null) { + top = cur; + } else if (cur.start() >= top.start() && (cur.end() + (useTrailingTriviaAsLimChar ? cur.trailingTriviaWidth() : 0)) <= (top.end() + (useTrailingTriviaAsLimChar ? top.trailingTriviaWidth() : 0))) { + if (top.width() !== 0 || cur.width() !== 0) { + top = cur; + } + } + } + } + + walker.options.goChildren = (minChar <= pos && pos <= limChar); + } + } + }; + + TypeScript.getAstWalkerFactory().walk(script, pre); + return top; + } + TypeScript.getAstAtPosition = getAstAtPosition; + + function getExtendsHeritageClause(clauses) { + if (!clauses) { + return null; + } + + return clauses.firstOrDefault(function (c) { + return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 230 /* ExtendsHeritageClause */; + }); + } + TypeScript.getExtendsHeritageClause = getExtendsHeritageClause; + + function getImplementsHeritageClause(clauses) { + if (!clauses) { + return null; + } + + return clauses.firstOrDefault(function (c) { + return c.typeNames.nonSeparatorCount() > 0 && c.kind() === 231 /* ImplementsHeritageClause */; + }); + } + TypeScript.getImplementsHeritageClause = getImplementsHeritageClause; + + function isCallExpression(ast) { + return (ast && ast.kind() === 213 /* InvocationExpression */) || (ast && ast.kind() === 216 /* ObjectCreationExpression */); + } + TypeScript.isCallExpression = isCallExpression; + + function isCallExpressionTarget(ast) { + if (!ast) { + return false; + } + + var current = ast; + + while (current && current.parent) { + if (current.parent.kind() === 212 /* MemberAccessExpression */ && current.parent.name === current) { + current = current.parent; + continue; + } + + break; + } + + if (current && current.parent) { + if (current.parent.kind() === 213 /* InvocationExpression */ || current.parent.kind() === 216 /* ObjectCreationExpression */) { + return current === current.parent.expression; + } + } + + return false; + } + TypeScript.isCallExpressionTarget = isCallExpressionTarget; + + function isNameOfSomeDeclaration(ast) { + if (ast === null || ast.parent === null) { + return false; + } + if (ast.kind() !== 11 /* IdentifierName */) { + return false; + } + + switch (ast.parent.kind()) { + case 131 /* ClassDeclaration */: + return ast.parent.identifier === ast; + case 128 /* InterfaceDeclaration */: + return ast.parent.identifier === ast; + case 132 /* EnumDeclaration */: + return ast.parent.identifier === ast; + case 130 /* ModuleDeclaration */: + return ast.parent.name === ast || ast.parent.stringLiteral === ast; + case 225 /* VariableDeclarator */: + return ast.parent.propertyName === ast; + case 129 /* FunctionDeclaration */: + return ast.parent.identifier === ast; + case 135 /* MemberFunctionDeclaration */: + return ast.parent.propertyName === ast; + case 242 /* Parameter */: + return ast.parent.identifier === ast; + case 238 /* TypeParameter */: + return ast.parent.identifier === ast; + case 240 /* SimplePropertyAssignment */: + return ast.parent.propertyName === ast; + case 241 /* FunctionPropertyAssignment */: + return ast.parent.propertyName === ast; + case 243 /* EnumElement */: + return ast.parent.propertyName === ast; + case 133 /* ImportDeclaration */: + return ast.parent.identifier === ast; + } + + return false; + } + + function isDeclarationASTOrDeclarationNameAST(ast) { + return isNameOfSomeDeclaration(ast) || isDeclarationAST(ast); + } + TypeScript.isDeclarationASTOrDeclarationNameAST = isDeclarationASTOrDeclarationNameAST; + + function isNameOfFunction(ast) { + return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 129 /* FunctionDeclaration */ && ast.parent.identifier === ast; + } + TypeScript.isNameOfFunction = isNameOfFunction; + + function isNameOfMemberFunction(ast) { + return ast && ast.parent && ast.kind() === 11 /* IdentifierName */ && ast.parent.kind() === 135 /* MemberFunctionDeclaration */ && ast.parent.propertyName === ast; + } + TypeScript.isNameOfMemberFunction = isNameOfMemberFunction; + + function isNameOfMemberAccessExpression(ast) { + if (ast && ast.parent && ast.parent.kind() === 212 /* MemberAccessExpression */ && ast.parent.name === ast) { + return true; + } + + return false; + } + TypeScript.isNameOfMemberAccessExpression = isNameOfMemberAccessExpression; + + function isRightSideOfQualifiedName(ast) { + if (ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.right === ast) { + return true; + } + + return false; + } + TypeScript.isRightSideOfQualifiedName = isRightSideOfQualifiedName; + + (function (Parameters) { + function fromIdentifier(id) { + return { + length: 1, + lastParameterIsRest: function () { + return false; + }, + ast: id, + astAt: function (index) { + return id; + }, + identifierAt: function (index) { + return id; + }, + typeAt: function (index) { + return null; + }, + initializerAt: function (index) { + return null; + }, + isOptionalAt: function (index) { + return false; + } + }; + } + Parameters.fromIdentifier = fromIdentifier; + + function fromParameter(parameter) { + return { + length: 1, + lastParameterIsRest: function () { + return parameter.dotDotDotToken !== null; + }, + ast: parameter, + astAt: function (index) { + return parameter; + }, + identifierAt: function (index) { + return parameter.identifier; + }, + typeAt: function (index) { + return TypeScript.getType(parameter); + }, + initializerAt: function (index) { + return parameter.equalsValueClause; + }, + isOptionalAt: function (index) { + return parameterIsOptional(parameter); + } + }; + } + Parameters.fromParameter = fromParameter; + + function parameterIsOptional(parameter) { + return parameter.questionToken !== null || parameter.equalsValueClause !== null; + } + + function fromParameterList(list) { + return { + length: list.parameters.nonSeparatorCount(), + lastParameterIsRest: function () { + return TypeScript.lastParameterIsRest(list); + }, + ast: list.parameters, + astAt: function (index) { + return list.parameters.nonSeparatorAt(index); + }, + identifierAt: function (index) { + return list.parameters.nonSeparatorAt(index).identifier; + }, + typeAt: function (index) { + return TypeScript.getType(list.parameters.nonSeparatorAt(index)); + }, + initializerAt: function (index) { + return list.parameters.nonSeparatorAt(index).equalsValueClause; + }, + isOptionalAt: function (index) { + return parameterIsOptional(list.parameters.nonSeparatorAt(index)); + } + }; + } + Parameters.fromParameterList = fromParameterList; + })(TypeScript.Parameters || (TypeScript.Parameters = {})); + var Parameters = TypeScript.Parameters; + + function isDeclarationAST(ast) { + switch (ast.kind()) { + case 225 /* VariableDeclarator */: + return getVariableStatement(ast) !== null; + + case 133 /* ImportDeclaration */: + case 131 /* ClassDeclaration */: + case 128 /* InterfaceDeclaration */: + case 242 /* Parameter */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 144 /* IndexSignature */: + case 129 /* FunctionDeclaration */: + case 130 /* ModuleDeclaration */: + case 124 /* ArrayType */: + case 122 /* ObjectType */: + case 238 /* TypeParameter */: + case 137 /* ConstructorDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + case 136 /* MemberVariableDeclaration */: + case 138 /* IndexMemberDeclaration */: + case 132 /* EnumDeclaration */: + case 243 /* EnumElement */: + case 240 /* SimplePropertyAssignment */: + case 241 /* FunctionPropertyAssignment */: + case 222 /* FunctionExpression */: + case 142 /* CallSignature */: + case 143 /* ConstructSignature */: + case 145 /* MethodSignature */: + case 141 /* PropertySignature */: + return true; + default: + return false; + } + } + TypeScript.isDeclarationAST = isDeclarationAST; + + function docComments(ast) { + if (isDeclarationAST(ast)) { + var preComments = ast.kind() === 225 /* VariableDeclarator */ ? getVariableStatement(ast).preComments() : ast.preComments(); + + if (preComments && preComments.length > 0) { + var preCommentsLength = preComments.length; + var docComments = new Array(); + for (var i = preCommentsLength - 1; i >= 0; i--) { + if (isDocComment(preComments[i])) { + docComments.push(preComments[i]); + continue; + } + + break; + } + + return docComments.reverse(); + } + } + + return TypeScript.sentinelEmptyArray; + } + TypeScript.docComments = docComments; + + function isDocComment(comment) { + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + var fullText = comment.fullText(); + return fullText.charAt(2) === "*" && fullText.charAt(3) !== "/"; + } + + return false; + } + + function getParameterList(ast) { + if (ast) { + switch (ast.kind()) { + case 137 /* ConstructorDeclaration */: + return ast.parameterList; + case 129 /* FunctionDeclaration */: + return getParameterList(ast.callSignature); + case 218 /* ParenthesizedArrowFunctionExpression */: + return getParameterList(ast.callSignature); + case 143 /* ConstructSignature */: + return getParameterList(ast.callSignature); + case 135 /* MemberFunctionDeclaration */: + return getParameterList(ast.callSignature); + case 241 /* FunctionPropertyAssignment */: + return getParameterList(ast.callSignature); + case 222 /* FunctionExpression */: + return getParameterList(ast.callSignature); + case 145 /* MethodSignature */: + return getParameterList(ast.callSignature); + case 125 /* ConstructorType */: + return ast.parameterList; + case 123 /* FunctionType */: + return ast.parameterList; + case 142 /* CallSignature */: + return ast.parameterList; + case 139 /* GetAccessor */: + return ast.parameterList; + case 140 /* SetAccessor */: + return ast.parameterList; + } + } + + return null; + } + TypeScript.getParameterList = getParameterList; + + function getType(ast) { + if (ast) { + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + return getType(ast.callSignature); + case 218 /* ParenthesizedArrowFunctionExpression */: + return getType(ast.callSignature); + case 143 /* ConstructSignature */: + return getType(ast.callSignature); + case 135 /* MemberFunctionDeclaration */: + return getType(ast.callSignature); + case 241 /* FunctionPropertyAssignment */: + return getType(ast.callSignature); + case 222 /* FunctionExpression */: + return getType(ast.callSignature); + case 145 /* MethodSignature */: + return getType(ast.callSignature); + case 142 /* CallSignature */: + return getType(ast.typeAnnotation); + case 144 /* IndexSignature */: + return getType(ast.typeAnnotation); + case 141 /* PropertySignature */: + return getType(ast.typeAnnotation); + case 139 /* GetAccessor */: + return getType(ast.typeAnnotation); + case 242 /* Parameter */: + return getType(ast.typeAnnotation); + case 136 /* MemberVariableDeclaration */: + return getType(ast.variableDeclarator); + case 225 /* VariableDeclarator */: + return getType(ast.typeAnnotation); + case 236 /* CatchClause */: + return getType(ast.typeAnnotation); + case 125 /* ConstructorType */: + return ast.type; + case 123 /* FunctionType */: + return ast.type; + case 244 /* TypeAnnotation */: + return ast.type; + } + } + + return null; + } + TypeScript.getType = getType; + + function getVariableStatement(variableDeclarator) { + if (variableDeclarator && variableDeclarator.parent && variableDeclarator.parent.parent && variableDeclarator.parent.parent.parent && variableDeclarator.parent.kind() === 2 /* SeparatedList */ && variableDeclarator.parent.parent.kind() === 224 /* VariableDeclaration */ && variableDeclarator.parent.parent.parent.kind() === 148 /* VariableStatement */) { + return variableDeclarator.parent.parent.parent; + } + + return null; + } + + function getVariableDeclaratorModifiers(variableDeclarator) { + var variableStatement = getVariableStatement(variableDeclarator); + return variableStatement ? variableStatement.modifiers : TypeScript.sentinelEmptyArray; + } + TypeScript.getVariableDeclaratorModifiers = getVariableDeclaratorModifiers; + + function isIntegerLiteralAST(expression) { + if (expression) { + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + expression = expression.operand; + return expression.kind() === 13 /* NumericLiteral */ && TypeScript.IntegerUtilities.isInteger(expression.text()); + + case 13 /* NumericLiteral */: + var text = expression.text(); + return TypeScript.IntegerUtilities.isInteger(text) || TypeScript.IntegerUtilities.isHexInteger(text); + } + } + + return false; + } + TypeScript.isIntegerLiteralAST = isIntegerLiteralAST; + + function getEnclosingModuleDeclaration(ast) { + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + return ast; + } + + ast = ast.parent; + } + + return null; + } + TypeScript.getEnclosingModuleDeclaration = getEnclosingModuleDeclaration; + + function isLastNameOfModule(ast, astName) { + if (ast) { + if (ast.stringLiteral) { + return astName === ast.stringLiteral; + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + var nameIndex = moduleNames.indexOf(astName); + + return nameIndex === (moduleNames.length - 1); + } + } + + return false; + } + TypeScript.isLastNameOfModule = isLastNameOfModule; + + function isAnyNameOfModule(ast, astName) { + if (ast) { + if (ast.stringLiteral) { + return ast.stringLiteral === astName; + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + var nameIndex = moduleNames.indexOf(astName); + + return nameIndex >= 0; + } + } + + return false; + } + TypeScript.isAnyNameOfModule = isAnyNameOfModule; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function walkListChildren(preAst, walker) { + for (var i = 0, n = preAst.childCount(); i < n; i++) { + walker.walk(preAst.childAt(i)); + } + } + + function walkThrowStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkPrefixUnaryExpressionChildren(preAst, walker) { + walker.walk(preAst.operand); + } + + function walkPostfixUnaryExpressionChildren(preAst, walker) { + walker.walk(preAst.operand); + } + + function walkDeleteExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkTypeArgumentListChildren(preAst, walker) { + walker.walk(preAst.typeArguments); + } + + function walkTypeOfExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkVoidExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkArgumentListChildren(preAst, walker) { + walker.walk(preAst.typeArgumentList); + walker.walk(preAst.arguments); + } + + function walkArrayLiteralExpressionChildren(preAst, walker) { + walker.walk(preAst.expressions); + } + + function walkSimplePropertyAssignmentChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.expression); + } + + function walkFunctionPropertyAssignmentChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkGetAccessorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.parameterList); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.block); + } + + function walkSeparatedListChildren(preAst, walker) { + for (var i = 0, n = preAst.nonSeparatorCount(); i < n; i++) { + walker.walk(preAst.nonSeparatorAt(i)); + } + } + + function walkSetAccessorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.parameterList); + walker.walk(preAst.block); + } + + function walkObjectLiteralExpressionChildren(preAst, walker) { + walker.walk(preAst.propertyAssignments); + } + + function walkCastExpressionChildren(preAst, walker) { + walker.walk(preAst.type); + walker.walk(preAst.expression); + } + + function walkParenthesizedExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkElementAccessExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentExpression); + } + + function walkMemberAccessExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.name); + } + + function walkQualifiedNameChildren(preAst, walker) { + walker.walk(preAst.left); + walker.walk(preAst.right); + } + + function walkBinaryExpressionChildren(preAst, walker) { + walker.walk(preAst.left); + walker.walk(preAst.right); + } + + function walkEqualsValueClauseChildren(preAst, walker) { + walker.walk(preAst.value); + } + + function walkTypeParameterChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.constraint); + } + + function walkTypeParameterListChildren(preAst, walker) { + walker.walk(preAst.typeParameters); + } + + function walkGenericTypeChildren(preAst, walker) { + walker.walk(preAst.name); + walker.walk(preAst.typeArgumentList); + } + + function walkTypeAnnotationChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkTypeQueryChildren(preAst, walker) { + walker.walk(preAst.name); + } + + function walkInvocationExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentList); + } + + function walkObjectCreationExpressionChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.argumentList); + } + + function walkTrinaryExpressionChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.whenTrue); + walker.walk(preAst.whenFalse); + } + + function walkFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkFunctionTypeChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.type); + } + + function walkParenthesizedArrowFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + walker.walk(preAst.expression); + } + + function walkSimpleArrowFunctionExpressionChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.block); + walker.walk(preAst.expression); + } + + function walkMemberFunctionDeclarationChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkFuncDeclChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.callSignature); + walker.walk(preAst.block); + } + + function walkIndexMemberDeclarationChildren(preAst, walker) { + walker.walk(preAst.indexSignature); + } + + function walkIndexSignatureChildren(preAst, walker) { + walker.walk(preAst.parameter); + walker.walk(preAst.typeAnnotation); + } + + function walkCallSignatureChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.typeAnnotation); + } + + function walkConstraintChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkConstructorDeclarationChildren(preAst, walker) { + walker.walk(preAst.parameterList); + walker.walk(preAst.block); + } + + function walkConstructorTypeChildren(preAst, walker) { + walker.walk(preAst.typeParameterList); + walker.walk(preAst.parameterList); + walker.walk(preAst.type); + } + + function walkConstructSignatureChildren(preAst, walker) { + walker.walk(preAst.callSignature); + } + + function walkParameterChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.equalsValueClause); + } + + function walkParameterListChildren(preAst, walker) { + walker.walk(preAst.parameters); + } + + function walkPropertySignatureChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.typeAnnotation); + } + + function walkVariableDeclaratorChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.equalsValueClause); + } + + function walkMemberVariableDeclarationChildren(preAst, walker) { + walker.walk(preAst.variableDeclarator); + } + + function walkMethodSignatureChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.callSignature); + } + + function walkReturnStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkForStatementChildren(preAst, walker) { + walker.walk(preAst.variableDeclaration); + walker.walk(preAst.initializer); + walker.walk(preAst.condition); + walker.walk(preAst.incrementor); + walker.walk(preAst.statement); + } + + function walkForInStatementChildren(preAst, walker) { + walker.walk(preAst.variableDeclaration); + walker.walk(preAst.left); + walker.walk(preAst.expression); + walker.walk(preAst.statement); + } + + function walkIfStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + walker.walk(preAst.elseClause); + } + + function walkElseClauseChildren(preAst, walker) { + walker.walk(preAst.statement); + } + + function walkWhileStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkDoStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkBlockChildren(preAst, walker) { + walker.walk(preAst.statements); + } + + function walkVariableDeclarationChildren(preAst, walker) { + walker.walk(preAst.declarators); + } + + function walkCaseSwitchClauseChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.statements); + } + + function walkDefaultSwitchClauseChildren(preAst, walker) { + walker.walk(preAst.statements); + } + + function walkSwitchStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + walker.walk(preAst.switchClauses); + } + + function walkTryStatementChildren(preAst, walker) { + walker.walk(preAst.block); + walker.walk(preAst.catchClause); + walker.walk(preAst.finallyClause); + } + + function walkCatchClauseChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeAnnotation); + walker.walk(preAst.block); + } + + function walkExternalModuleReferenceChildren(preAst, walker) { + walker.walk(preAst.stringLiteral); + } + + function walkFinallyClauseChildren(preAst, walker) { + walker.walk(preAst.block); + } + + function walkClassDeclChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeParameterList); + walker.walk(preAst.heritageClauses); + walker.walk(preAst.classElements); + } + + function walkScriptChildren(preAst, walker) { + walker.walk(preAst.moduleElements); + } + + function walkHeritageClauseChildren(preAst, walker) { + walker.walk(preAst.typeNames); + } + + function walkInterfaceDeclerationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.typeParameterList); + walker.walk(preAst.heritageClauses); + walker.walk(preAst.body); + } + + function walkObjectTypeChildren(preAst, walker) { + walker.walk(preAst.typeMembers); + } + + function walkArrayTypeChildren(preAst, walker) { + walker.walk(preAst.type); + } + + function walkModuleDeclarationChildren(preAst, walker) { + walker.walk(preAst.name); + walker.walk(preAst.stringLiteral); + walker.walk(preAst.moduleElements); + } + + function walkModuleNameModuleReferenceChildren(preAst, walker) { + walker.walk(preAst.moduleName); + } + + function walkEnumDeclarationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.enumElements); + } + + function walkEnumElementChildren(preAst, walker) { + walker.walk(preAst.propertyName); + walker.walk(preAst.equalsValueClause); + } + + function walkImportDeclarationChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.moduleReference); + } + + function walkExportAssignmentChildren(preAst, walker) { + walker.walk(preAst.identifier); + } + + function walkWithStatementChildren(preAst, walker) { + walker.walk(preAst.condition); + walker.walk(preAst.statement); + } + + function walkExpressionStatementChildren(preAst, walker) { + walker.walk(preAst.expression); + } + + function walkLabeledStatementChildren(preAst, walker) { + walker.walk(preAst.identifier); + walker.walk(preAst.statement); + } + + function walkVariableStatementChildren(preAst, walker) { + walker.walk(preAst.declaration); + } + + var childrenWalkers = new Array(246 /* Last */ + 1); + + for (var i = 9 /* FirstToken */, n = 119 /* LastToken */; i <= n; i++) { + childrenWalkers[i] = null; + } + for (var i = 4 /* FirstTrivia */, n = 8 /* LastTrivia */; i <= n; i++) { + childrenWalkers[i] = null; + } + + childrenWalkers[175 /* AddAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[208 /* AddExpression */] = walkBinaryExpressionChildren; + childrenWalkers[180 /* AndAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[60 /* AnyKeyword */] = null; + childrenWalkers[226 /* ArgumentList */] = walkArgumentListChildren; + childrenWalkers[214 /* ArrayLiteralExpression */] = walkArrayLiteralExpressionChildren; + childrenWalkers[124 /* ArrayType */] = walkArrayTypeChildren; + childrenWalkers[219 /* SimpleArrowFunctionExpression */] = walkSimpleArrowFunctionExpressionChildren; + childrenWalkers[218 /* ParenthesizedArrowFunctionExpression */] = walkParenthesizedArrowFunctionExpressionChildren; + childrenWalkers[174 /* AssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[191 /* BitwiseAndExpression */] = walkBinaryExpressionChildren; + childrenWalkers[190 /* BitwiseExclusiveOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[166 /* BitwiseNotExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[189 /* BitwiseOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[146 /* Block */] = walkBlockChildren; + childrenWalkers[61 /* BooleanKeyword */] = null; + childrenWalkers[152 /* BreakStatement */] = null; + childrenWalkers[142 /* CallSignature */] = walkCallSignatureChildren; + childrenWalkers[233 /* CaseSwitchClause */] = walkCaseSwitchClauseChildren; + childrenWalkers[220 /* CastExpression */] = walkCastExpressionChildren; + childrenWalkers[236 /* CatchClause */] = walkCatchClauseChildren; + childrenWalkers[131 /* ClassDeclaration */] = walkClassDeclChildren; + childrenWalkers[173 /* CommaExpression */] = walkBinaryExpressionChildren; + childrenWalkers[186 /* ConditionalExpression */] = walkTrinaryExpressionChildren; + childrenWalkers[239 /* Constraint */] = walkConstraintChildren; + childrenWalkers[137 /* ConstructorDeclaration */] = walkConstructorDeclarationChildren; + childrenWalkers[143 /* ConstructSignature */] = walkConstructSignatureChildren; + childrenWalkers[153 /* ContinueStatement */] = null; + childrenWalkers[125 /* ConstructorType */] = walkConstructorTypeChildren; + childrenWalkers[162 /* DebuggerStatement */] = null; + childrenWalkers[234 /* DefaultSwitchClause */] = walkDefaultSwitchClauseChildren; + childrenWalkers[170 /* DeleteExpression */] = walkDeleteExpressionChildren; + childrenWalkers[178 /* DivideAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[206 /* DivideExpression */] = walkBinaryExpressionChildren; + childrenWalkers[161 /* DoStatement */] = walkDoStatementChildren; + childrenWalkers[221 /* ElementAccessExpression */] = walkElementAccessExpressionChildren; + childrenWalkers[235 /* ElseClause */] = walkElseClauseChildren; + childrenWalkers[156 /* EmptyStatement */] = null; + childrenWalkers[132 /* EnumDeclaration */] = walkEnumDeclarationChildren; + childrenWalkers[243 /* EnumElement */] = walkEnumElementChildren; + childrenWalkers[194 /* EqualsExpression */] = walkBinaryExpressionChildren; + childrenWalkers[232 /* EqualsValueClause */] = walkEqualsValueClauseChildren; + childrenWalkers[192 /* EqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren; + childrenWalkers[181 /* ExclusiveOrAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[134 /* ExportAssignment */] = walkExportAssignmentChildren; + childrenWalkers[149 /* ExpressionStatement */] = walkExpressionStatementChildren; + childrenWalkers[230 /* ExtendsHeritageClause */] = walkHeritageClauseChildren; + childrenWalkers[245 /* ExternalModuleReference */] = walkExternalModuleReferenceChildren; + childrenWalkers[24 /* FalseKeyword */] = null; + childrenWalkers[237 /* FinallyClause */] = walkFinallyClauseChildren; + childrenWalkers[155 /* ForInStatement */] = walkForInStatementChildren; + childrenWalkers[154 /* ForStatement */] = walkForStatementChildren; + childrenWalkers[129 /* FunctionDeclaration */] = walkFuncDeclChildren; + childrenWalkers[222 /* FunctionExpression */] = walkFunctionExpressionChildren; + childrenWalkers[241 /* FunctionPropertyAssignment */] = walkFunctionPropertyAssignmentChildren; + childrenWalkers[123 /* FunctionType */] = walkFunctionTypeChildren; + childrenWalkers[126 /* GenericType */] = walkGenericTypeChildren; + childrenWalkers[139 /* GetAccessor */] = walkGetAccessorChildren; + childrenWalkers[197 /* GreaterThanExpression */] = walkBinaryExpressionChildren; + childrenWalkers[199 /* GreaterThanOrEqualExpression */] = walkBinaryExpressionChildren; + childrenWalkers[147 /* IfStatement */] = walkIfStatementChildren; + childrenWalkers[231 /* ImplementsHeritageClause */] = walkHeritageClauseChildren; + childrenWalkers[133 /* ImportDeclaration */] = walkImportDeclarationChildren; + childrenWalkers[138 /* IndexMemberDeclaration */] = walkIndexMemberDeclarationChildren; + childrenWalkers[144 /* IndexSignature */] = walkIndexSignatureChildren; + childrenWalkers[201 /* InExpression */] = walkBinaryExpressionChildren; + childrenWalkers[200 /* InstanceOfExpression */] = walkBinaryExpressionChildren; + childrenWalkers[128 /* InterfaceDeclaration */] = walkInterfaceDeclerationChildren; + childrenWalkers[213 /* InvocationExpression */] = walkInvocationExpressionChildren; + childrenWalkers[160 /* LabeledStatement */] = walkLabeledStatementChildren; + childrenWalkers[183 /* LeftShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[202 /* LeftShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[196 /* LessThanExpression */] = walkBinaryExpressionChildren; + childrenWalkers[198 /* LessThanOrEqualExpression */] = walkBinaryExpressionChildren; + childrenWalkers[1 /* List */] = walkListChildren; + childrenWalkers[188 /* LogicalAndExpression */] = walkBinaryExpressionChildren; + childrenWalkers[167 /* LogicalNotExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[187 /* LogicalOrExpression */] = walkBinaryExpressionChildren; + childrenWalkers[212 /* MemberAccessExpression */] = walkMemberAccessExpressionChildren; + childrenWalkers[135 /* MemberFunctionDeclaration */] = walkMemberFunctionDeclarationChildren; + childrenWalkers[136 /* MemberVariableDeclaration */] = walkMemberVariableDeclarationChildren; + childrenWalkers[145 /* MethodSignature */] = walkMethodSignatureChildren; + childrenWalkers[130 /* ModuleDeclaration */] = walkModuleDeclarationChildren; + childrenWalkers[246 /* ModuleNameModuleReference */] = walkModuleNameModuleReferenceChildren; + childrenWalkers[179 /* ModuloAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[207 /* ModuloExpression */] = walkBinaryExpressionChildren; + childrenWalkers[177 /* MultiplyAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[205 /* MultiplyExpression */] = walkBinaryExpressionChildren; + childrenWalkers[11 /* IdentifierName */] = null; + childrenWalkers[165 /* NegateExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[0 /* None */] = null; + childrenWalkers[195 /* NotEqualsExpression */] = walkBinaryExpressionChildren; + childrenWalkers[193 /* NotEqualsWithTypeConversionExpression */] = walkBinaryExpressionChildren; + childrenWalkers[32 /* NullKeyword */] = null; + childrenWalkers[67 /* NumberKeyword */] = null; + childrenWalkers[13 /* NumericLiteral */] = null; + childrenWalkers[216 /* ObjectCreationExpression */] = walkObjectCreationExpressionChildren; + childrenWalkers[215 /* ObjectLiteralExpression */] = walkObjectLiteralExpressionChildren; + childrenWalkers[122 /* ObjectType */] = walkObjectTypeChildren; + childrenWalkers[223 /* OmittedExpression */] = null; + childrenWalkers[182 /* OrAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[242 /* Parameter */] = walkParameterChildren; + childrenWalkers[227 /* ParameterList */] = walkParameterListChildren; + childrenWalkers[217 /* ParenthesizedExpression */] = walkParenthesizedExpressionChildren; + childrenWalkers[164 /* PlusExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[211 /* PostDecrementExpression */] = walkPostfixUnaryExpressionChildren; + childrenWalkers[210 /* PostIncrementExpression */] = walkPostfixUnaryExpressionChildren; + childrenWalkers[169 /* PreDecrementExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[168 /* PreIncrementExpression */] = walkPrefixUnaryExpressionChildren; + childrenWalkers[141 /* PropertySignature */] = walkPropertySignatureChildren; + childrenWalkers[121 /* QualifiedName */] = walkQualifiedNameChildren; + childrenWalkers[12 /* RegularExpressionLiteral */] = null; + childrenWalkers[150 /* ReturnStatement */] = walkReturnStatementChildren; + childrenWalkers[120 /* SourceUnit */] = walkScriptChildren; + childrenWalkers[2 /* SeparatedList */] = walkSeparatedListChildren; + childrenWalkers[140 /* SetAccessor */] = walkSetAccessorChildren; + childrenWalkers[184 /* SignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[203 /* SignedRightShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[240 /* SimplePropertyAssignment */] = walkSimplePropertyAssignmentChildren; + childrenWalkers[14 /* StringLiteral */] = null; + childrenWalkers[69 /* StringKeyword */] = null; + childrenWalkers[176 /* SubtractAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[209 /* SubtractExpression */] = walkBinaryExpressionChildren; + childrenWalkers[50 /* SuperKeyword */] = null; + childrenWalkers[151 /* SwitchStatement */] = walkSwitchStatementChildren; + childrenWalkers[35 /* ThisKeyword */] = null; + childrenWalkers[157 /* ThrowStatement */] = walkThrowStatementChildren; + childrenWalkers[3 /* TriviaList */] = null; + childrenWalkers[37 /* TrueKeyword */] = null; + childrenWalkers[159 /* TryStatement */] = walkTryStatementChildren; + childrenWalkers[244 /* TypeAnnotation */] = walkTypeAnnotationChildren; + childrenWalkers[228 /* TypeArgumentList */] = walkTypeArgumentListChildren; + childrenWalkers[171 /* TypeOfExpression */] = walkTypeOfExpressionChildren; + childrenWalkers[238 /* TypeParameter */] = walkTypeParameterChildren; + childrenWalkers[229 /* TypeParameterList */] = walkTypeParameterListChildren; + childrenWalkers[127 /* TypeQuery */] = walkTypeQueryChildren; + childrenWalkers[185 /* UnsignedRightShiftAssignmentExpression */] = walkBinaryExpressionChildren; + childrenWalkers[204 /* UnsignedRightShiftExpression */] = walkBinaryExpressionChildren; + childrenWalkers[224 /* VariableDeclaration */] = walkVariableDeclarationChildren; + childrenWalkers[225 /* VariableDeclarator */] = walkVariableDeclaratorChildren; + childrenWalkers[148 /* VariableStatement */] = walkVariableStatementChildren; + childrenWalkers[172 /* VoidExpression */] = walkVoidExpressionChildren; + childrenWalkers[41 /* VoidKeyword */] = null; + childrenWalkers[158 /* WhileStatement */] = walkWhileStatementChildren; + childrenWalkers[163 /* WithStatement */] = walkWithStatementChildren; + + for (var e in TypeScript.SyntaxKind) { + if (TypeScript.SyntaxKind.hasOwnProperty(e) && TypeScript.StringUtilities.isString(TypeScript.SyntaxKind[e])) { + TypeScript.Debug.assert(childrenWalkers[e] !== undefined, "Fix initWalkers: " + TypeScript.SyntaxKind[e]); + } + } + + var AstWalkOptions = (function () { + function AstWalkOptions() { + this.goChildren = true; + this.stopWalking = false; + } + return AstWalkOptions; + })(); + TypeScript.AstWalkOptions = AstWalkOptions; + + var SimplePreAstWalker = (function () { + function SimplePreAstWalker(pre, state) { + this.pre = pre; + this.state = state; + this.options = new AstWalkOptions(); + } + SimplePreAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + this.pre(ast, this.state); + + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + }; + return SimplePreAstWalker; + })(); + + var SimplePrePostAstWalker = (function () { + function SimplePrePostAstWalker(pre, post, state) { + this.pre = pre; + this.post = post; + this.state = state; + this.options = new AstWalkOptions(); + } + SimplePrePostAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + this.pre(ast, this.state); + + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + + this.post(ast, this.state); + }; + return SimplePrePostAstWalker; + })(); + + var NormalAstWalker = (function () { + function NormalAstWalker(pre, post, state) { + this.pre = pre; + this.post = post; + this.state = state; + this.options = new AstWalkOptions(); + } + NormalAstWalker.prototype.walk = function (ast) { + if (!ast) { + return; + } + + if (this.options.stopWalking) { + return; + } + + this.pre(ast, this); + + if (this.options.stopWalking) { + return; + } + + if (this.options.goChildren) { + var walker = childrenWalkers[ast.kind()]; + if (walker) { + walker(ast, this); + } + } else { + this.options.goChildren = true; + } + + if (this.post) { + this.post(ast, this); + } + }; + return NormalAstWalker; + })(); + + var AstWalkerFactory = (function () { + function AstWalkerFactory() { + } + AstWalkerFactory.prototype.walk = function (ast, pre, post, state) { + new NormalAstWalker(pre, post, state).walk(ast); + }; + + AstWalkerFactory.prototype.simpleWalk = function (ast, pre, post, state) { + if (post) { + new SimplePrePostAstWalker(pre, post, state).walk(ast); + } else { + new SimplePreAstWalker(pre, state).walk(ast); + } + }; + return AstWalkerFactory; + })(); + TypeScript.AstWalkerFactory = AstWalkerFactory; + + var globalAstWalkerFactory = new AstWalkerFactory(); + + function getAstWalkerFactory() { + return globalAstWalkerFactory; + } + TypeScript.getAstWalkerFactory = getAstWalkerFactory; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var Base64Format = (function () { + function Base64Format() { + } + Base64Format.encode = function (inValue) { + if (inValue < 64) { + return Base64Format.encodedValues.charAt(inValue); + } + throw TypeError(inValue + ": not a 64 based value"); + }; + + Base64Format.decodeChar = function (inChar) { + if (inChar.length === 1) { + return Base64Format.encodedValues.indexOf(inChar); + } else { + throw TypeError('"' + inChar + '" must have length 1'); + } + }; + Base64Format.encodedValues = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + return Base64Format; + })(); + + var Base64VLQFormat = (function () { + function Base64VLQFormat() { + } + Base64VLQFormat.encode = function (inValue) { + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } else { + inValue = inValue << 1; + } + + var encodedStr = ""; + do { + var currentDigit = inValue & 31; + inValue = inValue >> 5; + if (inValue > 0) { + currentDigit = currentDigit | 32; + } + encodedStr = encodedStr + Base64Format.encode(currentDigit); + } while(inValue > 0); + + return encodedStr; + }; + + Base64VLQFormat.decode = function (inString) { + var result = 0; + var negative = false; + + var shift = 0; + for (var i = 0; i < inString.length; i++) { + var byte = Base64Format.decodeChar(inString[i]); + if (i === 0) { + if ((byte & 1) === 1) { + negative = true; + } + result = (byte >> 1) & 15; + } else { + result = result | ((byte & 31) << shift); + } + + shift += (i === 0) ? 4 : 5; + + if ((byte & 32) === 32) { + } else { + return { value: negative ? -(result) : result, rest: inString.substr(i + 1) }; + } + } + + throw new Error(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Base64_value_0_finished_with_a_continuation_bit, [inString])); + }; + return Base64VLQFormat; + })(); + TypeScript.Base64VLQFormat = Base64VLQFormat; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SourceMapPosition = (function () { + function SourceMapPosition() { + } + return SourceMapPosition; + })(); + TypeScript.SourceMapPosition = SourceMapPosition; + + var SourceMapping = (function () { + function SourceMapping() { + this.start = new SourceMapPosition(); + this.end = new SourceMapPosition(); + this.nameIndex = -1; + this.childMappings = []; + } + return SourceMapping; + })(); + TypeScript.SourceMapping = SourceMapping; + + var SourceMapEntry = (function () { + function SourceMapEntry(emittedFile, emittedLine, emittedColumn, sourceFile, sourceLine, sourceColumn, sourceName) { + this.emittedFile = emittedFile; + this.emittedLine = emittedLine; + this.emittedColumn = emittedColumn; + this.sourceFile = sourceFile; + this.sourceLine = sourceLine; + this.sourceColumn = sourceColumn; + this.sourceName = sourceName; + TypeScript.Debug.assert(isFinite(emittedLine)); + TypeScript.Debug.assert(isFinite(emittedColumn)); + TypeScript.Debug.assert(isFinite(sourceColumn)); + TypeScript.Debug.assert(isFinite(sourceLine)); + } + return SourceMapEntry; + })(); + TypeScript.SourceMapEntry = SourceMapEntry; + + var SourceMapper = (function () { + function SourceMapper(jsFile, sourceMapOut, document, jsFilePath, emitOptions, resolvePath) { + this.jsFile = jsFile; + this.sourceMapOut = sourceMapOut; + this.names = []; + this.mappingLevel = []; + this.tsFilePaths = []; + this.allSourceMappings = []; + this.sourceMapEntries = []; + this.setSourceMapOptions(document, jsFilePath, emitOptions, resolvePath); + this.setNewSourceFile(document, emitOptions); + } + SourceMapper.prototype.getOutputFile = function () { + var result = this.sourceMapOut.getOutputFile(); + result.sourceMapEntries = this.sourceMapEntries; + + return result; + }; + + SourceMapper.prototype.increaseMappingLevel = function (ast) { + this.mappingLevel.push(ast); + }; + + SourceMapper.prototype.decreaseMappingLevel = function (ast) { + TypeScript.Debug.assert(this.mappingLevel.length > 0, "Mapping level should never be less than 0. This suggests a missing start call."); + var expectedAst = this.mappingLevel.pop(); + var expectedAstInfo = expectedAst.kind ? TypeScript.SyntaxKind[expectedAst.kind()] : [expectedAst.start(), expectedAst.end()]; + var astInfo = ast.kind ? TypeScript.SyntaxKind[ast.kind()] : [ast.start(), ast.end()]; + TypeScript.Debug.assert(ast === expectedAst, "Provided ast is not the expected AST, Expected: " + expectedAstInfo + " Given: " + astInfo); + }; + + SourceMapper.prototype.setNewSourceFile = function (document, emitOptions) { + var sourceMappings = []; + this.allSourceMappings.push(sourceMappings); + this.currentMappings = [sourceMappings]; + this.currentNameIndex = []; + + this.setNewSourceFilePath(document, emitOptions); + }; + + SourceMapper.prototype.setSourceMapOptions = function (document, jsFilePath, emitOptions, resolvePath) { + var prettyJsFileName = TypeScript.getPrettyName(jsFilePath, false, true); + var prettyMapFileName = prettyJsFileName + SourceMapper.MapFileExtension; + this.jsFileName = prettyJsFileName; + + if (emitOptions.sourceMapRootDirectory()) { + this.sourceMapDirectory = emitOptions.sourceMapRootDirectory(); + if (document.emitToOwnOutputFile()) { + this.sourceMapDirectory = this.sourceMapDirectory + TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath((document.fileName)).replace(emitOptions.commonDirectoryPath(), "")); + } + + if (TypeScript.isRelative(this.sourceMapDirectory)) { + this.sourceMapDirectory = emitOptions.commonDirectoryPath() + this.sourceMapDirectory; + this.sourceMapDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(this.sourceMapDirectory))); + this.sourceMapPath = TypeScript.getRelativePathToFixedPath(TypeScript.getRootFilePath(jsFilePath), this.sourceMapDirectory + prettyMapFileName); + } else { + this.sourceMapPath = this.sourceMapDirectory + prettyMapFileName; + } + } else { + this.sourceMapPath = prettyMapFileName; + this.sourceMapDirectory = TypeScript.getRootFilePath(jsFilePath); + } + this.sourceRoot = emitOptions.sourceRootDirectory(); + }; + + SourceMapper.prototype.setNewSourceFilePath = function (document, emitOptions) { + var tsFilePath = TypeScript.switchToForwardSlashes(document.fileName); + if (emitOptions.sourceRootDirectory()) { + tsFilePath = TypeScript.getRelativePathToFixedPath(emitOptions.commonDirectoryPath(), tsFilePath); + } else { + tsFilePath = TypeScript.getRelativePathToFixedPath(this.sourceMapDirectory, tsFilePath); + } + this.tsFilePaths.push(tsFilePath); + }; + + SourceMapper.prototype.emitSourceMapping = function () { + var _this = this; + TypeScript.Debug.assert(this.mappingLevel.length === 0, "Mapping level is not 0. This suggest a missing end call. Value: " + this.mappingLevel.map(function (item) { + return ['Node of type', TypeScript.SyntaxKind[item.kind()], 'at', item.start(), 'to', item.end()].join(' '); + }).join(', ')); + + this.jsFile.WriteLine("//# sourceMappingURL=" + this.sourceMapPath); + + var mappingsString = ""; + + var prevEmittedColumn = 0; + var prevEmittedLine = 0; + var prevSourceColumn = 0; + var prevSourceLine = 0; + var prevSourceIndex = 0; + var prevNameIndex = 0; + var emitComma = false; + + var recordedPosition = null; + for (var sourceIndex = 0; sourceIndex < this.tsFilePaths.length; sourceIndex++) { + var recordSourceMapping = function (mappedPosition, nameIndex) { + if (recordedPosition !== null && recordedPosition.emittedColumn === mappedPosition.emittedColumn && recordedPosition.emittedLine === mappedPosition.emittedLine) { + return; + } + + if (prevEmittedLine !== mappedPosition.emittedLine) { + while (prevEmittedLine < mappedPosition.emittedLine) { + prevEmittedColumn = 0; + mappingsString = mappingsString + ";"; + prevEmittedLine++; + } + emitComma = false; + } else if (emitComma) { + mappingsString = mappingsString + ","; + } + + _this.sourceMapEntries.push(new SourceMapEntry(_this.jsFileName, mappedPosition.emittedLine + 1, mappedPosition.emittedColumn + 1, _this.tsFilePaths[sourceIndex], mappedPosition.sourceLine, mappedPosition.sourceColumn + 1, nameIndex >= 0 ? _this.names[nameIndex] : undefined)); + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.emittedColumn - prevEmittedColumn); + prevEmittedColumn = mappedPosition.emittedColumn; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(sourceIndex - prevSourceIndex); + prevSourceIndex = sourceIndex; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceLine - 1 - prevSourceLine); + prevSourceLine = mappedPosition.sourceLine - 1; + + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(mappedPosition.sourceColumn - prevSourceColumn); + prevSourceColumn = mappedPosition.sourceColumn; + + if (nameIndex >= 0) { + mappingsString = mappingsString + TypeScript.Base64VLQFormat.encode(nameIndex - prevNameIndex); + prevNameIndex = nameIndex; + } + + emitComma = true; + recordedPosition = mappedPosition; + }; + + var recordSourceMappingSiblings = function (sourceMappings) { + for (var i = 0; i < sourceMappings.length; i++) { + var sourceMapping = sourceMappings[i]; + recordSourceMapping(sourceMapping.start, sourceMapping.nameIndex); + recordSourceMappingSiblings(sourceMapping.childMappings); + recordSourceMapping(sourceMapping.end, sourceMapping.nameIndex); + } + }; + + recordSourceMappingSiblings(this.allSourceMappings[sourceIndex]); + } + + this.sourceMapOut.Write(JSON.stringify({ + version: 3, + file: this.jsFileName, + sourceRoot: this.sourceRoot, + sources: this.tsFilePaths, + names: this.names, + mappings: mappingsString + })); + + this.sourceMapOut.Close(); + }; + SourceMapper.MapFileExtension = ".map"; + return SourceMapper; + })(); + TypeScript.SourceMapper = SourceMapper; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (EmitContainer) { + EmitContainer[EmitContainer["Prog"] = 0] = "Prog"; + EmitContainer[EmitContainer["Module"] = 1] = "Module"; + EmitContainer[EmitContainer["DynamicModule"] = 2] = "DynamicModule"; + EmitContainer[EmitContainer["Class"] = 3] = "Class"; + EmitContainer[EmitContainer["Constructor"] = 4] = "Constructor"; + EmitContainer[EmitContainer["Function"] = 5] = "Function"; + EmitContainer[EmitContainer["Args"] = 6] = "Args"; + EmitContainer[EmitContainer["Interface"] = 7] = "Interface"; + })(TypeScript.EmitContainer || (TypeScript.EmitContainer = {})); + var EmitContainer = TypeScript.EmitContainer; + + var EmitState = (function () { + function EmitState() { + this.column = 0; + this.line = 0; + this.container = 0 /* Prog */; + } + return EmitState; + })(); + TypeScript.EmitState = EmitState; + + var EmitOptions = (function () { + function EmitOptions(compiler, resolvePath) { + this.resolvePath = resolvePath; + this._diagnostic = null; + this._settings = null; + this._commonDirectoryPath = ""; + this._sharedOutputFile = ""; + this._sourceRootDirectory = ""; + this._sourceMapRootDirectory = ""; + this._outputDirectory = ""; + var settings = compiler.compilationSettings(); + this._settings = settings; + + if (settings.moduleGenTarget() === 0 /* Unspecified */ && compiler._isDynamicModuleCompilation()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_compile_external_modules_unless_the_module_flag_is_provided, null); + return; + } + + if (!settings.mapSourceFiles()) { + if (settings.mapRoot()) { + if (settings.sourceRoot()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Options_mapRoot_and_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } else { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_mapRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } + } else if (settings.sourceRoot()) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Option_sourceRoot_cannot_be_specified_without_specifying_sourcemap_option, null); + return; + } + } + + this._sourceMapRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.mapRoot())); + this._sourceRootDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(settings.sourceRoot())); + + if (settings.outFileOption() || settings.outDirOption() || settings.mapRoot() || settings.sourceRoot()) { + if (settings.outFileOption()) { + this._sharedOutputFile = TypeScript.switchToForwardSlashes(resolvePath(settings.outFileOption())); + } + + if (settings.outDirOption()) { + this._outputDirectory = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(resolvePath(settings.outDirOption()))); + } + + if (this._outputDirectory || this._sourceMapRootDirectory || this.sourceRootDirectory) { + this.determineCommonDirectoryPath(compiler); + } + } + } + EmitOptions.prototype.diagnostic = function () { + return this._diagnostic; + }; + + EmitOptions.prototype.commonDirectoryPath = function () { + return this._commonDirectoryPath; + }; + EmitOptions.prototype.sharedOutputFile = function () { + return this._sharedOutputFile; + }; + EmitOptions.prototype.sourceRootDirectory = function () { + return this._sourceRootDirectory; + }; + EmitOptions.prototype.sourceMapRootDirectory = function () { + return this._sourceMapRootDirectory; + }; + EmitOptions.prototype.outputDirectory = function () { + return this._outputDirectory; + }; + + EmitOptions.prototype.compilationSettings = function () { + return this._settings; + }; + + EmitOptions.prototype.determineCommonDirectoryPath = function (compiler) { + var commonComponents = []; + var commonComponentsLength = -1; + + var fileNames = compiler.fileNames(); + for (var i = 0, len = fileNames.length; i < len; i++) { + var fileName = fileNames[i]; + var document = compiler.getDocument(fileNames[i]); + var sourceUnit = document.sourceUnit(); + + if (!document.isDeclareFile()) { + var fileComponents = TypeScript.filePathComponents(fileName); + if (commonComponentsLength === -1) { + commonComponents = fileComponents; + commonComponentsLength = commonComponents.length; + } else { + var updatedPath = false; + for (var j = 0; j < commonComponentsLength && j < fileComponents.length; j++) { + if (commonComponents[j] !== fileComponents[j]) { + commonComponentsLength = j; + updatedPath = true; + + if (j === 0) { + if (this._outputDirectory || this._sourceRootDirectory || (this._sourceMapRootDirectory && (!this._sharedOutputFile || compiler._isDynamicModuleCompilation()))) { + this._diagnostic = new TypeScript.Diagnostic(null, null, 0, 0, TypeScript.DiagnosticCode.Cannot_find_the_common_subdirectory_path_for_the_input_files, null); + return; + } + + return; + } + + break; + } + } + + if (!updatedPath && fileComponents.length < commonComponentsLength) { + commonComponentsLength = fileComponents.length; + } + } + } + } + + this._commonDirectoryPath = commonComponents.slice(0, commonComponentsLength).join("/") + "/"; + }; + return EmitOptions; + })(); + TypeScript.EmitOptions = EmitOptions; + + var Indenter = (function () { + function Indenter() { + this.indentAmt = 0; + } + Indenter.prototype.increaseIndent = function () { + this.indentAmt += Indenter.indentStep; + }; + + Indenter.prototype.decreaseIndent = function () { + this.indentAmt -= Indenter.indentStep; + }; + + Indenter.prototype.getIndent = function () { + var indentString = Indenter.indentStrings[this.indentAmt]; + if (indentString === undefined) { + indentString = ""; + for (var i = 0; i < this.indentAmt; i = i + Indenter.indentStep) { + indentString += Indenter.indentStepString; + } + Indenter.indentStrings[this.indentAmt] = indentString; + } + return indentString; + }; + Indenter.indentStep = 4; + Indenter.indentStepString = " "; + Indenter.indentStrings = []; + return Indenter; + })(); + TypeScript.Indenter = Indenter; + + function lastParameterIsRest(parameterList) { + var parameters = parameterList.parameters; + return parameters.nonSeparatorCount() > 0 && parameters.nonSeparatorAt(parameters.nonSeparatorCount() - 1).dotDotDotToken !== null; + } + TypeScript.lastParameterIsRest = lastParameterIsRest; + + var Emitter = (function () { + function Emitter(emittingFileName, outfile, emitOptions, semanticInfoChain) { + this.emittingFileName = emittingFileName; + this.outfile = outfile; + this.emitOptions = emitOptions; + this.semanticInfoChain = semanticInfoChain; + this.globalThisCapturePrologueEmitted = false; + this.extendsPrologueEmitted = false; + this.thisClassNode = null; + this.inArrowFunction = false; + this.moduleName = ""; + this.emitState = new EmitState(); + this.indenter = new Indenter(); + this.sourceMapper = null; + this.captureThisStmtString = "var _this = this;"; + this.declStack = []; + this.exportAssignmentIdentifier = null; + this.inWithBlock = false; + this.document = null; + this.copyrightElement = null; + } + Emitter.prototype.pushDecl = function (decl) { + if (decl) { + this.declStack[this.declStack.length] = decl; + } + }; + + Emitter.prototype.popDecl = function (decl) { + if (decl) { + this.declStack.length--; + } + }; + + Emitter.prototype.getEnclosingDecl = function () { + var declStackLen = this.declStack.length; + var enclosingDecl = declStackLen > 0 ? this.declStack[declStackLen - 1] : null; + return enclosingDecl; + }; + + Emitter.prototype.setExportAssignmentIdentifier = function (id) { + this.exportAssignmentIdentifier = id; + }; + + Emitter.prototype.getExportAssignmentIdentifier = function () { + return this.exportAssignmentIdentifier; + }; + + Emitter.prototype.setDocument = function (document) { + this.document = document; + }; + + Emitter.prototype.shouldEmitImportDeclaration = function (importDeclAST) { + return TypeScript.importDeclarationIsElided(importDeclAST, this.semanticInfoChain, this.emitOptions.compilationSettings()); + }; + + Emitter.prototype.emitImportDeclaration = function (importDeclAST) { + var isExternalModuleReference = importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */; + var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST); + var isExported = TypeScript.hasFlag(importDecl.flags, 1 /* Exported */); + var isAmdCodeGen = this.emitOptions.compilationSettings().moduleGenTarget() == 2 /* Asynchronous */; + + this.emitComments(importDeclAST, true); + + var importSymbol = importDecl.getSymbol(); + + var parentSymbol = importSymbol.getContainer(); + var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */; + var associatedParentSymbol = parentSymbol ? parentSymbol.getAssociatedContainerType() : null; + var associatedParentSymbolKind = associatedParentSymbol ? associatedParentSymbol.kind : 0 /* None */; + + var needsPropertyAssignment = false; + var usePropertyAssignmentInsteadOfVarDecl = false; + var moduleNamePrefix; + + if (isExported && (parentKind == 4 /* Container */ || parentKind === 32 /* DynamicModule */ || associatedParentSymbolKind === 4 /* Container */ || associatedParentSymbolKind === 32 /* DynamicModule */)) { + if (importSymbol.getExportAssignedTypeSymbol() || importSymbol.getExportAssignedContainerSymbol()) { + needsPropertyAssignment = true; + } else { + var valueSymbol = importSymbol.getExportAssignedValueSymbol(); + if (valueSymbol && (valueSymbol.kind == 65536 /* Method */ || valueSymbol.kind == 16384 /* Function */)) { + needsPropertyAssignment = true; + } else { + usePropertyAssignmentInsteadOfVarDecl = true; + } + } + + if (this.emitState.container === 2 /* DynamicModule */) { + moduleNamePrefix = "exports."; + } else { + moduleNamePrefix = this.moduleName + "."; + } + } + + if (isAmdCodeGen && isExternalModuleReference) { + needsPropertyAssignment = true; + } else { + this.recordSourceMappingStart(importDeclAST); + if (usePropertyAssignmentInsteadOfVarDecl) { + this.writeToOutput(moduleNamePrefix); + } else { + this.writeToOutput("var "); + } + this.writeToOutput(importDeclAST.identifier.text() + " = "); + var aliasAST = importDeclAST.moduleReference; + + if (isExternalModuleReference) { + this.writeToOutput("require(" + aliasAST.stringLiteral.text() + ")"); + } else { + this.emitJavascript(aliasAST.moduleName, false); + } + + this.recordSourceMappingEnd(importDeclAST); + this.writeToOutput(";"); + + if (needsPropertyAssignment) { + this.writeLineToOutput(""); + this.emitIndent(); + } + } + + if (needsPropertyAssignment) { + this.writeToOutputWithSourceMapRecord(moduleNamePrefix + importDeclAST.identifier.text() + " = " + importDeclAST.identifier.text(), importDeclAST); + this.writeToOutput(";"); + } + this.emitComments(importDeclAST, false); + }; + + Emitter.prototype.createSourceMapper = function (document, jsFileName, jsFile, sourceMapOut, resolvePath) { + this.sourceMapper = new TypeScript.SourceMapper(jsFile, sourceMapOut, document, jsFileName, this.emitOptions, resolvePath); + }; + + Emitter.prototype.setSourceMapperNewSourceFile = function (document) { + this.sourceMapper.setNewSourceFile(document, this.emitOptions); + }; + + Emitter.prototype.updateLineAndColumn = function (s) { + var lineNumbers = TypeScript.TextUtilities.parseLineStarts(s); + if (lineNumbers.length > 1) { + this.emitState.line += lineNumbers.length - 1; + this.emitState.column = s.length - lineNumbers[lineNumbers.length - 1]; + } else { + this.emitState.column += s.length; + } + }; + + Emitter.prototype.writeToOutputWithSourceMapRecord = function (s, astSpan) { + this.recordSourceMappingStart(astSpan); + this.writeToOutput(s); + this.recordSourceMappingEnd(astSpan); + }; + + Emitter.prototype.writeToOutput = function (s) { + this.outfile.Write(s); + this.updateLineAndColumn(s); + }; + + Emitter.prototype.writeLineToOutput = function (s, force) { + if (typeof force === "undefined") { force = false; } + if (!force && s === "" && this.emitState.column === 0) { + return; + } + + this.outfile.WriteLine(s); + this.updateLineAndColumn(s); + this.emitState.column = 0; + this.emitState.line++; + }; + + Emitter.prototype.writeCaptureThisStatement = function (ast) { + this.emitIndent(); + this.writeToOutputWithSourceMapRecord(this.captureThisStmtString, ast); + this.writeLineToOutput(""); + }; + + Emitter.prototype.setContainer = function (c) { + var temp = this.emitState.container; + this.emitState.container = c; + return temp; + }; + + Emitter.prototype.getIndentString = function () { + return this.indenter.getIndent(); + }; + + Emitter.prototype.emitIndent = function () { + this.writeToOutput(this.getIndentString()); + }; + + Emitter.prototype.emitComment = function (comment, trailing, first) { + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var text = getTrimmedTextLines(comment); + var emitColumn = this.emitState.column; + + if (emitColumn === 0) { + this.emitIndent(); + } else if (trailing && first) { + this.writeToOutput(" "); + } + + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + this.recordSourceMappingStart(comment); + this.writeToOutput(text[0]); + + if (text.length > 1 || comment.endsLine) { + for (var i = 1; i < text.length; i++) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput(text[i]); + } + this.recordSourceMappingEnd(comment); + this.writeLineToOutput(""); + } else { + this.recordSourceMappingEnd(comment); + this.writeToOutput(" "); + return; + } + } else { + this.recordSourceMappingStart(comment); + this.writeToOutput(text[0]); + this.recordSourceMappingEnd(comment); + this.writeLineToOutput(""); + } + + if (!trailing && emitColumn != 0) { + this.emitIndent(); + } + }; + + Emitter.prototype.emitComments = function (ast, pre, onlyPinnedOrTripleSlashComments) { + if (typeof onlyPinnedOrTripleSlashComments === "undefined") { onlyPinnedOrTripleSlashComments = false; } + var _this = this; + if (ast && ast.kind() !== 146 /* Block */) { + if (ast.parent.kind() === 219 /* SimpleArrowFunctionExpression */ || ast.parent.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + return; + } + } + + if (pre) { + var preComments = ast.preComments(); + + if (preComments && ast === this.copyrightElement) { + var copyrightComments = this.getCopyrightComments(); + preComments = preComments.slice(copyrightComments.length); + } + + if (onlyPinnedOrTripleSlashComments) { + preComments = TypeScript.ArrayUtilities.where(preComments, function (c) { + return _this.isPinnedOrTripleSlash(c); + }); + } + + this.emitCommentsArray(preComments, false); + } else { + this.emitCommentsArray(ast.postComments(), true); + } + }; + + Emitter.prototype.isPinnedOrTripleSlash = function (comment) { + var fullText = comment.fullText(); + if (fullText.match(TypeScript.tripleSlashReferenceRegExp)) { + return true; + } else { + return fullText.indexOf("/*!") === 0; + } + }; + + Emitter.prototype.emitCommentsArray = function (comments, trailing) { + if (!this.emitOptions.compilationSettings().removeComments() && comments) { + for (var i = 0, n = comments.length; i < n; i++) { + this.emitComment(comments[i], trailing, i === 0); + } + } + }; + + Emitter.prototype.emitObjectLiteralExpression = function (objectLiteral) { + this.recordSourceMappingStart(objectLiteral); + + this.writeToOutput("{"); + this.emitCommaSeparatedList(objectLiteral, objectLiteral.propertyAssignments, " ", true); + this.writeToOutput("}"); + + this.recordSourceMappingEnd(objectLiteral); + }; + + Emitter.prototype.emitArrayLiteralExpression = function (arrayLiteral) { + this.recordSourceMappingStart(arrayLiteral); + + this.writeToOutput("["); + this.emitCommaSeparatedList(arrayLiteral, arrayLiteral.expressions, "", true); + this.writeToOutput("]"); + + this.recordSourceMappingEnd(arrayLiteral); + }; + + Emitter.prototype.emitObjectCreationExpression = function (objectCreationExpression) { + this.recordSourceMappingStart(objectCreationExpression); + this.writeToOutput("new "); + var target = objectCreationExpression.expression; + + this.emit(target); + if (objectCreationExpression.argumentList) { + this.recordSourceMappingStart(objectCreationExpression.argumentList); + this.writeToOutput("("); + this.emitCommaSeparatedList(objectCreationExpression.argumentList, objectCreationExpression.argumentList.arguments, "", false); + this.writeToOutputWithSourceMapRecord(")", objectCreationExpression.argumentList.closeParenToken); + this.recordSourceMappingEnd(objectCreationExpression.argumentList); + } + + this.recordSourceMappingEnd(objectCreationExpression); + }; + + Emitter.prototype.getConstantDecl = function (dotExpr) { + var pullSymbol = this.semanticInfoChain.getSymbolForAST(dotExpr); + if (pullSymbol && pullSymbol.kind === 67108864 /* EnumMember */) { + var pullDecls = pullSymbol.getDeclarations(); + if (pullDecls.length === 1) { + var pullDecl = pullDecls[0]; + if (pullDecl.kind === 67108864 /* EnumMember */) { + return pullDecl; + } + } + } + + return null; + }; + + Emitter.prototype.tryEmitConstant = function (dotExpr) { + var propertyName = dotExpr.name; + var boundDecl = this.getConstantDecl(dotExpr); + if (boundDecl) { + var value = boundDecl.constantValue; + if (value !== null) { + this.recordSourceMappingStart(dotExpr); + this.writeToOutput(value.toString()); + var comment = " /* "; + comment += propertyName.text(); + comment += " */"; + this.writeToOutput(comment); + this.recordSourceMappingEnd(dotExpr); + return true; + } + } + + return false; + }; + + Emitter.prototype.emitInvocationExpression = function (callNode) { + this.recordSourceMappingStart(callNode); + var target = callNode.expression; + var args = callNode.argumentList.arguments; + + if (target.kind() === 212 /* MemberAccessExpression */ && target.expression.kind() === 50 /* SuperKeyword */) { + this.emit(target); + this.writeToOutput(".call"); + this.recordSourceMappingStart(args); + this.writeToOutput("("); + this.emitThis(); + if (args && args.nonSeparatorCount() > 0) { + this.writeToOutput(", "); + this.emitCommaSeparatedList(callNode.argumentList, args, "", false); + } + } else { + if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) { + this.writeToOutput("_super.call"); + } else { + this.emitJavascript(target, false); + } + this.recordSourceMappingStart(args); + this.writeToOutput("("); + if (callNode.expression.kind() === 50 /* SuperKeyword */ && this.emitState.container === 4 /* Constructor */) { + this.writeToOutput("this"); + if (args && args.nonSeparatorCount() > 0) { + this.writeToOutput(", "); + } + } + this.emitCommaSeparatedList(callNode.argumentList, args, "", false); + } + + this.writeToOutputWithSourceMapRecord(")", callNode.argumentList.closeParenToken); + this.recordSourceMappingEnd(args); + this.recordSourceMappingEnd(callNode); + }; + + Emitter.prototype.emitParameterList = function (list) { + this.writeToOutput("("); + this.emitCommentsArray(list.openParenTrailingComments, true); + this.emitFunctionParameters(TypeScript.Parameters.fromParameterList(list)); + this.writeToOutput(")"); + }; + + Emitter.prototype.emitFunctionParameters = function (parameters) { + var argsLen = 0; + + if (parameters) { + this.emitComments(parameters.ast, true); + + var tempContainer = this.setContainer(6 /* Args */); + argsLen = parameters.length; + var printLen = argsLen; + if (parameters.lastParameterIsRest()) { + printLen--; + } + for (var i = 0; i < printLen; i++) { + var arg = parameters.astAt(i); + this.emit(arg); + + if (i < (printLen - 1)) { + this.writeToOutput(", "); + } + } + this.setContainer(tempContainer); + + this.emitComments(parameters.ast, false); + } + }; + + Emitter.prototype.emitFunctionBodyStatements = function (name, funcDecl, parameterList, block, bodyExpression) { + this.writeLineToOutput(" {"); + if (name) { + this.recordSourceMappingNameStart(name); + } + + this.indenter.increaseIndent(); + + if (parameterList) { + this.emitDefaultValueAssignments(parameterList); + this.emitRestParameterInitializer(parameterList); + } + + if (this.shouldCaptureThis(funcDecl)) { + this.writeCaptureThisStatement(funcDecl); + } + + if (block) { + this.emitList(block.statements); + this.emitCommentsArray(block.closeBraceLeadingComments, false); + } else { + this.emitIndent(); + this.emitCommentsArray(bodyExpression.preComments(), false); + this.writeToOutput("return "); + this.emit(bodyExpression); + this.writeLineToOutput(";"); + this.emitCommentsArray(bodyExpression.postComments(), true); + } + + this.indenter.decreaseIndent(); + this.emitIndent(); + + if (block) { + this.writeToOutputWithSourceMapRecord("}", block.closeBraceToken); + } else { + this.writeToOutputWithSourceMapRecord("}", bodyExpression); + } + + if (name) { + this.recordSourceMappingNameEnd(); + } + }; + + Emitter.prototype.emitDefaultValueAssignments = function (parameters) { + var n = parameters.length; + if (parameters.lastParameterIsRest()) { + n--; + } + + for (var i = 0; i < n; i++) { + var arg = parameters.astAt(i); + var id = parameters.identifierAt(i); + var equalsValueClause = parameters.initializerAt(i); + if (equalsValueClause) { + this.emitIndent(); + this.recordSourceMappingStart(arg); + this.writeToOutput("if (typeof " + id.text() + " === \"undefined\") { "); + this.writeToOutputWithSourceMapRecord(id.text(), id); + this.emitJavascript(equalsValueClause, false); + this.writeLineToOutput("; }"); + this.recordSourceMappingEnd(arg); + } + } + }; + + Emitter.prototype.emitRestParameterInitializer = function (parameters) { + if (parameters.lastParameterIsRest()) { + var n = parameters.length; + var lastArg = parameters.astAt(n - 1); + var id = parameters.identifierAt(n - 1); + this.emitIndent(); + this.recordSourceMappingStart(lastArg); + this.writeToOutput("var "); + this.writeToOutputWithSourceMapRecord(id.text(), id); + this.writeLineToOutput(" = [];"); + this.recordSourceMappingEnd(lastArg); + this.emitIndent(); + this.writeToOutput("for ("); + this.writeToOutputWithSourceMapRecord("var _i = 0;", lastArg); + this.writeToOutput(" "); + this.writeToOutputWithSourceMapRecord("_i < (arguments.length - " + (n - 1) + ")", lastArg); + this.writeToOutput("; "); + this.writeToOutputWithSourceMapRecord("_i++", lastArg); + this.writeLineToOutput(") {"); + this.indenter.increaseIndent(); + this.emitIndent(); + + this.writeToOutputWithSourceMapRecord(id.text() + "[_i] = arguments[_i + " + (n - 1) + "];", lastArg); + this.writeLineToOutput(""); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("}"); + } + }; + + Emitter.prototype.getImportDecls = function (fileName) { + var topLevelDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName); + var result = []; + + var dynamicModuleDecl = topLevelDecl.getChildDecls()[0]; + var queue = dynamicModuleDecl.getChildDecls(); + + for (var i = 0, n = queue.length; i < n; i++) { + var decl = queue[i]; + + if (decl.kind & 128 /* TypeAlias */) { + var importStatementAST = this.semanticInfoChain.getASTForDecl(decl); + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var symbol = decl.getSymbol(); + var typeSymbol = symbol && symbol.type; + if (typeSymbol && typeSymbol !== this.semanticInfoChain.anyTypeSymbol && !typeSymbol.isError()) { + result.push(decl); + } + } + } + } + + return result; + }; + + Emitter.prototype.getModuleImportAndDependencyList = function (sourceUnit) { + var importList = ""; + var dependencyList = ""; + + var importDecls = this.getImportDecls(this.document.fileName); + + if (importDecls.length) { + for (var i = 0; i < importDecls.length; i++) { + var importStatementDecl = importDecls[i]; + var importStatementSymbol = importStatementDecl.getSymbol(); + var importStatementAST = this.semanticInfoChain.getASTForDecl(importStatementDecl); + + if (importStatementSymbol.isUsedAsValue()) { + if (i <= importDecls.length - 1) { + dependencyList += ", "; + importList += ", "; + } + + importList += importStatementDecl.name; + dependencyList += importStatementAST.moduleReference.stringLiteral.text(); + } + } + } + + var amdDependencies = this.document.amdDependencies(); + for (var i = 0; i < amdDependencies.length; i++) { + dependencyList += ", \"" + amdDependencies[i] + "\""; + } + + return { + importList: importList, + dependencyList: dependencyList + }; + }; + + Emitter.prototype.shouldCaptureThis = function (ast) { + if (ast.kind() === 120 /* SourceUnit */) { + var scriptDecl = this.semanticInfoChain.topLevelDecl(this.document.fileName); + return TypeScript.hasFlag(scriptDecl.flags, 262144 /* MustCaptureThis */); + } + + var decl = this.semanticInfoChain.getDeclForAST(ast); + if (decl) { + return TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */); + } + + return false; + }; + + Emitter.prototype.emitEnum = function (moduleDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.pushDecl(pullDecl); + + var svModuleName = this.moduleName; + this.moduleName = moduleDecl.identifier.text(); + + var temp = this.setContainer(1 /* Module */); + var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */); + + if (!isExported) { + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("var "); + this.recordSourceMappingStart(moduleDecl.identifier); + this.writeToOutput(this.moduleName); + this.recordSourceMappingEnd(moduleDecl.identifier); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(moduleDecl); + this.emitIndent(); + } + + this.writeToOutput("("); + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("function ("); + this.writeToOutputWithSourceMapRecord(this.moduleName, moduleDecl.identifier); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart(this.moduleName); + + this.indenter.increaseIndent(); + + if (this.shouldCaptureThis(moduleDecl)) { + this.writeCaptureThisStatement(moduleDecl); + } + + this.emitSeparatedList(moduleDecl.enumElements); + this.indenter.decreaseIndent(); + this.emitIndent(); + + var parentIsDynamic = temp === 2 /* DynamicModule */; + if (temp === 0 /* Prog */ && isExported) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));"); + } else if (isExported || temp === 0 /* Prog */) { + var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName; + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));"); + } else if (!isExported && temp !== 0 /* Prog */) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));"); + } else { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.writeToOutput(")();"); + } + + this.recordSourceMappingEnd(moduleDecl); + if (temp !== 0 /* Prog */ && isExported) { + this.recordSourceMappingStart(moduleDecl); + if (parentIsDynamic) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";"); + } else { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";"); + } + this.recordSourceMappingEnd(moduleDecl); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + + this.popDecl(pullDecl); + }; + + Emitter.prototype.getModuleDeclToVerifyChildNameCollision = function (moduleDecl, changeNameIfAnyDeclarationInContext) { + if (TypeScript.ArrayUtilities.contains(this.declStack, moduleDecl)) { + return moduleDecl; + } else if (changeNameIfAnyDeclarationInContext) { + var symbol = moduleDecl.getSymbol(); + if (symbol) { + var otherDecls = symbol.getDeclarations(); + for (var i = 0; i < otherDecls.length; i++) { + if (TypeScript.ArrayUtilities.contains(this.declStack, otherDecls[i])) { + return otherDecls[i]; + } + } + } + } + + return null; + }; + + Emitter.prototype.hasChildNameCollision = function (moduleName, childDecls) { + var _this = this; + return TypeScript.ArrayUtilities.any(childDecls, function (childDecl) { + if (childDecl.name == moduleName) { + var childAST = _this.semanticInfoChain.getASTForDecl(childDecl); + if (_this.shouldEmit(childAST)) { + return true; + } + } + return false; + }); + }; + + Emitter.prototype.getModuleName = function (moduleDecl, changeNameIfAnyDeclarationInContext) { + var moduleName = moduleDecl.name; + var moduleDisplayName = moduleDecl.getDisplayName(); + + moduleDecl = this.getModuleDeclToVerifyChildNameCollision(moduleDecl, changeNameIfAnyDeclarationInContext); + if (moduleDecl) { + var childDecls = moduleDecl.getChildDecls(); + + while (this.hasChildNameCollision(moduleName, childDecls)) { + moduleName = "_" + moduleName; + moduleDisplayName = "_" + moduleDisplayName; + } + } + + return moduleDisplayName; + }; + + Emitter.prototype.emitModuleDeclarationWorker = function (moduleDecl) { + if (moduleDecl.stringLiteral) { + this.emitSingleModuleDeclaration(moduleDecl, moduleDecl.stringLiteral); + } else { + var moduleNames = TypeScript.getModuleNames(moduleDecl.name); + this.emitSingleModuleDeclaration(moduleDecl, moduleNames[0]); + } + }; + + Emitter.prototype.emitSingleModuleDeclaration = function (moduleDecl, moduleName) { + var isLastName = TypeScript.isLastNameOfModule(moduleDecl, moduleName); + + if (isLastName) { + this.emitComments(moduleDecl, true); + } + + var pullDecl = this.semanticInfoChain.getDeclForAST(moduleName); + this.pushDecl(pullDecl); + + var svModuleName = this.moduleName; + + if (moduleDecl.stringLiteral) { + this.moduleName = moduleDecl.stringLiteral.valueText(); + if (TypeScript.isTSFile(this.moduleName)) { + this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length); + } + } else { + this.moduleName = moduleName.text(); + } + + var temp = this.setContainer(1 /* Module */); + var isExported = TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */); + + if (!isExported) { + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("var "); + this.recordSourceMappingStart(moduleName); + this.writeToOutput(this.moduleName); + this.recordSourceMappingEnd(moduleName); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(moduleDecl); + this.emitIndent(); + } + + this.writeToOutput("("); + this.recordSourceMappingStart(moduleDecl); + this.writeToOutput("function ("); + + this.moduleName = this.getModuleName(pullDecl); + this.writeToOutputWithSourceMapRecord(this.moduleName, moduleName); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart(moduleName.text()); + + this.indenter.increaseIndent(); + + if (this.shouldCaptureThis(moduleDecl)) { + this.writeCaptureThisStatement(moduleDecl); + } + + if (moduleName === moduleDecl.stringLiteral) { + this.emitList(moduleDecl.moduleElements); + } else { + var moduleNames = TypeScript.getModuleNames(moduleDecl.name); + var nameIndex = moduleNames.indexOf(moduleName); + TypeScript.Debug.assert(nameIndex >= 0); + + if (isLastName) { + this.emitList(moduleDecl.moduleElements); + } else { + this.emitIndent(); + this.emitSingleModuleDeclaration(moduleDecl, moduleNames[nameIndex + 1]); + this.writeLineToOutput(""); + } + } + + this.moduleName = moduleName.text(); + this.indenter.decreaseIndent(); + this.emitIndent(); + + var parentIsDynamic = temp === 2 /* DynamicModule */; + this.recordSourceMappingStart(moduleDecl.endingToken); + if (temp === 0 /* Prog */ && isExported) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(this." + this.moduleName + " || (this." + this.moduleName + " = {}));"); + } else if (isExported || temp === 0 /* Prog */) { + var dotMod = svModuleName !== "" ? (parentIsDynamic ? "exports" : svModuleName) + "." : svModuleName; + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(" + dotMod + this.moduleName + " || (" + dotMod + this.moduleName + " = {}));"); + } else if (!isExported && temp !== 0 /* Prog */) { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")(" + this.moduleName + " || (" + this.moduleName + " = {}));"); + } else { + this.writeToOutput("}"); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(moduleDecl.endingToken); + this.writeToOutput(")();"); + } + + this.recordSourceMappingEnd(moduleDecl); + if (temp !== 0 /* Prog */ && isExported) { + this.recordSourceMappingStart(moduleDecl); + if (parentIsDynamic) { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = exports." + this.moduleName + ";"); + } else { + this.writeLineToOutput(""); + this.emitIndent(); + this.writeToOutput("var " + this.moduleName + " = " + svModuleName + "." + this.moduleName + ";"); + } + this.recordSourceMappingEnd(moduleDecl); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + + this.popDecl(pullDecl); + + if (isLastName) { + this.emitComments(moduleDecl, false); + } + }; + + Emitter.prototype.emitEnumElement = function (varDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + TypeScript.Debug.assert(pullDecl && pullDecl.kind === 67108864 /* EnumMember */); + + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + var name = varDecl.propertyName.text(); + var quoted = TypeScript.isQuoted(name); + this.writeToOutput(this.moduleName); + this.writeToOutput('['); + this.writeToOutput(this.moduleName); + this.writeToOutput('['); + this.writeToOutput(quoted ? name : '"' + name + '"'); + this.writeToOutput(']'); + + if (varDecl.equalsValueClause) { + this.emit(varDecl.equalsValueClause); + } else if (pullDecl.constantValue !== null) { + this.writeToOutput(' = '); + this.writeToOutput(pullDecl.constantValue.toString()); + } else { + this.writeToOutput(' = null'); + } + + this.writeToOutput('] = '); + this.writeToOutput(quoted ? name : '"' + name + '"'); + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + this.writeToOutput(';'); + }; + + Emitter.prototype.emitElementAccessExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.emit(expression.expression); + this.writeToOutput("["); + this.emit(expression.argumentExpression); + this.writeToOutput("]"); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitSimpleArrowFunctionExpression = function (arrowFunction) { + this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.Parameters.fromIdentifier(arrowFunction.identifier), arrowFunction.block, arrowFunction.expression); + }; + + Emitter.prototype.emitParenthesizedArrowFunctionExpression = function (arrowFunction) { + this.emitAnyArrowFunctionExpression(arrowFunction, null, TypeScript.Parameters.fromParameterList(arrowFunction.callSignature.parameterList), arrowFunction.block, arrowFunction.expression); + }; + + Emitter.prototype.emitAnyArrowFunctionExpression = function (arrowFunction, funcName, parameters, block, expression) { + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = true; + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(arrowFunction); + + var pullDecl = this.semanticInfoChain.getDeclForAST(arrowFunction); + this.pushDecl(pullDecl); + + this.emitComments(arrowFunction, true); + + this.recordSourceMappingStart(arrowFunction); + this.writeToOutput("function "); + this.writeToOutput("("); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcName, arrowFunction, parameters, block, expression); + + this.recordSourceMappingEnd(arrowFunction); + + this.recordSourceMappingEnd(arrowFunction); + + this.emitComments(arrowFunction, false); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + }; + + Emitter.prototype.emitConstructor = function (funcDecl) { + if (!funcDecl.block) { + return; + } + var temp = this.setContainer(4 /* Constructor */); + + this.recordSourceMappingStart(funcDecl); + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.emitComments(funcDecl, true); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + this.writeToOutput(this.thisClassNode.identifier.text()); + this.writeToOutput("("); + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.parameterList); + this.emitFunctionParameters(parameters); + this.writeLineToOutput(") {"); + + this.recordSourceMappingNameStart("constructor"); + this.indenter.increaseIndent(); + + this.emitDefaultValueAssignments(parameters); + this.emitRestParameterInitializer(parameters); + + if (this.shouldCaptureThis(funcDecl)) { + this.writeCaptureThisStatement(funcDecl); + } + + this.emitConstructorStatements(funcDecl); + this.emitCommentsArray(funcDecl.block.closeBraceLeadingComments, false); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("}", funcDecl.block.closeBraceToken); + + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + this.setContainer(temp); + }; + + Emitter.prototype.emitGetAccessor = function (accessor) { + this.recordSourceMappingStart(accessor); + this.writeToOutput("get "); + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(accessor); + + var pullDecl = this.semanticInfoChain.getDeclForAST(accessor); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(accessor); + + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain); + var container = accessorSymbol.getContainer(); + var containerKind = container.kind; + + this.recordSourceMappingNameStart(accessor.propertyName.text()); + this.writeToOutput(accessor.propertyName.text()); + this.writeToOutput("("); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, accessor, TypeScript.Parameters.fromParameterList(accessor.parameterList), accessor.block, null); + + this.recordSourceMappingEnd(accessor); + + this.recordSourceMappingEnd(accessor); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.recordSourceMappingEnd(accessor); + }; + + Emitter.prototype.emitSetAccessor = function (accessor) { + this.recordSourceMappingStart(accessor); + this.writeToOutput("set "); + + var temp = this.setContainer(5 /* Function */); + + this.recordSourceMappingStart(accessor); + + var pullDecl = this.semanticInfoChain.getDeclForAST(accessor); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(accessor); + + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(accessor, this.semanticInfoChain); + var container = accessorSymbol.getContainer(); + var containerKind = container.kind; + + this.recordSourceMappingNameStart(accessor.propertyName.text()); + this.writeToOutput(accessor.propertyName.text()); + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(accessor.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, accessor, parameters, accessor.block, null); + + this.recordSourceMappingEnd(accessor); + + this.recordSourceMappingEnd(accessor); + + this.popDecl(pullDecl); + this.setContainer(temp); + this.recordSourceMappingEnd(accessor); + }; + + Emitter.prototype.emitFunctionExpression = function (funcDecl) { + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + + var funcName = funcDecl.identifier ? funcDecl.identifier.text() : null; + + this.recordSourceMappingStart(funcDecl); + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + if (funcDecl.identifier) { + this.recordSourceMappingStart(funcDecl.identifier); + this.writeToOutput(funcDecl.identifier.text()); + this.recordSourceMappingEnd(funcDecl.identifier); + } + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcName, funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + }; + + Emitter.prototype.emitFunction = function (funcDecl) { + if (funcDecl.block === null) { + return; + } + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + + var funcName = funcDecl.identifier.text(); + + this.recordSourceMappingStart(funcDecl); + + var printName = funcDecl.identifier !== null; + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.emitComments(funcDecl, true); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + if (printName) { + var id = funcDecl.identifier.text(); + if (id) { + if (funcDecl.identifier) { + this.recordSourceMappingStart(funcDecl.identifier); + } + this.writeToOutput(id); + if (funcDecl.identifier) { + this.recordSourceMappingEnd(funcDecl.identifier); + } + } + } + + this.emitParameterList(funcDecl.callSignature.parameterList); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionBodyStatements(funcDecl.identifier.text(), funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + + if (funcDecl.block) { + var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + if ((this.emitState.container === 1 /* Module */ || this.emitState.container === 2 /* DynamicModule */) && pullFunctionDecl && TypeScript.hasFlag(pullFunctionDecl.flags, 1 /* Exported */)) { + this.writeLineToOutput(""); + this.emitIndent(); + var modName = this.emitState.container === 1 /* Module */ ? this.moduleName : "exports"; + this.recordSourceMappingStart(funcDecl); + this.writeToOutput(modName + "." + funcName + " = " + funcName + ";"); + this.recordSourceMappingEnd(funcDecl); + } + } + }; + + Emitter.prototype.emitAmbientVarDecl = function (varDecl) { + this.recordSourceMappingStart(this.currentVariableDeclaration); + if (varDecl.equalsValueClause) { + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName); + this.emitJavascript(varDecl.equalsValueClause, false); + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + } + }; + + Emitter.prototype.emitVarDeclVar = function () { + if (this.currentVariableDeclaration) { + this.writeToOutput("var "); + } + }; + + Emitter.prototype.emitVariableDeclaration = function (declaration) { + var varDecl = declaration.declarators.nonSeparatorAt(0); + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentKind = parentSymbol ? parentSymbol.kind : 0 /* None */; + + this.emitComments(declaration, true); + + var pullVarDecl = this.semanticInfoChain.getDeclForAST(varDecl); + var isAmbientWithoutInit = pullVarDecl && TypeScript.hasFlag(pullVarDecl.flags, 8 /* Ambient */) && varDecl.equalsValueClause === null; + if (!isAmbientWithoutInit) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.currentVariableDeclaration = declaration; + + for (var i = 0, n = declaration.declarators.nonSeparatorCount(); i < n; i++) { + var declarator = declaration.declarators.nonSeparatorAt(i); + + if (i > 0) { + this.writeToOutput(", "); + } + + this.emit(declarator); + } + this.currentVariableDeclaration = prevVariableDeclaration; + + this.recordSourceMappingEnd(declaration); + } + + this.emitComments(declaration, false); + }; + + Emitter.prototype.emitMemberVariableDeclaration = function (varDecl) { + TypeScript.Debug.assert(!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause); + + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + this.pushDecl(pullDecl); + + this.emitComments(varDecl, true); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.variableDeclarator.propertyName.text(); + var quotedOrNumber = TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */; + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentDecl = pullDecl && pullDecl.getParentDecl(); + + if (quotedOrNumber) { + this.writeToOutput("this["); + } else { + this.writeToOutput("this."); + } + + this.writeToOutputWithSourceMapRecord(varDecl.variableDeclarator.propertyName.text(), varDecl.variableDeclarator.propertyName); + + if (quotedOrNumber) { + this.writeToOutput("]"); + } + + if (varDecl.variableDeclarator.equalsValueClause) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.emit(varDecl.variableDeclarator.equalsValueClause); + this.currentVariableDeclaration = prevVariableDeclaration; + } + + if (this.emitState.container !== 6 /* Args */) { + this.writeToOutput(";"); + } + + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitVariableDeclarator = function (varDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(varDecl); + this.pushDecl(pullDecl); + if (pullDecl && (pullDecl.flags & 8 /* Ambient */) === 8 /* Ambient */) { + this.emitAmbientVarDecl(varDecl); + } else { + this.emitComments(varDecl, true); + this.recordSourceMappingStart(this.currentVariableDeclaration); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.propertyName.text(); + + var symbol = this.semanticInfoChain.getSymbolForAST(varDecl); + var parentSymbol = symbol ? symbol.getContainer() : null; + var parentDecl = pullDecl && pullDecl.getParentDecl(); + var parentIsModule = parentDecl && (parentDecl.flags & 102400 /* SomeInitializedModule */); + + if (parentIsModule) { + if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + this.emitVarDeclVar(); + } else { + if (this.emitState.container === 2 /* DynamicModule */) { + this.writeToOutput("exports."); + } else { + this.writeToOutput(this.moduleName + "."); + } + } + } else { + this.emitVarDeclVar(); + } + + this.writeToOutputWithSourceMapRecord(varDecl.propertyName.text(), varDecl.propertyName); + + if (varDecl.equalsValueClause) { + var prevVariableDeclaration = this.currentVariableDeclaration; + this.emit(varDecl.equalsValueClause); + this.currentVariableDeclaration = prevVariableDeclaration; + } + + this.recordSourceMappingEnd(varDecl); + this.emitComments(varDecl, false); + } + this.currentVariableDeclaration = undefined; + this.popDecl(pullDecl); + }; + + Emitter.prototype.symbolIsUsedInItsEnclosingContainer = function (symbol, dynamic) { + if (typeof dynamic === "undefined") { dynamic = false; } + var symDecls = symbol.getDeclarations(); + + if (symDecls.length) { + var enclosingDecl = this.getEnclosingDecl(); + if (enclosingDecl) { + var parentDecl = symDecls[0].getParentDecl(); + if (parentDecl) { + var symbolDeclarationEnclosingContainer = parentDecl; + var enclosingContainer = enclosingDecl; + + while (symbolDeclarationEnclosingContainer) { + if (symbolDeclarationEnclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) { + break; + } + symbolDeclarationEnclosingContainer = symbolDeclarationEnclosingContainer.getParentDecl(); + } + + if (symbolDeclarationEnclosingContainer) { + while (enclosingContainer) { + if (enclosingContainer.kind === (dynamic ? 32 /* DynamicModule */ : 4 /* Container */)) { + break; + } + + enclosingContainer = enclosingContainer.getParentDecl(); + } + } + + if (symbolDeclarationEnclosingContainer && enclosingContainer) { + var same = symbolDeclarationEnclosingContainer === enclosingContainer; + + if (!same && symbol.anyDeclHasFlag(32768 /* InitializedModule */)) { + same = symbolDeclarationEnclosingContainer === enclosingContainer.getParentDecl(); + } + + return same; + } + } + } + } + + return false; + }; + + Emitter.prototype.getPotentialDeclPathInfoForEmit = function (pullSymbol) { + var decl = pullSymbol.getDeclarations()[0]; + var parentDecl = decl.getParentDecl(); + var symbolContainerDeclPath = parentDecl ? parentDecl.getParentPath() : []; + + var enclosingContextDeclPath = this.declStack; + var commonNodeIndex = -1; + + if (enclosingContextDeclPath.length) { + for (var i = symbolContainerDeclPath.length - 1; i >= 0; i--) { + var symbolContainerDeclPathNode = symbolContainerDeclPath[i]; + for (var j = enclosingContextDeclPath.length - 1; j >= 0; j--) { + var enclosingContextDeclPathNode = enclosingContextDeclPath[j]; + if (symbolContainerDeclPathNode === enclosingContextDeclPathNode) { + commonNodeIndex = i; + break; + } + } + + if (commonNodeIndex >= 0) { + break; + } + } + } + + var startingIndex = symbolContainerDeclPath.length - 1; + for (var i = startingIndex - 1; i > commonNodeIndex; i--) { + if (symbolContainerDeclPath[i + 1].flags & 1 /* Exported */) { + startingIndex = i; + } else { + break; + } + } + return { potentialPath: symbolContainerDeclPath, startingIndex: startingIndex }; + }; + + Emitter.prototype.emitDottedNameFromDeclPath = function (declPath, startingIndex, lastIndex) { + for (var i = startingIndex; i <= lastIndex; i++) { + if (declPath[i].kind === 32 /* DynamicModule */ || declPath[i].flags & 65536 /* InitializedDynamicModule */) { + this.writeToOutput("exports."); + } else { + this.writeToOutput(this.getModuleName(declPath[i], true) + "."); + } + } + }; + + Emitter.prototype.emitSymbolContainerNameInEnclosingContext = function (pullSymbol) { + var declPathInfo = this.getPotentialDeclPathInfoForEmit(pullSymbol); + var potentialDeclPath = declPathInfo.potentialPath; + var startingIndex = declPathInfo.startingIndex; + + this.emitDottedNameFromDeclPath(potentialDeclPath, startingIndex, potentialDeclPath.length - 1); + }; + + Emitter.prototype.getSymbolForEmit = function (ast) { + var pullSymbol = this.semanticInfoChain.getSymbolForAST(ast); + var pullSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(ast); + if (pullSymbol && pullSymbolAlias) { + var symbolToCompare = TypeScript.isTypesOnlyLocation(ast) ? pullSymbolAlias.getExportAssignedTypeSymbol() : pullSymbolAlias.getExportAssignedValueSymbol(); + + if (pullSymbol == symbolToCompare) { + pullSymbol = pullSymbolAlias; + pullSymbolAlias = null; + } + } + return { symbol: pullSymbol, aliasSymbol: pullSymbolAlias }; + }; + + Emitter.prototype.emitName = function (name, addThis) { + this.emitComments(name, true); + this.recordSourceMappingStart(name); + if (name.text().length > 0) { + var symbolForEmit = this.getSymbolForEmit(name); + var pullSymbol = symbolForEmit.symbol; + if (!pullSymbol) { + pullSymbol = this.semanticInfoChain.anyTypeSymbol; + } + var pullSymbolAlias = symbolForEmit.aliasSymbol; + var pullSymbolKind = pullSymbol.kind; + var isLocalAlias = pullSymbolAlias && (pullSymbolAlias.getDeclarations()[0].getParentDecl() == this.getEnclosingDecl()); + if (addThis && (this.emitState.container !== 6 /* Args */) && pullSymbol) { + var pullSymbolContainer = pullSymbol.getContainer(); + + if (pullSymbolContainer) { + var pullSymbolContainerKind = pullSymbolContainer.kind; + + if (pullSymbolContainerKind === 8 /* Class */) { + if (pullSymbol.anyDeclHasFlag(16 /* Static */)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbolKind === 4096 /* Property */) { + this.emitThis(); + this.writeToOutput("."); + } + } else if (TypeScript.PullHelpers.symbolIsModule(pullSymbolContainer) || pullSymbolContainerKind === 64 /* Enum */ || pullSymbolContainer.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) { + if (pullSymbolKind === 4096 /* Property */ || pullSymbolKind === 67108864 /* EnumMember */) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && pullSymbolKind === 512 /* Variable */ && !pullSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(pullSymbol)) { + this.emitSymbolContainerNameInEnclosingContext(pullSymbol); + } + } else if (pullSymbolContainerKind === 32 /* DynamicModule */ || pullSymbolContainer.anyDeclHasFlag(65536 /* InitializedDynamicModule */)) { + if (pullSymbolKind === 4096 /* Property */) { + this.writeToOutput("exports."); + } else if (pullSymbol.anyDeclHasFlag(1 /* Exported */) && !isLocalAlias && !pullSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */) && pullSymbol.kind !== 32768 /* ConstructorMethod */ && pullSymbol.kind !== 8 /* Class */ && pullSymbol.kind !== 64 /* Enum */) { + this.writeToOutput("exports."); + } + } + } + } + + this.writeToOutput(name.text()); + } + + this.recordSourceMappingEnd(name); + this.emitComments(name, false); + }; + + Emitter.prototype.recordSourceMappingNameStart = function (name) { + if (this.sourceMapper) { + var nameIndex = -1; + if (name) { + if (this.sourceMapper.currentNameIndex.length > 0) { + var parentNameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1]; + if (parentNameIndex != -1) { + name = this.sourceMapper.names[parentNameIndex] + "." + name; + } + } + + var nameIndex = this.sourceMapper.names.length - 1; + for (nameIndex; nameIndex >= 0; nameIndex--) { + if (this.sourceMapper.names[nameIndex] == name) { + break; + } + } + + if (nameIndex == -1) { + nameIndex = this.sourceMapper.names.length; + this.sourceMapper.names.push(name); + } + } + this.sourceMapper.currentNameIndex.push(nameIndex); + } + }; + + Emitter.prototype.recordSourceMappingNameEnd = function () { + if (this.sourceMapper) { + this.sourceMapper.currentNameIndex.pop(); + } + }; + + Emitter.prototype.recordSourceMappingStart = function (ast) { + if (this.sourceMapper && TypeScript.isValidAstNode(ast)) { + var lineCol = { line: -1, character: -1 }; + var sourceMapping = new TypeScript.SourceMapping(); + sourceMapping.start.emittedColumn = this.emitState.column; + sourceMapping.start.emittedLine = this.emitState.line; + + var lineMap = this.document.lineMap(); + lineMap.fillLineAndCharacterFromPosition(ast.start(), lineCol); + sourceMapping.start.sourceColumn = lineCol.character; + sourceMapping.start.sourceLine = lineCol.line + 1; + lineMap.fillLineAndCharacterFromPosition(ast.end(), lineCol); + sourceMapping.end.sourceColumn = lineCol.character; + sourceMapping.end.sourceLine = lineCol.line + 1; + + TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.emittedLine)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.start.sourceLine)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.sourceLine)); + + if (this.sourceMapper.currentNameIndex.length > 0) { + sourceMapping.nameIndex = this.sourceMapper.currentNameIndex[this.sourceMapper.currentNameIndex.length - 1]; + } + + var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; + siblings.push(sourceMapping); + this.sourceMapper.currentMappings.push(sourceMapping.childMappings); + this.sourceMapper.increaseMappingLevel(ast); + } + }; + + Emitter.prototype.recordSourceMappingEnd = function (ast) { + if (this.sourceMapper && TypeScript.isValidAstNode(ast)) { + this.sourceMapper.currentMappings.pop(); + + var siblings = this.sourceMapper.currentMappings[this.sourceMapper.currentMappings.length - 1]; + var sourceMapping = siblings[siblings.length - 1]; + + sourceMapping.end.emittedColumn = this.emitState.column; + sourceMapping.end.emittedLine = this.emitState.line; + + TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedColumn)); + TypeScript.Debug.assert(!isNaN(sourceMapping.end.emittedLine)); + + this.sourceMapper.decreaseMappingLevel(ast); + } + }; + + Emitter.prototype.getOutputFiles = function () { + var result = []; + if (this.sourceMapper !== null) { + this.sourceMapper.emitSourceMapping(); + result.push(this.sourceMapper.getOutputFile()); + } + + result.push(this.outfile.getOutputFile()); + return result; + }; + + Emitter.prototype.emitParameterPropertyAndMemberVariableAssignments = function () { + var constructorDecl = getLastConstructor(this.thisClassNode); + + if (constructorDecl && constructorDecl.parameterList) { + for (var i = 0, n = constructorDecl.parameterList.parameters.nonSeparatorCount(); i < n; i++) { + var parameter = constructorDecl.parameterList.parameters.nonSeparatorAt(i); + var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter); + if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) { + this.emitIndent(); + this.recordSourceMappingStart(parameter); + this.writeToOutputWithSourceMapRecord("this." + parameter.identifier.text(), parameter.identifier); + this.writeToOutput(" = "); + this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter.identifier); + this.writeLineToOutput(";"); + this.recordSourceMappingEnd(parameter); + } + } + } + + for (var i = 0, n = this.thisClassNode.classElements.childCount(); i < n; i++) { + if (this.thisClassNode.classElements.childAt(i).kind() === 136 /* MemberVariableDeclaration */) { + var varDecl = this.thisClassNode.classElements.childAt(i); + if (!TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) { + this.emitIndent(); + this.emitMemberVariableDeclaration(varDecl); + this.writeLineToOutput(""); + } + } + } + }; + + Emitter.prototype.isOnSameLine = function (pos1, pos2) { + var lineMap = this.document.lineMap(); + return lineMap.getLineNumberFromPosition(pos1) === lineMap.getLineNumberFromPosition(pos2); + }; + + Emitter.prototype.emitCommaSeparatedList = function (parent, list, buffer, preserveNewLines) { + if (list === null || list.nonSeparatorCount() === 0) { + return; + } + + var startLine = preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(0).end()); + + if (preserveNewLines) { + this.indenter.increaseIndent(); + } + + if (startLine) { + this.writeLineToOutput(""); + } else { + this.writeToOutput(buffer); + } + + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + var emitNode = list.nonSeparatorAt(i); + + this.emitJavascript(emitNode, startLine); + + if (i < (n - 1)) { + startLine = preserveNewLines && !this.isOnSameLine(emitNode.end(), list.nonSeparatorAt(i + 1).start()); + if (startLine) { + this.writeLineToOutput(","); + } else { + this.writeToOutput(", "); + } + } + } + + if (preserveNewLines) { + this.indenter.decreaseIndent(); + } + + if (preserveNewLines && !this.isOnSameLine(parent.end(), list.nonSeparatorAt(list.nonSeparatorCount() - 1).end())) { + this.writeLineToOutput(""); + this.emitIndent(); + } else { + this.writeToOutput(buffer); + } + }; + + Emitter.prototype.emitList = function (list, useNewLineSeparator, startInclusive, endExclusive) { + if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; } + if (typeof startInclusive === "undefined") { startInclusive = 0; } + if (typeof endExclusive === "undefined") { endExclusive = list.childCount(); } + if (list === null) { + return; + } + + this.emitComments(list, true); + var lastEmittedNode = null; + + for (var i = startInclusive; i < endExclusive; i++) { + var node = list.childAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + if (useNewLineSeparator) { + this.writeLineToOutput(""); + } + + lastEmittedNode = node; + } + } + + this.emitComments(list, false); + }; + + Emitter.prototype.emitSeparatedList = function (list, useNewLineSeparator, startInclusive, endExclusive) { + if (typeof useNewLineSeparator === "undefined") { useNewLineSeparator = true; } + if (typeof startInclusive === "undefined") { startInclusive = 0; } + if (typeof endExclusive === "undefined") { endExclusive = list.nonSeparatorCount(); } + if (list === null) { + return; + } + + this.emitComments(list, true); + var lastEmittedNode = null; + + for (var i = startInclusive; i < endExclusive; i++) { + var node = list.nonSeparatorAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + if (useNewLineSeparator) { + this.writeLineToOutput(""); + } + + lastEmittedNode = node; + } + } + + this.emitComments(list, false); + }; + + Emitter.prototype.isDirectivePrologueElement = function (node) { + if (node.kind() === 149 /* ExpressionStatement */) { + var exprStatement = node; + return exprStatement.expression.kind() === 14 /* StringLiteral */; + } + + return false; + }; + + Emitter.prototype.emitSpaceBetweenConstructs = function (node1, node2) { + if (node1 === null || node2 === null) { + return; + } + + if (node1.start() === -1 || node1.end() === -1 || node2.start() === -1 || node2.end() === -1) { + return; + } + + var lineMap = this.document.lineMap(); + var node1EndLine = lineMap.getLineNumberFromPosition(node1.end()); + var node2StartLine = lineMap.getLineNumberFromPosition(node2.start()); + + if ((node2StartLine - node1EndLine) > 1) { + this.writeLineToOutput("", true); + } + }; + + Emitter.prototype.getCopyrightComments = function () { + var preComments = this.copyrightElement.preComments(); + if (preComments) { + var lineMap = this.document.lineMap(); + + var copyrightComments = []; + var lastComment = null; + + for (var i = 0, n = preComments.length; i < n; i++) { + var comment = preComments[i]; + + if (lastComment) { + var lastCommentLine = lineMap.getLineNumberFromPosition(lastComment.end()); + var commentLine = lineMap.getLineNumberFromPosition(comment.start()); + + if (commentLine >= lastCommentLine + 2) { + return copyrightComments; + } + } + + copyrightComments.push(comment); + lastComment = comment; + } + + var lastCommentLine = lineMap.getLineNumberFromPosition(TypeScript.ArrayUtilities.last(copyrightComments).end()); + var astLine = lineMap.getLineNumberFromPosition(this.copyrightElement.start()); + if (astLine >= lastCommentLine + 2) { + return copyrightComments; + } + } + + return []; + }; + + Emitter.prototype.emitPossibleCopyrightHeaders = function (script) { + var list = script.moduleElements; + if (list.childCount() > 0) { + var firstElement = list.childAt(0); + + this.copyrightElement = firstElement; + this.emitCommentsArray(this.getCopyrightComments(), false); + } + }; + + Emitter.prototype.emitScriptElements = function (sourceUnit) { + var list = sourceUnit.moduleElements; + + this.emitPossibleCopyrightHeaders(sourceUnit); + + for (var i = 0, n = list.childCount(); i < n; i++) { + var node = list.childAt(i); + + if (!this.isDirectivePrologueElement(node)) { + break; + } + + this.emitJavascript(node, true); + this.writeLineToOutput(""); + } + + this.emitPrologue(sourceUnit); + + var isExternalModule = this.document.isExternalModule(); + var isNonElidedExternalModule = isExternalModule && !TypeScript.scriptIsElided(sourceUnit); + if (isNonElidedExternalModule) { + this.recordSourceMappingStart(sourceUnit); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + var dependencyList = "[\"require\", \"exports\""; + var importList = "require, exports"; + + var importAndDependencyList = this.getModuleImportAndDependencyList(sourceUnit); + importList += importAndDependencyList.importList; + dependencyList += importAndDependencyList.dependencyList + "]"; + + this.writeLineToOutput("define(" + dependencyList + "," + " function(" + importList + ") {"); + } + } + + if (isExternalModule) { + var temp = this.setContainer(2 /* DynamicModule */); + + var svModuleName = this.moduleName; + this.moduleName = sourceUnit.fileName(); + if (TypeScript.isTSFile(this.moduleName)) { + this.moduleName = this.moduleName.substring(0, this.moduleName.length - ".ts".length); + } + + this.setExportAssignmentIdentifier(null); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + this.indenter.increaseIndent(); + } + + var externalModule = this.semanticInfoChain.getDeclForAST(this.document.sourceUnit()); + + if (TypeScript.hasFlag(externalModule.flags, 262144 /* MustCaptureThis */)) { + this.writeCaptureThisStatement(sourceUnit); + } + + this.pushDecl(externalModule); + } + + this.emitList(list, true, i, n); + + if (isExternalModule) { + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + this.indenter.decreaseIndent(); + } + + if (isNonElidedExternalModule) { + var exportAssignmentIdentifier = this.getExportAssignmentIdentifier(); + var exportAssignmentValueSymbol = externalModule.getSymbol().getExportAssignedValueSymbol(); + + if (this.emitOptions.compilationSettings().moduleGenTarget() === 2 /* Asynchronous */) { + if (exportAssignmentIdentifier && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) { + this.indenter.increaseIndent(); + this.emitIndent(); + this.writeLineToOutput("return " + exportAssignmentIdentifier + ";"); + this.indenter.decreaseIndent(); + } + this.writeToOutput("});"); + } else if (exportAssignmentIdentifier && exportAssignmentValueSymbol && !(exportAssignmentValueSymbol.kind & 58720272 /* SomeTypeReference */)) { + this.emitIndent(); + this.writeToOutput("module.exports = " + exportAssignmentIdentifier + ";"); + } + + this.recordSourceMappingEnd(sourceUnit); + this.writeLineToOutput(""); + } + + this.setContainer(temp); + this.moduleName = svModuleName; + this.popDecl(externalModule); + } + }; + + Emitter.prototype.emitConstructorStatements = function (funcDecl) { + var list = funcDecl.block.statements; + + if (list === null) { + return; + } + + this.emitComments(list, true); + + var emitPropertyAssignmentsAfterSuperCall = TypeScript.getExtendsHeritageClause(this.thisClassNode.heritageClauses) !== null; + var propertyAssignmentIndex = emitPropertyAssignmentsAfterSuperCall ? 1 : 0; + var lastEmittedNode = null; + + for (var i = 0, n = list.childCount(); i < n; i++) { + if (i === propertyAssignmentIndex) { + this.emitParameterPropertyAndMemberVariableAssignments(); + } + + var node = list.childAt(i); + + if (this.shouldEmit(node)) { + this.emitSpaceBetweenConstructs(lastEmittedNode, node); + + this.emitJavascript(node, true); + this.writeLineToOutput(""); + + lastEmittedNode = node; + } + } + + if (i === propertyAssignmentIndex) { + this.emitParameterPropertyAndMemberVariableAssignments(); + } + + this.emitComments(list, false); + }; + + Emitter.prototype.emitJavascript = function (ast, startLine) { + if (ast === null) { + return; + } + + if (startLine && this.indenter.indentAmt > 0) { + this.emitIndent(); + } + + this.emit(ast); + }; + + Emitter.prototype.emitAccessorMemberDeclaration = function (funcDecl, name, className, isProto) { + if (funcDecl.kind() !== 139 /* GetAccessor */) { + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain); + if (accessorSymbol.getGetter()) { + return; + } + } + + this.emitIndent(); + this.recordSourceMappingStart(funcDecl); + + this.writeToOutput("Object.defineProperty(" + className); + if (isProto) { + this.writeToOutput(".prototype, "); + } else { + this.writeToOutput(", "); + } + + var functionName = name.text(); + if (TypeScript.isQuoted(functionName)) { + this.writeToOutput(functionName); + } else { + this.writeToOutput('"' + functionName + '"'); + } + + this.writeLineToOutput(", {"); + + this.indenter.increaseIndent(); + + var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain); + if (accessors.getter) { + this.emitIndent(); + this.recordSourceMappingStart(accessors.getter); + this.emitComments(accessors.getter, true); + this.writeToOutput("get: "); + this.emitAccessorBody(accessors.getter, accessors.getter.parameterList, accessors.getter.block); + this.writeLineToOutput(","); + } + + if (accessors.setter) { + this.emitIndent(); + this.recordSourceMappingStart(accessors.setter); + this.emitComments(accessors.setter, true); + this.writeToOutput("set: "); + this.emitAccessorBody(accessors.setter, accessors.setter.parameterList, accessors.setter.block); + this.writeLineToOutput(","); + } + + this.emitIndent(); + this.writeLineToOutput("enumerable: true,"); + this.emitIndent(); + this.writeLineToOutput("configurable: true"); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("});"); + this.recordSourceMappingEnd(funcDecl); + }; + + Emitter.prototype.emitAccessorBody = function (funcDecl, parameterList, block) { + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(null, funcDecl, parameters, block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.recordSourceMappingEnd(funcDecl); + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitClass = function (classDecl) { + var pullDecl = this.semanticInfoChain.getDeclForAST(classDecl); + this.pushDecl(pullDecl); + + var svClassNode = this.thisClassNode; + this.thisClassNode = classDecl; + var className = classDecl.identifier.text(); + this.emitComments(classDecl, true); + var temp = this.setContainer(3 /* Class */); + + this.recordSourceMappingStart(classDecl); + this.writeToOutput("var " + className); + + var hasBaseClass = TypeScript.getExtendsHeritageClause(classDecl.heritageClauses) !== null; + var baseTypeReference = null; + var varDecl = null; + + if (hasBaseClass) { + this.writeLineToOutput(" = (function (_super) {"); + } else { + this.writeLineToOutput(" = (function () {"); + } + + this.recordSourceMappingNameStart(className); + this.indenter.increaseIndent(); + + if (hasBaseClass) { + baseTypeReference = TypeScript.getExtendsHeritageClause(classDecl.heritageClauses).typeNames.nonSeparatorAt(0); + this.emitIndent(); + this.writeLineToOutput("__extends(" + className + ", _super);"); + } + + this.emitIndent(); + + var constrDecl = getLastConstructor(classDecl); + + if (constrDecl) { + this.emit(constrDecl); + this.writeLineToOutput(""); + } else { + this.recordSourceMappingStart(classDecl); + + this.indenter.increaseIndent(); + this.writeLineToOutput("function " + classDecl.identifier.text() + "() {"); + this.recordSourceMappingNameStart("constructor"); + if (hasBaseClass) { + this.emitIndent(); + this.writeLineToOutput("_super.apply(this, arguments);"); + } + + if (this.shouldCaptureThis(classDecl)) { + this.writeCaptureThisStatement(classDecl); + } + + this.emitParameterPropertyAndMemberVariableAssignments(); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeLineToOutput("}"); + + this.recordSourceMappingNameEnd(); + this.recordSourceMappingEnd(classDecl); + } + + this.emitClassMembers(classDecl); + + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("return " + className + ";", classDecl.closeBraceToken); + this.writeLineToOutput(""); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutputWithSourceMapRecord("}", classDecl.closeBraceToken); + this.recordSourceMappingNameEnd(); + this.recordSourceMappingStart(classDecl); + this.writeToOutput(")("); + if (hasBaseClass) { + this.emitJavascript(baseTypeReference, false); + } + this.writeToOutput(");"); + this.recordSourceMappingEnd(classDecl); + + if ((temp === 1 /* Module */ || temp === 2 /* DynamicModule */) && TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + this.writeLineToOutput(""); + this.emitIndent(); + var modName = temp === 1 /* Module */ ? this.moduleName : "exports"; + this.writeToOutputWithSourceMapRecord(modName + "." + className + " = " + className + ";", classDecl); + } + + this.recordSourceMappingEnd(classDecl); + this.emitComments(classDecl, false); + this.setContainer(temp); + this.thisClassNode = svClassNode; + + this.popDecl(pullDecl); + }; + + Emitter.prototype.emitClassMembers = function (classDecl) { + var lastEmittedMember = null; + + for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) { + var memberDecl = classDecl.classElements.childAt(i); + + if (memberDecl.kind() === 139 /* GetAccessor */) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + var getter = memberDecl; + this.emitAccessorMemberDeclaration(getter, getter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(getter.modifiers, 16 /* Static */)); + lastEmittedMember = memberDecl; + } else if (memberDecl.kind() === 140 /* SetAccessor */) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + var setter = memberDecl; + this.emitAccessorMemberDeclaration(setter, setter.propertyName, classDecl.identifier.text(), !TypeScript.hasModifier(setter.modifiers, 16 /* Static */)); + lastEmittedMember = memberDecl; + } else if (memberDecl.kind() === 135 /* MemberFunctionDeclaration */) { + var memberFunction = memberDecl; + + if (memberFunction.block) { + this.emitSpaceBetweenConstructs(lastEmittedMember, memberDecl); + + this.emitClassMemberFunctionDeclaration(classDecl, memberFunction); + lastEmittedMember = memberDecl; + } + } + } + + for (var i = 0, n = classDecl.classElements.childCount(); i < n; i++) { + var memberDecl = classDecl.classElements.childAt(i); + + if (memberDecl.kind() === 136 /* MemberVariableDeclaration */) { + var varDecl = memberDecl; + + if (TypeScript.hasModifier(varDecl.modifiers, 16 /* Static */) && varDecl.variableDeclarator.equalsValueClause) { + this.emitSpaceBetweenConstructs(lastEmittedMember, varDecl); + + this.emitIndent(); + this.recordSourceMappingStart(varDecl); + + var varDeclName = varDecl.variableDeclarator.propertyName.text(); + if (TypeScript.isQuoted(varDeclName) || varDecl.variableDeclarator.propertyName.kind() !== 11 /* IdentifierName */) { + this.writeToOutput(classDecl.identifier.text() + "[" + varDeclName + "]"); + } else { + this.writeToOutput(classDecl.identifier.text() + "." + varDeclName); + } + + this.emit(varDecl.variableDeclarator.equalsValueClause); + + this.recordSourceMappingEnd(varDecl); + this.writeLineToOutput(";"); + + lastEmittedMember = varDecl; + } + } + } + }; + + Emitter.prototype.emitClassMemberFunctionDeclaration = function (classDecl, funcDecl) { + this.emitIndent(); + this.recordSourceMappingStart(funcDecl); + this.emitComments(funcDecl, true); + var functionName = funcDecl.propertyName.text(); + + this.writeToOutput(classDecl.identifier.text()); + + if (!TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) { + this.writeToOutput(".prototype"); + } + + if (TypeScript.isQuoted(functionName) || funcDecl.propertyName.kind() !== 11 /* IdentifierName */) { + this.writeToOutput("[" + functionName + "] = "); + } else { + this.writeToOutput("." + functionName + " = "); + } + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcDecl); + this.writeToOutput("function "); + + this.emitParameterList(funcDecl.callSignature.parameterList); + + var parameters = TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList); + this.emitFunctionBodyStatements(funcDecl.propertyName.text(), funcDecl, parameters, funcDecl.block, null); + + this.recordSourceMappingEnd(funcDecl); + + this.emitComments(funcDecl, false); + + this.recordSourceMappingEnd(funcDecl); + this.popDecl(pullDecl); + + this.writeLineToOutput(";"); + }; + + Emitter.prototype.requiresExtendsBlock = function (moduleElements) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + + if (moduleElement.kind() === 130 /* ModuleDeclaration */) { + var moduleAST = moduleElement; + + if (!TypeScript.hasModifier(moduleAST.modifiers, 8 /* Ambient */) && this.requiresExtendsBlock(moduleAST.moduleElements)) { + return true; + } + } else if (moduleElement.kind() === 131 /* ClassDeclaration */) { + var classDeclaration = moduleElement; + + if (!TypeScript.hasModifier(classDeclaration.modifiers, 8 /* Ambient */) && TypeScript.getExtendsHeritageClause(classDeclaration.heritageClauses) !== null) { + return true; + } + } + } + + return false; + }; + + Emitter.prototype.emitPrologue = function (sourceUnit) { + if (!this.extendsPrologueEmitted) { + if (this.requiresExtendsBlock(sourceUnit.moduleElements)) { + this.extendsPrologueEmitted = true; + this.writeLineToOutput("var __extends = this.__extends || function (d, b) {"); + this.writeLineToOutput(" for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];"); + this.writeLineToOutput(" function __() { this.constructor = d; }"); + this.writeLineToOutput(" __.prototype = b.prototype;"); + this.writeLineToOutput(" d.prototype = new __();"); + this.writeLineToOutput("};"); + } + } + + if (!this.globalThisCapturePrologueEmitted) { + if (this.shouldCaptureThis(sourceUnit)) { + this.globalThisCapturePrologueEmitted = true; + this.writeLineToOutput(this.captureThisStmtString); + } + } + }; + + Emitter.prototype.emitThis = function () { + if (!this.inWithBlock && this.inArrowFunction) { + this.writeToOutput("_this"); + } else { + this.writeToOutput("this"); + } + }; + + Emitter.prototype.emitBlockOrStatement = function (node) { + if (node.kind() === 146 /* Block */) { + this.emit(node); + } else { + this.writeLineToOutput(""); + this.indenter.increaseIndent(); + this.emitJavascript(node, true); + this.indenter.decreaseIndent(); + } + }; + + Emitter.prototype.emitLiteralExpression = function (expression) { + switch (expression.kind()) { + case 32 /* NullKeyword */: + this.writeToOutputWithSourceMapRecord("null", expression); + break; + case 24 /* FalseKeyword */: + this.writeToOutputWithSourceMapRecord("false", expression); + break; + case 37 /* TrueKeyword */: + this.writeToOutputWithSourceMapRecord("true", expression); + break; + default: + throw TypeScript.Errors.abstract(); + } + }; + + Emitter.prototype.emitThisExpression = function (expression) { + if (!this.inWithBlock && this.inArrowFunction) { + this.writeToOutputWithSourceMapRecord("_this", expression); + } else { + this.writeToOutputWithSourceMapRecord("this", expression); + } + }; + + Emitter.prototype.emitSuperExpression = function (expression) { + this.writeToOutputWithSourceMapRecord("_super.prototype", expression); + }; + + Emitter.prototype.emitParenthesizedExpression = function (parenthesizedExpression) { + if (parenthesizedExpression.expression.kind() === 220 /* CastExpression */ && parenthesizedExpression.openParenTrailingComments === null) { + this.emit(parenthesizedExpression.expression); + } else { + this.recordSourceMappingStart(parenthesizedExpression); + this.writeToOutput("("); + this.emitCommentsArray(parenthesizedExpression.openParenTrailingComments, false); + this.emit(parenthesizedExpression.expression); + this.writeToOutput(")"); + this.recordSourceMappingEnd(parenthesizedExpression); + } + }; + + Emitter.prototype.emitCastExpression = function (expression) { + this.emit(expression.expression); + }; + + Emitter.prototype.emitPrefixUnaryExpression = function (expression) { + var nodeType = expression.kind(); + + this.recordSourceMappingStart(expression); + switch (nodeType) { + case 167 /* LogicalNotExpression */: + this.writeToOutput("!"); + this.emit(expression.operand); + break; + case 166 /* BitwiseNotExpression */: + this.writeToOutput("~"); + this.emit(expression.operand); + break; + case 165 /* NegateExpression */: + this.writeToOutput("-"); + if (expression.operand.kind() === 165 /* NegateExpression */ || expression.operand.kind() === 169 /* PreDecrementExpression */) { + this.writeToOutput(" "); + } + this.emit(expression.operand); + break; + case 164 /* PlusExpression */: + this.writeToOutput("+"); + if (expression.operand.kind() === 164 /* PlusExpression */ || expression.operand.kind() === 168 /* PreIncrementExpression */) { + this.writeToOutput(" "); + } + this.emit(expression.operand); + break; + case 168 /* PreIncrementExpression */: + this.writeToOutput("++"); + this.emit(expression.operand); + break; + case 169 /* PreDecrementExpression */: + this.writeToOutput("--"); + this.emit(expression.operand); + break; + default: + throw TypeScript.Errors.abstract(); + } + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitPostfixUnaryExpression = function (expression) { + var nodeType = expression.kind(); + + this.recordSourceMappingStart(expression); + switch (nodeType) { + case 210 /* PostIncrementExpression */: + this.emit(expression.operand); + this.writeToOutput("++"); + break; + case 211 /* PostDecrementExpression */: + this.emit(expression.operand); + this.writeToOutput("--"); + break; + default: + throw TypeScript.Errors.abstract(); + } + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitTypeOfExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("typeof "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitDeleteExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("delete "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitVoidExpression = function (expression) { + this.recordSourceMappingStart(expression); + this.writeToOutput("void "); + this.emit(expression.expression); + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.canEmitDottedNameMemberAccessExpression = function (expression) { + var memberExpressionNodeType = expression.expression.kind(); + + if (memberExpressionNodeType == 11 /* IdentifierName */ || memberExpressionNodeType == 212 /* MemberAccessExpression */) { + var memberAccessSymbol = this.getSymbolForEmit(expression).symbol; + var memberAccessExpressionSymbol = this.getSymbolForEmit(expression.expression).symbol; + if (memberAccessSymbol && memberAccessExpressionSymbol && !this.semanticInfoChain.getAliasSymbolForAST(expression.expression) && (TypeScript.PullHelpers.symbolIsModule(memberAccessExpressionSymbol) || memberAccessExpressionSymbol.kind === 64 /* Enum */ || memberAccessExpressionSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */))) { + var memberAccessSymbolKind = memberAccessSymbol.kind; + if (memberAccessSymbolKind === 4096 /* Property */ || memberAccessSymbolKind === 67108864 /* EnumMember */ || (memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && memberAccessSymbolKind === 512 /* Variable */ && !memberAccessSymbol.anyDeclHasFlag(32768 /* InitializedModule */ | 4096 /* Enum */)) || ((memberAccessSymbol.anyDeclHasFlag(1 /* Exported */) && !this.symbolIsUsedInItsEnclosingContainer(memberAccessSymbol)))) { + if (memberExpressionNodeType == 212 /* MemberAccessExpression */) { + return this.canEmitDottedNameMemberAccessExpression(expression.expression); + } + + return true; + } + } + } + + return false; + }; + + Emitter.prototype.emitDottedNameMemberAccessExpressionWorker = function (expression, potentialPath, startingIndex, lastIndex) { + this.recordSourceMappingStart(expression); + if (expression.expression.kind() == 212 /* MemberAccessExpression */) { + this.emitDottedNameMemberAccessExpressionRecurse(expression.expression, potentialPath, startingIndex, lastIndex - 1); + } else { + this.emitComments(expression.expression, true); + this.recordSourceMappingStart(expression.expression); + + this.emitDottedNameFromDeclPath(potentialPath, startingIndex, lastIndex - 2); + + this.writeToOutput(expression.expression.text()); + + this.recordSourceMappingEnd(expression.expression); + this.emitComments(expression.expression, false); + } + + this.writeToOutput("."); + this.emitName(expression.name, false); + + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitDottedNameMemberAccessExpressionRecurse = function (expression, potentialPath, startingIndex, lastIndex) { + this.emitComments(expression, true); + + if (lastIndex - startingIndex < 1) { + startingIndex = lastIndex - 1; + TypeScript.Debug.assert(startingIndex >= 0); + } + + this.emitDottedNameMemberAccessExpressionWorker(expression, potentialPath, startingIndex, lastIndex); + this.emitComments(expression, false); + }; + + Emitter.prototype.emitDottedNameMemberAccessExpression = function (expression) { + var memberAccessSymbol = this.getSymbolForEmit(expression).symbol; + + var potentialDeclInfo = this.getPotentialDeclPathInfoForEmit(memberAccessSymbol); + this.emitDottedNameMemberAccessExpressionWorker(expression, potentialDeclInfo.potentialPath, potentialDeclInfo.startingIndex, potentialDeclInfo.potentialPath.length); + }; + + Emitter.prototype.emitMemberAccessExpression = function (expression) { + if (!this.tryEmitConstant(expression)) { + if (this.canEmitDottedNameMemberAccessExpression(expression)) { + this.emitDottedNameMemberAccessExpression(expression); + } else { + this.recordSourceMappingStart(expression); + this.emit(expression.expression); + this.writeToOutput("."); + this.emitName(expression.name, false); + this.recordSourceMappingEnd(expression); + } + } + }; + + Emitter.prototype.emitQualifiedName = function (name) { + this.recordSourceMappingStart(name); + + this.emit(name.left); + this.writeToOutput("."); + this.emitName(name.right, false); + + this.recordSourceMappingEnd(name); + }; + + Emitter.prototype.emitBinaryExpression = function (expression) { + this.recordSourceMappingStart(expression); + switch (expression.kind()) { + case 173 /* CommaExpression */: + this.emit(expression.left); + this.writeToOutput(", "); + this.emit(expression.right); + break; + default: { + this.emit(expression.left); + var binOp = TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(expression.kind())); + if (binOp === "instanceof") { + this.writeToOutput(" instanceof "); + } else if (binOp === "in") { + this.writeToOutput(" in "); + } else { + this.writeToOutput(" " + binOp + " "); + } + this.emit(expression.right); + } + } + this.recordSourceMappingEnd(expression); + }; + + Emitter.prototype.emitSimplePropertyAssignment = function (property) { + this.recordSourceMappingStart(property); + this.emit(property.propertyName); + this.writeToOutput(": "); + this.emit(property.expression); + this.recordSourceMappingEnd(property); + }; + + Emitter.prototype.emitFunctionPropertyAssignment = function (funcProp) { + this.recordSourceMappingStart(funcProp); + + this.emit(funcProp.propertyName); + this.writeToOutput(": "); + + var pullFunctionDecl = this.semanticInfoChain.getDeclForAST(funcProp); + + var savedInArrowFunction = this.inArrowFunction; + this.inArrowFunction = false; + + var temp = this.setContainer(5 /* Function */); + var funcName = funcProp.propertyName; + + var pullDecl = this.semanticInfoChain.getDeclForAST(funcProp); + this.pushDecl(pullDecl); + + this.recordSourceMappingStart(funcProp); + this.writeToOutput("function "); + + this.writeToOutput("("); + + var parameters = TypeScript.Parameters.fromParameterList(funcProp.callSignature.parameterList); + this.emitFunctionParameters(parameters); + this.writeToOutput(")"); + + this.emitFunctionBodyStatements(funcProp.propertyName.text(), funcProp, parameters, funcProp.block, null); + + this.recordSourceMappingEnd(funcProp); + + this.recordSourceMappingEnd(funcProp); + + this.emitComments(funcProp, false); + + this.popDecl(pullDecl); + + this.setContainer(temp); + this.inArrowFunction = savedInArrowFunction; + + this.recordSourceMappingEnd(funcProp); + }; + + Emitter.prototype.emitConditionalExpression = function (expression) { + this.emit(expression.condition); + this.writeToOutput(" ? "); + this.emit(expression.whenTrue); + this.writeToOutput(" : "); + this.emit(expression.whenFalse); + }; + + Emitter.prototype.emitThrowStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("throw "); + this.emit(statement.expression); + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitExpressionStatement = function (statement) { + var isArrowExpression = statement.expression.kind() === 219 /* SimpleArrowFunctionExpression */ || statement.expression.kind() === 218 /* ParenthesizedArrowFunctionExpression */; + + this.recordSourceMappingStart(statement); + if (isArrowExpression) { + this.writeToOutput("("); + } + + this.emit(statement.expression); + + if (isArrowExpression) { + this.writeToOutput(")"); + } + + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitLabeledStatement = function (statement) { + this.writeToOutputWithSourceMapRecord(statement.identifier.text(), statement.identifier); + this.writeLineToOutput(":"); + this.emitJavascript(statement.statement, true); + }; + + Emitter.prototype.emitBlock = function (block) { + this.recordSourceMappingStart(block); + this.writeLineToOutput(" {"); + this.indenter.increaseIndent(); + if (block.statements) { + this.emitList(block.statements); + } + this.emitCommentsArray(block.closeBraceLeadingComments, false); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutput("}"); + this.recordSourceMappingEnd(block); + }; + + Emitter.prototype.emitBreakStatement = function (jump) { + this.recordSourceMappingStart(jump); + this.writeToOutput("break"); + + if (jump.identifier) { + this.writeToOutput(" " + jump.identifier.text()); + } + + this.recordSourceMappingEnd(jump); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitContinueStatement = function (jump) { + this.recordSourceMappingStart(jump); + this.writeToOutput("continue"); + + if (jump.identifier) { + this.writeToOutput(" " + jump.identifier.text()); + } + + this.recordSourceMappingEnd(jump); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitWhileStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("while ("); + this.emit(statement.condition); + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitDoStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("do"); + this.emitBlockOrStatement(statement.statement); + this.writeToOutputWithSourceMapRecord(" while", statement.whileKeyword); + this.writeToOutput('('); + this.emit(statement.condition); + this.writeToOutput(")"); + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitIfStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("if ("); + this.emit(statement.condition); + this.writeToOutput(")"); + + this.emitBlockOrStatement(statement.statement); + + if (statement.elseClause) { + if (statement.statement.kind() !== 146 /* Block */) { + this.writeLineToOutput(""); + this.emitIndent(); + } else { + this.writeToOutput(" "); + } + + this.emit(statement.elseClause); + } + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitElseClause = function (elseClause) { + if (elseClause.statement.kind() === 147 /* IfStatement */) { + this.writeToOutput("else "); + this.emit(elseClause.statement); + } else { + this.writeToOutput("else"); + this.emitBlockOrStatement(elseClause.statement); + } + }; + + Emitter.prototype.emitReturnStatement = function (statement) { + this.recordSourceMappingStart(statement); + if (statement.expression) { + this.writeToOutput("return "); + this.emit(statement.expression); + } else { + this.writeToOutput("return"); + } + this.recordSourceMappingEnd(statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitForInStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("for ("); + if (statement.left) { + this.emit(statement.left); + } else { + this.emit(statement.variableDeclaration); + } + this.writeToOutput(" in "); + this.emit(statement.expression); + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitForStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("for ("); + if (statement.variableDeclaration) { + this.emit(statement.variableDeclaration); + } else if (statement.initializer) { + this.emit(statement.initializer); + } + + this.writeToOutput("; "); + this.emitJavascript(statement.condition, false); + this.writeToOutput(";"); + if (statement.incrementor) { + this.writeToOutput(" "); + this.emitJavascript(statement.incrementor, false); + } + this.writeToOutput(")"); + this.emitBlockOrStatement(statement.statement); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitWithStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("with ("); + if (statement.condition) { + this.emit(statement.condition); + } + + this.writeToOutput(")"); + var prevInWithBlock = this.inWithBlock; + this.inWithBlock = true; + this.emitBlockOrStatement(statement.statement); + this.inWithBlock = prevInWithBlock; + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitSwitchStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("switch ("); + this.emit(statement.expression); + this.recordSourceMappingStart(statement.closeParenToken); + this.writeToOutput(")"); + this.recordSourceMappingEnd(statement.closeParenToken); + this.writeLineToOutput(" {"); + this.indenter.increaseIndent(); + this.emitList(statement.switchClauses, false); + this.indenter.decreaseIndent(); + this.emitIndent(); + this.writeToOutput("}"); + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitCaseSwitchClause = function (clause) { + this.recordSourceMappingStart(clause); + this.writeToOutput("case "); + this.emit(clause.expression); + this.writeToOutput(":"); + + this.emitSwitchClauseBody(clause.statements); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitSwitchClauseBody = function (body) { + if (body.childCount() === 1 && body.childAt(0).kind() === 146 /* Block */) { + this.emit(body.childAt(0)); + this.writeLineToOutput(""); + } else { + this.writeLineToOutput(""); + this.indenter.increaseIndent(); + this.emit(body); + this.indenter.decreaseIndent(); + } + }; + + Emitter.prototype.emitDefaultSwitchClause = function (clause) { + this.recordSourceMappingStart(clause); + this.writeToOutput("default:"); + + this.emitSwitchClauseBody(clause.statements); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitTryStatement = function (statement) { + this.recordSourceMappingStart(statement); + this.writeToOutput("try "); + this.emit(statement.block); + this.emitJavascript(statement.catchClause, false); + + if (statement.finallyClause) { + this.emit(statement.finallyClause); + } + this.recordSourceMappingEnd(statement); + }; + + Emitter.prototype.emitCatchClause = function (clause) { + this.writeToOutput(" "); + this.recordSourceMappingStart(clause); + this.writeToOutput("catch ("); + this.emit(clause.identifier); + this.writeToOutput(")"); + this.emit(clause.block); + this.recordSourceMappingEnd(clause); + }; + + Emitter.prototype.emitFinallyClause = function (clause) { + this.writeToOutput(" finally"); + this.emit(clause.block); + }; + + Emitter.prototype.emitDebuggerStatement = function (statement) { + this.writeToOutputWithSourceMapRecord("debugger", statement); + this.writeToOutput(";"); + }; + + Emitter.prototype.emitNumericLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitRegularExpressionLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitStringLiteral = function (literal) { + this.writeToOutputWithSourceMapRecord(literal.text(), literal); + }; + + Emitter.prototype.emitEqualsValueClause = function (clause) { + this.writeToOutput(" = "); + this.emit(clause.value); + }; + + Emitter.prototype.emitParameter = function (parameter) { + this.writeToOutputWithSourceMapRecord(parameter.identifier.text(), parameter); + }; + + Emitter.prototype.emitConstructorDeclaration = function (declaration) { + if (declaration.block) { + this.emitConstructor(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitFunctionDeclaration = function (declaration) { + return declaration.preComments() !== null || (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null); + }; + + Emitter.prototype.emitFunctionDeclaration = function (declaration) { + if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */) && declaration.block !== null) { + this.emitFunction(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.emitSourceUnit = function (sourceUnit) { + if (!this.document.isDeclareFile()) { + var pullDecl = this.semanticInfoChain.getDeclForAST(sourceUnit); + this.pushDecl(pullDecl); + this.emitScriptElements(sourceUnit); + this.popDecl(pullDecl); + } + }; + + Emitter.prototype.shouldEmitEnumDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.enumIsElided(declaration); + }; + + Emitter.prototype.emitEnumDeclaration = function (declaration) { + if (!TypeScript.enumIsElided(declaration)) { + this.emitComments(declaration, true); + this.emitEnum(declaration); + this.emitComments(declaration, false); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitModuleDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.moduleIsElided(declaration); + }; + + Emitter.prototype.emitModuleDeclaration = function (declaration) { + if (!TypeScript.moduleIsElided(declaration)) { + this.emitModuleDeclarationWorker(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitClassDeclaration = function (declaration) { + return declaration.preComments() !== null || !TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */); + }; + + Emitter.prototype.emitClassDeclaration = function (declaration) { + if (!TypeScript.hasModifier(declaration.modifiers, 8 /* Ambient */)) { + this.emitClass(declaration); + } else { + this.emitComments(declaration, true, true); + } + }; + + Emitter.prototype.shouldEmitInterfaceDeclaration = function (declaration) { + return declaration.preComments() !== null; + }; + + Emitter.prototype.emitInterfaceDeclaration = function (declaration) { + this.emitComments(declaration, true, true); + }; + + Emitter.prototype.firstVariableDeclarator = function (statement) { + return statement.declaration.declarators.nonSeparatorAt(0); + }; + + Emitter.prototype.isNotAmbientOrHasInitializer = function (variableStatement) { + return !TypeScript.hasModifier(variableStatement.modifiers, 8 /* Ambient */) || this.firstVariableDeclarator(variableStatement).equalsValueClause !== null; + }; + + Emitter.prototype.shouldEmitVariableStatement = function (statement) { + return statement.preComments() !== null || this.isNotAmbientOrHasInitializer(statement); + }; + + Emitter.prototype.emitVariableStatement = function (statement) { + if (this.isNotAmbientOrHasInitializer(statement)) { + this.emitComments(statement, true); + this.emit(statement.declaration); + this.writeToOutput(";"); + this.emitComments(statement, false); + } else { + this.emitComments(statement, true, true); + } + }; + + Emitter.prototype.emitGenericType = function (type) { + this.emit(type.name); + }; + + Emitter.prototype.shouldEmit = function (ast) { + if (!ast) { + return false; + } + + switch (ast.kind()) { + case 133 /* ImportDeclaration */: + return this.shouldEmitImportDeclaration(ast); + case 131 /* ClassDeclaration */: + return this.shouldEmitClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.shouldEmitInterfaceDeclaration(ast); + case 129 /* FunctionDeclaration */: + return this.shouldEmitFunctionDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.shouldEmitModuleDeclaration(ast); + case 148 /* VariableStatement */: + return this.shouldEmitVariableStatement(ast); + case 223 /* OmittedExpression */: + return false; + case 132 /* EnumDeclaration */: + return this.shouldEmitEnumDeclaration(ast); + } + + return true; + }; + + Emitter.prototype.emit = function (ast) { + if (!ast) { + return; + } + + switch (ast.kind()) { + case 2 /* SeparatedList */: + return this.emitSeparatedList(ast); + case 1 /* List */: + return this.emitList(ast); + case 120 /* SourceUnit */: + return this.emitSourceUnit(ast); + case 133 /* ImportDeclaration */: + return this.emitImportDeclaration(ast); + case 134 /* ExportAssignment */: + return this.setExportAssignmentIdentifier(ast.identifier.text()); + case 131 /* ClassDeclaration */: + return this.emitClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.emitInterfaceDeclaration(ast); + case 11 /* IdentifierName */: + return this.emitName(ast, true); + case 225 /* VariableDeclarator */: + return this.emitVariableDeclarator(ast); + case 219 /* SimpleArrowFunctionExpression */: + return this.emitSimpleArrowFunctionExpression(ast); + case 218 /* ParenthesizedArrowFunctionExpression */: + return this.emitParenthesizedArrowFunctionExpression(ast); + case 129 /* FunctionDeclaration */: + return this.emitFunctionDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.emitModuleDeclaration(ast); + case 224 /* VariableDeclaration */: + return this.emitVariableDeclaration(ast); + case 126 /* GenericType */: + return this.emitGenericType(ast); + case 137 /* ConstructorDeclaration */: + return this.emitConstructorDeclaration(ast); + case 132 /* EnumDeclaration */: + return this.emitEnumDeclaration(ast); + case 243 /* EnumElement */: + return this.emitEnumElement(ast); + case 222 /* FunctionExpression */: + return this.emitFunctionExpression(ast); + case 148 /* VariableStatement */: + return this.emitVariableStatement(ast); + } + + this.emitComments(ast, true); + this.emitWorker(ast); + this.emitComments(ast, false); + }; + + Emitter.prototype.emitWorker = function (ast) { + if (!ast) { + return; + } + + switch (ast.kind()) { + case 13 /* NumericLiteral */: + return this.emitNumericLiteral(ast); + case 12 /* RegularExpressionLiteral */: + return this.emitRegularExpressionLiteral(ast); + case 14 /* StringLiteral */: + return this.emitStringLiteral(ast); + case 24 /* FalseKeyword */: + case 32 /* NullKeyword */: + case 37 /* TrueKeyword */: + return this.emitLiteralExpression(ast); + case 35 /* ThisKeyword */: + return this.emitThisExpression(ast); + case 50 /* SuperKeyword */: + return this.emitSuperExpression(ast); + case 217 /* ParenthesizedExpression */: + return this.emitParenthesizedExpression(ast); + case 214 /* ArrayLiteralExpression */: + return this.emitArrayLiteralExpression(ast); + case 211 /* PostDecrementExpression */: + case 210 /* PostIncrementExpression */: + return this.emitPostfixUnaryExpression(ast); + case 167 /* LogicalNotExpression */: + case 166 /* BitwiseNotExpression */: + case 165 /* NegateExpression */: + case 164 /* PlusExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return this.emitPrefixUnaryExpression(ast); + case 213 /* InvocationExpression */: + return this.emitInvocationExpression(ast); + case 221 /* ElementAccessExpression */: + return this.emitElementAccessExpression(ast); + case 212 /* MemberAccessExpression */: + return this.emitMemberAccessExpression(ast); + case 121 /* QualifiedName */: + return this.emitQualifiedName(ast); + case 173 /* CommaExpression */: + case 174 /* AssignmentExpression */: + case 175 /* AddAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 187 /* LogicalOrExpression */: + case 188 /* LogicalAndExpression */: + case 189 /* BitwiseOrExpression */: + case 190 /* BitwiseExclusiveOrExpression */: + case 191 /* BitwiseAndExpression */: + case 192 /* EqualsWithTypeConversionExpression */: + case 193 /* NotEqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + case 196 /* LessThanExpression */: + case 197 /* GreaterThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 200 /* InstanceOfExpression */: + case 201 /* InExpression */: + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + case 208 /* AddExpression */: + case 209 /* SubtractExpression */: + return this.emitBinaryExpression(ast); + case 186 /* ConditionalExpression */: + return this.emitConditionalExpression(ast); + case 232 /* EqualsValueClause */: + return this.emitEqualsValueClause(ast); + case 242 /* Parameter */: + return this.emitParameter(ast); + case 146 /* Block */: + return this.emitBlock(ast); + case 235 /* ElseClause */: + return this.emitElseClause(ast); + case 147 /* IfStatement */: + return this.emitIfStatement(ast); + case 149 /* ExpressionStatement */: + return this.emitExpressionStatement(ast); + case 139 /* GetAccessor */: + return this.emitGetAccessor(ast); + case 140 /* SetAccessor */: + return this.emitSetAccessor(ast); + case 157 /* ThrowStatement */: + return this.emitThrowStatement(ast); + case 150 /* ReturnStatement */: + return this.emitReturnStatement(ast); + case 216 /* ObjectCreationExpression */: + return this.emitObjectCreationExpression(ast); + case 151 /* SwitchStatement */: + return this.emitSwitchStatement(ast); + case 233 /* CaseSwitchClause */: + return this.emitCaseSwitchClause(ast); + case 234 /* DefaultSwitchClause */: + return this.emitDefaultSwitchClause(ast); + case 152 /* BreakStatement */: + return this.emitBreakStatement(ast); + case 153 /* ContinueStatement */: + return this.emitContinueStatement(ast); + case 154 /* ForStatement */: + return this.emitForStatement(ast); + case 155 /* ForInStatement */: + return this.emitForInStatement(ast); + case 158 /* WhileStatement */: + return this.emitWhileStatement(ast); + case 163 /* WithStatement */: + return this.emitWithStatement(ast); + case 220 /* CastExpression */: + return this.emitCastExpression(ast); + case 215 /* ObjectLiteralExpression */: + return this.emitObjectLiteralExpression(ast); + case 240 /* SimplePropertyAssignment */: + return this.emitSimplePropertyAssignment(ast); + case 241 /* FunctionPropertyAssignment */: + return this.emitFunctionPropertyAssignment(ast); + case 156 /* EmptyStatement */: + return this.writeToOutputWithSourceMapRecord(";", ast); + case 159 /* TryStatement */: + return this.emitTryStatement(ast); + case 236 /* CatchClause */: + return this.emitCatchClause(ast); + case 237 /* FinallyClause */: + return this.emitFinallyClause(ast); + case 160 /* LabeledStatement */: + return this.emitLabeledStatement(ast); + case 161 /* DoStatement */: + return this.emitDoStatement(ast); + case 171 /* TypeOfExpression */: + return this.emitTypeOfExpression(ast); + case 170 /* DeleteExpression */: + return this.emitDeleteExpression(ast); + case 172 /* VoidExpression */: + return this.emitVoidExpression(ast); + case 162 /* DebuggerStatement */: + return this.emitDebuggerStatement(ast); + } + }; + return Emitter; + })(); + TypeScript.Emitter = Emitter; + + function getLastConstructor(classDecl) { + return classDecl.classElements.lastOrDefault(function (e) { + return e.kind() === 137 /* ConstructorDeclaration */; + }); + } + TypeScript.getLastConstructor = getLastConstructor; + + function getTrimmedTextLines(comment) { + if (comment.kind() === 6 /* MultiLineCommentTrivia */) { + return comment.fullText().split("\n").map(function (s) { + return s.trim(); + }); + } else { + return [comment.fullText().trim()]; + } + } + TypeScript.getTrimmedTextLines = getTrimmedTextLines; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var MemberName = (function () { + function MemberName() { + this.prefix = ""; + this.suffix = ""; + } + MemberName.prototype.isString = function () { + return false; + }; + MemberName.prototype.isArray = function () { + return false; + }; + MemberName.prototype.isMarker = function () { + return !this.isString() && !this.isArray(); + }; + + MemberName.prototype.toString = function () { + return MemberName.memberNameToString(this); + }; + + MemberName.memberNameToString = function (memberName, markerInfo, markerBaseLength) { + if (typeof markerBaseLength === "undefined") { markerBaseLength = 0; } + var result = memberName.prefix; + + if (memberName.isString()) { + result += memberName.text; + } else if (memberName.isArray()) { + var ar = memberName; + for (var index = 0; index < ar.entries.length; index++) { + if (ar.entries[index].isMarker()) { + if (markerInfo) { + markerInfo.push(markerBaseLength + result.length); + } + continue; + } + + result += MemberName.memberNameToString(ar.entries[index], markerInfo, markerBaseLength + result.length); + result += ar.delim; + } + } + + result += memberName.suffix; + return result; + }; + + MemberName.create = function (arg1, arg2, arg3) { + if (typeof arg1 === "string") { + return new MemberNameString(arg1); + } else { + var result = new MemberNameArray(); + if (arg2) + result.prefix = arg2; + if (arg3) + result.suffix = arg3; + result.entries.push(arg1); + return result; + } + }; + return MemberName; + })(); + TypeScript.MemberName = MemberName; + + var MemberNameString = (function (_super) { + __extends(MemberNameString, _super); + function MemberNameString(text) { + _super.call(this); + this.text = text; + } + MemberNameString.prototype.isString = function () { + return true; + }; + return MemberNameString; + })(MemberName); + TypeScript.MemberNameString = MemberNameString; + + var MemberNameArray = (function (_super) { + __extends(MemberNameArray, _super); + function MemberNameArray() { + _super.call(this); + this.delim = ""; + this.entries = []; + } + MemberNameArray.prototype.isArray = function () { + return true; + }; + + MemberNameArray.prototype.add = function (entry) { + this.entries.push(entry); + }; + + MemberNameArray.prototype.addAll = function (entries) { + for (var i = 0; i < entries.length; i++) { + this.entries.push(entries[i]); + } + }; + return MemberNameArray; + })(MemberName); + TypeScript.MemberNameArray = MemberNameArray; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + function stripStartAndEndQuotes(str) { + var firstCharCode = str && str.charCodeAt(0); + if (str && str.length >= 2 && firstCharCode === str.charCodeAt(str.length - 1) && (firstCharCode === 39 /* singleQuote */ || firstCharCode === 34 /* doubleQuote */)) { + return str.substring(1, str.length - 1); + } + + return str; + } + TypeScript.stripStartAndEndQuotes = stripStartAndEndQuotes; + + function isSingleQuoted(str) { + return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 39 /* singleQuote */; + } + TypeScript.isSingleQuoted = isSingleQuoted; + + function isDoubleQuoted(str) { + return str && str.length >= 2 && str.charCodeAt(0) === str.charCodeAt(str.length - 1) && str.charCodeAt(0) === 34 /* doubleQuote */; + } + TypeScript.isDoubleQuoted = isDoubleQuoted; + + function isQuoted(str) { + return isDoubleQuoted(str) || isSingleQuoted(str); + } + TypeScript.isQuoted = isQuoted; + + function quoteStr(str) { + return "\"" + str + "\""; + } + TypeScript.quoteStr = quoteStr; + + var switchToForwardSlashesRegEx = /\\/g; + function switchToForwardSlashes(path) { + return path.replace(switchToForwardSlashesRegEx, "/"); + } + TypeScript.switchToForwardSlashes = switchToForwardSlashes; + + function trimModName(modName) { + if (modName.length > 5 && modName.substring(modName.length - 5, modName.length) === ".d.ts") { + return modName.substring(0, modName.length - 5); + } + if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".ts") { + return modName.substring(0, modName.length - 3); + } + + if (modName.length > 3 && modName.substring(modName.length - 3, modName.length) === ".js") { + return modName.substring(0, modName.length - 3); + } + + return modName; + } + TypeScript.trimModName = trimModName; + + function getDeclareFilePath(fname) { + return isTSFile(fname) ? changePathToDTS(fname) : changePathToDTS(fname); + } + TypeScript.getDeclareFilePath = getDeclareFilePath; + + function isFileOfExtension(fname, ext) { + var invariantFname = fname.toLocaleUpperCase(); + var invariantExt = ext.toLocaleUpperCase(); + var extLength = invariantExt.length; + return invariantFname.length > extLength && invariantFname.substring(invariantFname.length - extLength, invariantFname.length) === invariantExt; + } + + function isTSFile(fname) { + return isFileOfExtension(fname, ".ts"); + } + TypeScript.isTSFile = isTSFile; + + function isDTSFile(fname) { + return isFileOfExtension(fname, ".d.ts"); + } + TypeScript.isDTSFile = isDTSFile; + + function getPrettyName(modPath, quote, treatAsFileName) { + if (typeof quote === "undefined") { quote = true; } + if (typeof treatAsFileName === "undefined") { treatAsFileName = false; } + var modName = treatAsFileName ? switchToForwardSlashes(modPath) : trimModName(stripStartAndEndQuotes(modPath)); + var components = this.getPathComponents(modName); + return components.length ? (quote ? quoteStr(components[components.length - 1]) : components[components.length - 1]) : modPath; + } + TypeScript.getPrettyName = getPrettyName; + + function getPathComponents(path) { + return path.split("/"); + } + TypeScript.getPathComponents = getPathComponents; + + function getRelativePathToFixedPath(fixedModFilePath, absoluteModPath, isAbsoultePathURL) { + if (typeof isAbsoultePathURL === "undefined") { isAbsoultePathURL = true; } + absoluteModPath = switchToForwardSlashes(absoluteModPath); + + var modComponents = this.getPathComponents(absoluteModPath); + var fixedModComponents = this.getPathComponents(fixedModFilePath); + + var joinStartIndex = 0; + for (; joinStartIndex < modComponents.length && joinStartIndex < fixedModComponents.length; joinStartIndex++) { + if (fixedModComponents[joinStartIndex] !== modComponents[joinStartIndex]) { + break; + } + } + + if (joinStartIndex !== 0) { + var relativePath = ""; + var relativePathComponents = modComponents.slice(joinStartIndex, modComponents.length); + for (; joinStartIndex < fixedModComponents.length; joinStartIndex++) { + if (fixedModComponents[joinStartIndex] !== "") { + relativePath = relativePath + "../"; + } + } + + return relativePath + relativePathComponents.join("/"); + } + + if (isAbsoultePathURL && absoluteModPath.indexOf("://") === -1) { + absoluteModPath = "file:///" + absoluteModPath; + } + + return absoluteModPath; + } + TypeScript.getRelativePathToFixedPath = getRelativePathToFixedPath; + + function changePathToDTS(modPath) { + return trimModName(stripStartAndEndQuotes(modPath)) + ".d.ts"; + } + TypeScript.changePathToDTS = changePathToDTS; + + function isRelative(path) { + return path.length > 0 && path.charAt(0) === "."; + } + TypeScript.isRelative = isRelative; + function isRooted(path) { + return path.length > 0 && (path.charAt(0) === "\\" || path.charAt(0) === "/" || (path.indexOf(":\\") !== -1) || (path.indexOf(":/") !== -1)); + } + TypeScript.isRooted = isRooted; + + function getRootFilePath(outFname) { + if (outFname === "") { + return outFname; + } else { + var isPath = outFname.indexOf("/") !== -1; + return isPath ? filePath(outFname) : ""; + } + } + TypeScript.getRootFilePath = getRootFilePath; + + function filePathComponents(fullPath) { + fullPath = switchToForwardSlashes(fullPath); + var components = getPathComponents(fullPath); + return components.slice(0, components.length - 1); + } + TypeScript.filePathComponents = filePathComponents; + + function filePath(fullPath) { + var path = filePathComponents(fullPath); + return path.join("/") + "/"; + } + TypeScript.filePath = filePath; + + function convertToDirectoryPath(dirPath) { + if (dirPath && dirPath.charAt(dirPath.length - 1) !== "/") { + dirPath += "/"; + } + + return dirPath; + } + TypeScript.convertToDirectoryPath = convertToDirectoryPath; + + var normalizePathRegEx = /^\\\\[^\\]/; + function normalizePath(path) { + if (normalizePathRegEx.test(path)) { + path = "file:" + path; + } + var parts = this.getPathComponents(switchToForwardSlashes(path)); + var normalizedParts = []; + + for (var i = 0; i < parts.length; i++) { + var part = parts[i]; + if (part === ".") { + continue; + } + + if (normalizedParts.length > 0 && TypeScript.ArrayUtilities.last(normalizedParts) !== ".." && part === "..") { + normalizedParts.pop(); + continue; + } + + normalizedParts.push(part); + } + + return normalizedParts.join("/"); + } + TypeScript.normalizePath = normalizePath; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + + + function isNoDefaultLibMatch(comment) { + var isNoDefaultLibRegex = /^(\/\/\/\s*/gim; + return isNoDefaultLibRegex.exec(comment); + } + + TypeScript.tripleSlashReferenceRegExp = /^(\/\/\/\s*/; + + function getFileReferenceFromReferencePath(fileName, lineMap, position, comment, diagnostics) { + var simpleReferenceRegEx = /^\/\/\/\s*= 7 && fullReference[6] === "true"; + if (isResident) { + TypeScript.CompilerDiagnostics.debugPrint(path + " is resident"); + } + return { + line: 0, + character: 0, + position: 0, + length: 0, + path: TypeScript.switchToForwardSlashes(adjustedPath), + isResident: isResident + }; + } + } + } + + return null; + } + + var scannerWindow = TypeScript.ArrayUtilities.createArray(2048, 0); + var scannerDiagnostics = []; + + function processImports(lineMap, scanner, token, importedFiles) { + var position = 0; + var lineChar = { line: -1, character: -1 }; + + var start = new Date().getTime(); + + while (token.tokenKind !== 10 /* EndOfFileToken */) { + if (token.tokenKind === 49 /* ImportKeyword */) { + var importStart = position + token.leadingTriviaWidth(); + token = scanner.scan(scannerDiagnostics, false); + + if (TypeScript.SyntaxFacts.isIdentifierNameOrAnyKeyword(token)) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 107 /* EqualsToken */) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 65 /* ModuleKeyword */ || token.tokenKind === 66 /* RequireKeyword */) { + token = scanner.scan(scannerDiagnostics, false); + + if (token.tokenKind === 72 /* OpenParenToken */) { + var afterOpenParenPosition = scanner.absoluteIndex(); + token = scanner.scan(scannerDiagnostics, false); + + lineMap.fillLineAndCharacterFromPosition(importStart, lineChar); + + if (token.tokenKind === 14 /* StringLiteral */) { + var ref = { + line: lineChar.line, + character: lineChar.character, + position: afterOpenParenPosition + token.leadingTriviaWidth(), + length: token.width(), + path: TypeScript.stripStartAndEndQuotes(TypeScript.switchToForwardSlashes(token.text())), + isResident: false + }; + importedFiles.push(ref); + } + } + } + } + } + } + + position = scanner.absoluteIndex(); + token = scanner.scan(scannerDiagnostics, false); + } + + var totalTime = new Date().getTime() - start; + TypeScript.fileResolutionScanImportsTime += totalTime; + } + + function processTripleSlashDirectives(fileName, lineMap, firstToken) { + var leadingTrivia = firstToken.leadingTrivia(); + + var position = 0; + var lineChar = { line: -1, character: -1 }; + var noDefaultLib = false; + var diagnostics = []; + var referencedFiles = []; + + for (var i = 0, n = leadingTrivia.count(); i < n; i++) { + var trivia = leadingTrivia.syntaxTriviaAt(i); + + if (trivia.kind() === 7 /* SingleLineCommentTrivia */) { + var triviaText = trivia.fullText(); + var referencedCode = getFileReferenceFromReferencePath(fileName, lineMap, position, triviaText, diagnostics); + + if (referencedCode) { + lineMap.fillLineAndCharacterFromPosition(position, lineChar); + referencedCode.position = position; + referencedCode.length = trivia.fullWidth(); + referencedCode.line = lineChar.line; + referencedCode.character = lineChar.character; + + referencedFiles.push(referencedCode); + } + + var isNoDefaultLib = isNoDefaultLibMatch(triviaText); + if (isNoDefaultLib) { + noDefaultLib = isNoDefaultLib[3] === "true"; + } + } + + position += trivia.fullWidth(); + } + + return { noDefaultLib: noDefaultLib, diagnostics: diagnostics, referencedFiles: referencedFiles }; + } + + function preProcessFile(fileName, sourceText, readImportFiles) { + if (typeof readImportFiles === "undefined") { readImportFiles = true; } + var text = TypeScript.SimpleText.fromScriptSnapshot(sourceText); + var scanner = new TypeScript.Scanner(fileName, text, 1 /* EcmaScript5 */, scannerWindow); + + var firstToken = scanner.scan(scannerDiagnostics, false); + + var importedFiles = []; + if (readImportFiles) { + processImports(text.lineMap(), scanner, firstToken, importedFiles); + } + + var properties = processTripleSlashDirectives(fileName, text.lineMap(), firstToken); + + scannerDiagnostics.length = 0; + return { referencedFiles: properties.referencedFiles, importedFiles: importedFiles, isLibFile: properties.noDefaultLib, diagnostics: properties.diagnostics }; + } + TypeScript.preProcessFile = preProcessFile; + + function getParseOptions(settings) { + return new TypeScript.ParseOptions(settings.codeGenTarget(), settings.allowAutomaticSemicolonInsertion()); + } + TypeScript.getParseOptions = getParseOptions; + + function getReferencedFiles(fileName, sourceText) { + return preProcessFile(fileName, sourceText, false).referencedFiles; + } + TypeScript.getReferencedFiles = getReferencedFiles; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ReferenceResolutionResult = (function () { + function ReferenceResolutionResult() { + this.resolvedFiles = []; + this.diagnostics = []; + this.seenNoDefaultLibTag = false; + } + return ReferenceResolutionResult; + })(); + TypeScript.ReferenceResolutionResult = ReferenceResolutionResult; + + var ReferenceLocation = (function () { + function ReferenceLocation(filePath, lineMap, position, length, isImported) { + this.filePath = filePath; + this.lineMap = lineMap; + this.position = position; + this.length = length; + this.isImported = isImported; + } + return ReferenceLocation; + })(); + + var ReferenceResolver = (function () { + function ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution) { + this.useCaseSensitiveFileResolution = useCaseSensitiveFileResolution; + this.inputFileNames = inputFileNames; + this.host = host; + this.visited = {}; + } + ReferenceResolver.resolve = function (inputFileNames, host, useCaseSensitiveFileResolution) { + var resolver = new ReferenceResolver(inputFileNames, host, useCaseSensitiveFileResolution); + return resolver.resolveInputFiles(); + }; + + ReferenceResolver.prototype.resolveInputFiles = function () { + var _this = this; + var result = new ReferenceResolutionResult(); + + if (!this.inputFileNames || this.inputFileNames.length <= 0) { + return result; + } + + var referenceLocation = new ReferenceLocation(null, null, 0, 0, false); + this.inputFileNames.forEach(function (fileName) { + return _this.resolveIncludedFile(fileName, referenceLocation, result); + }); + + return result; + }; + + ReferenceResolver.prototype.resolveIncludedFile = function (path, referenceLocation, resolutionResult) { + var normalizedPath = this.getNormalizedFilePath(path, referenceLocation.filePath); + + if (this.isSameFile(normalizedPath, referenceLocation.filePath)) { + if (!referenceLocation.isImported) { + resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.A_file_cannot_have_a_reference_to_itself, null)); + } + + return normalizedPath; + } + + if (!TypeScript.isTSFile(normalizedPath) && !TypeScript.isDTSFile(normalizedPath)) { + var dtsFile = normalizedPath + ".d.ts"; + var tsFile = normalizedPath + ".ts"; + + if (this.host.fileExists(dtsFile)) { + normalizedPath = dtsFile; + } else { + normalizedPath = tsFile; + } + } + + if (!this.host.fileExists(normalizedPath)) { + if (!referenceLocation.isImported) { + resolutionResult.diagnostics.push(new TypeScript.Diagnostic(referenceLocation.filePath, referenceLocation.lineMap, referenceLocation.position, referenceLocation.length, TypeScript.DiagnosticCode.Cannot_resolve_referenced_file_0, [path])); + } + + return normalizedPath; + } + + return this.resolveFile(normalizedPath, resolutionResult); + }; + + ReferenceResolver.prototype.resolveImportedFile = function (path, referenceLocation, resolutionResult) { + var isRelativePath = TypeScript.isRelative(path); + var isRootedPath = isRelativePath ? false : TypeScript.isRooted(path); + + if (isRelativePath || isRootedPath) { + return this.resolveIncludedFile(path, referenceLocation, resolutionResult); + } else { + var parentDirectory = this.host.getParentDirectory(referenceLocation.filePath); + var searchFilePath = null; + var dtsFileName = path + ".d.ts"; + var tsFilePath = path + ".ts"; + + var start = new Date().getTime(); + + do { + var currentFilePath = this.host.resolveRelativePath(dtsFileName, parentDirectory); + if (this.host.fileExists(currentFilePath)) { + searchFilePath = currentFilePath; + break; + } + + currentFilePath = this.host.resolveRelativePath(tsFilePath, parentDirectory); + if (this.host.fileExists(currentFilePath)) { + searchFilePath = currentFilePath; + break; + } + + parentDirectory = this.host.getParentDirectory(parentDirectory); + } while(parentDirectory); + + TypeScript.fileResolutionImportFileSearchTime += new Date().getTime() - start; + + if (!searchFilePath) { + return path; + } + + return this.resolveFile(searchFilePath, resolutionResult); + } + }; + + ReferenceResolver.prototype.resolveFile = function (normalizedPath, resolutionResult) { + var _this = this; + var visitedPath = this.isVisited(normalizedPath); + if (!visitedPath) { + this.recordVisitedFile(normalizedPath); + + var start = new Date().getTime(); + var scriptSnapshot = this.host.getScriptSnapshot(normalizedPath); + var totalTime = new Date().getTime() - start; + TypeScript.fileResolutionIOTime += totalTime; + + var lineMap = TypeScript.LineMap1.fromScriptSnapshot(scriptSnapshot); + var preprocessedFileInformation = TypeScript.preProcessFile(normalizedPath, scriptSnapshot); + resolutionResult.diagnostics.push.apply(resolutionResult.diagnostics, preprocessedFileInformation.diagnostics); + + if (preprocessedFileInformation.isLibFile) { + resolutionResult.seenNoDefaultLibTag = true; + } + + var normalizedReferencePaths = []; + preprocessedFileInformation.referencedFiles.forEach(function (fileReference) { + var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileReference.position, fileReference.length, false); + var normalizedReferencePath = _this.resolveIncludedFile(fileReference.path, currentReferenceLocation, resolutionResult); + normalizedReferencePaths.push(normalizedReferencePath); + }); + + var normalizedImportPaths = []; + for (var i = 0; i < preprocessedFileInformation.importedFiles.length; i++) { + var fileImport = preprocessedFileInformation.importedFiles[i]; + var currentReferenceLocation = new ReferenceLocation(normalizedPath, lineMap, fileImport.position, fileImport.length, true); + var normalizedImportPath = this.resolveImportedFile(fileImport.path, currentReferenceLocation, resolutionResult); + normalizedImportPaths.push(normalizedImportPath); + } + + resolutionResult.resolvedFiles.push({ + path: normalizedPath, + referencedFiles: normalizedReferencePaths, + importedFiles: normalizedImportPaths + }); + } else { + normalizedPath = visitedPath; + } + + return normalizedPath; + }; + + ReferenceResolver.prototype.getNormalizedFilePath = function (path, parentFilePath) { + var parentFileDirectory = parentFilePath ? this.host.getParentDirectory(parentFilePath) : ""; + var normalizedPath = this.host.resolveRelativePath(path, parentFileDirectory); + return normalizedPath; + }; + + ReferenceResolver.prototype.getUniqueFileId = function (filePath) { + return this.useCaseSensitiveFileResolution ? filePath : filePath.toLocaleUpperCase(); + }; + + ReferenceResolver.prototype.recordVisitedFile = function (filePath) { + this.visited[this.getUniqueFileId(filePath)] = filePath; + }; + + ReferenceResolver.prototype.isVisited = function (filePath) { + return this.visited[this.getUniqueFileId(filePath)]; + }; + + ReferenceResolver.prototype.isSameFile = function (filePath1, filePath2) { + if (!filePath1 || !filePath2) { + return false; + } + + if (this.useCaseSensitiveFileResolution) { + return filePath1 === filePath2; + } else { + return filePath1.toLocaleUpperCase() === filePath2.toLocaleUpperCase(); + } + }; + return ReferenceResolver; + })(); + TypeScript.ReferenceResolver = ReferenceResolver; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var TextWriter = (function () { + function TextWriter(name, writeByteOrderMark, outputFileType) { + this.name = name; + this.writeByteOrderMark = writeByteOrderMark; + this.outputFileType = outputFileType; + this.contents = ""; + this.onNewLine = true; + } + TextWriter.prototype.Write = function (s) { + this.contents += s; + this.onNewLine = false; + }; + + TextWriter.prototype.WriteLine = function (s) { + this.contents += s; + this.contents += TypeScript.newLine(); + this.onNewLine = true; + }; + + TextWriter.prototype.Close = function () { + }; + + TextWriter.prototype.getOutputFile = function () { + return new TypeScript.OutputFile(this.name, this.writeByteOrderMark, this.contents, this.outputFileType); + }; + return TextWriter; + })(); + TypeScript.TextWriter = TextWriter; + + var DeclarationEmitter = (function () { + function DeclarationEmitter(emittingFileName, document, compiler, emitOptions, semanticInfoChain) { + this.emittingFileName = emittingFileName; + this.document = document; + this.compiler = compiler; + this.emitOptions = emitOptions; + this.semanticInfoChain = semanticInfoChain; + this.declFile = null; + this.indenter = new TypeScript.Indenter(); + this.emittedReferencePaths = false; + this.declFile = new TextWriter(emittingFileName, this.document.byteOrderMark !== 0 /* None */, 2 /* Declaration */); + } + DeclarationEmitter.prototype.getOutputFile = function () { + return this.declFile.getOutputFile(); + }; + + DeclarationEmitter.prototype.emitDeclarations = function (sourceUnit) { + this.emitDeclarationsForSourceUnit(sourceUnit); + }; + + DeclarationEmitter.prototype.emitDeclarationsForList = function (list) { + for (var i = 0, n = list.childCount(); i < n; i++) { + this.emitDeclarationsForAST(list.childAt(i)); + } + }; + + DeclarationEmitter.prototype.emitSeparatedList = function (list) { + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + this.emitDeclarationsForAST(list.nonSeparatorAt(i)); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForAST = function (ast) { + switch (ast.kind()) { + case 148 /* VariableStatement */: + return this.emitDeclarationsForVariableStatement(ast); + case 141 /* PropertySignature */: + return this.emitPropertySignature(ast); + case 225 /* VariableDeclarator */: + return this.emitVariableDeclarator(ast, true, true); + case 136 /* MemberVariableDeclaration */: + return this.emitDeclarationsForMemberVariableDeclaration(ast); + case 137 /* ConstructorDeclaration */: + return this.emitDeclarationsForConstructorDeclaration(ast); + case 139 /* GetAccessor */: + return this.emitDeclarationsForGetAccessor(ast); + case 140 /* SetAccessor */: + return this.emitDeclarationsForSetAccessor(ast); + case 138 /* IndexMemberDeclaration */: + return this.emitIndexMemberDeclaration(ast); + case 144 /* IndexSignature */: + return this.emitIndexSignature(ast); + case 142 /* CallSignature */: + return this.emitCallSignature(ast); + case 143 /* ConstructSignature */: + return this.emitConstructSignature(ast); + case 145 /* MethodSignature */: + return this.emitMethodSignature(ast); + case 129 /* FunctionDeclaration */: + return this.emitDeclarationsForFunctionDeclaration(ast); + case 135 /* MemberFunctionDeclaration */: + return this.emitMemberFunctionDeclaration(ast); + case 131 /* ClassDeclaration */: + return this.emitDeclarationsForClassDeclaration(ast); + case 128 /* InterfaceDeclaration */: + return this.emitDeclarationsForInterfaceDeclaration(ast); + case 133 /* ImportDeclaration */: + return this.emitDeclarationsForImportDeclaration(ast); + case 130 /* ModuleDeclaration */: + return this.emitDeclarationsForModuleDeclaration(ast); + case 132 /* EnumDeclaration */: + return this.emitDeclarationsForEnumDeclaration(ast); + case 134 /* ExportAssignment */: + return this.emitDeclarationsForExportAssignment(ast); + } + }; + + DeclarationEmitter.prototype.getIndentString = function (declIndent) { + if (typeof declIndent === "undefined") { declIndent = false; } + return this.indenter.getIndent(); + }; + + DeclarationEmitter.prototype.emitIndent = function () { + this.declFile.Write(this.getIndentString()); + }; + + DeclarationEmitter.prototype.canEmitDeclarations = function (declAST) { + var container = this.getEnclosingContainer(declAST); + if (container.kind() === 130 /* ModuleDeclaration */ || container.kind() === 120 /* SourceUnit */) { + var pullDecl = this.semanticInfoChain.getDeclForAST(declAST); + if (!TypeScript.hasFlag(pullDecl.flags, 1 /* Exported */)) { + var start = new Date().getTime(); + var declSymbol = this.semanticInfoChain.getSymbolForAST(declAST); + var result = declSymbol && declSymbol.isExternallyVisible(); + TypeScript.declarationEmitIsExternallyVisibleTime += new Date().getTime() - start; + + return result; + } + } + + return true; + }; + + DeclarationEmitter.prototype.getDeclFlagsString = function (pullDecl, typeString) { + var result = this.getIndentString(); + var pullFlags = pullDecl.flags; + + if (TypeScript.hasFlag(pullFlags, 16 /* Static */)) { + if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) { + result += "private "; + } + result += "static "; + } else { + if (TypeScript.hasFlag(pullFlags, 2 /* Private */)) { + result += "private "; + } else if (TypeScript.hasFlag(pullFlags, 4 /* Public */)) { + result += "public "; + } else { + var emitDeclare = !TypeScript.hasFlag(pullFlags, 1 /* Exported */); + + var declAST = this.semanticInfoChain.getASTForDecl(pullDecl); + var container = this.getEnclosingContainer(declAST); + + if (container.kind() === 130 /* ModuleDeclaration */ && TypeScript.isAnyNameOfModule(container, declAST)) { + container = this.getEnclosingContainer(container); + } + + var isExternalModule = container.kind() === 120 /* SourceUnit */ && this.document.isExternalModule(); + + if (isExternalModule && TypeScript.hasFlag(pullFlags, 1 /* Exported */)) { + result += "export "; + emitDeclare = true; + } + + if (isExternalModule || container.kind() == 120 /* SourceUnit */) { + if (emitDeclare && typeString !== "interface" && typeString != "import") { + result += "declare "; + } + } + + result += typeString + " "; + } + } + + return result; + }; + + DeclarationEmitter.prototype.emitDeclFlags = function (declarationAST, typeString) { + this.declFile.Write(this.getDeclFlagsString(this.semanticInfoChain.getDeclForAST(declarationAST), typeString)); + }; + + DeclarationEmitter.prototype.emitTypeNamesMember = function (memberName, emitIndent) { + if (typeof emitIndent === "undefined") { emitIndent = false; } + if (memberName.prefix === "{ ") { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.WriteLine("{"); + this.indenter.increaseIndent(); + emitIndent = true; + } else if (memberName.prefix !== "") { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.Write(memberName.prefix); + emitIndent = false; + } + + if (memberName.isString()) { + if (emitIndent) { + this.emitIndent(); + } + + this.declFile.Write(memberName.text); + } else if (memberName.isArray()) { + var ar = memberName; + for (var index = 0; index < ar.entries.length; index++) { + this.emitTypeNamesMember(ar.entries[index], emitIndent); + if (ar.delim === "; ") { + this.declFile.WriteLine(";"); + } + } + } + + if (memberName.suffix === "}") { + this.indenter.decreaseIndent(); + this.emitIndent(); + this.declFile.Write(memberName.suffix); + } else { + this.declFile.Write(memberName.suffix); + } + }; + + DeclarationEmitter.prototype.emitTypeSignature = function (ast, type) { + var declarationContainerAst = this.getEnclosingContainer(ast); + + var start = new Date().getTime(); + var declarationContainerDecl = this.semanticInfoChain.getDeclForAST(declarationContainerAst); + + var declarationPullSymbol = declarationContainerDecl.getSymbol(); + TypeScript.declarationEmitTypeSignatureTime += new Date().getTime() - start; + + var typeNameMembers = type.getScopedNameEx(declarationPullSymbol); + this.emitTypeNamesMember(typeNameMembers); + }; + + DeclarationEmitter.prototype.emitComment = function (comment) { + var text = TypeScript.getTrimmedTextLines(comment); + if (this.declFile.onNewLine) { + this.emitIndent(); + } else if (comment.kind() !== 6 /* MultiLineCommentTrivia */) { + this.declFile.WriteLine(""); + this.emitIndent(); + } + + this.declFile.Write(text[0]); + + for (var i = 1; i < text.length; i++) { + this.declFile.WriteLine(""); + this.emitIndent(); + this.declFile.Write(text[i]); + } + + if (comment.endsLine || comment.kind() !== 6 /* MultiLineCommentTrivia */) { + this.declFile.WriteLine(""); + } else { + this.declFile.Write(" "); + } + }; + + DeclarationEmitter.prototype.emitDeclarationComments = function (astOrSymbol, endLine) { + if (typeof endLine === "undefined") { endLine = true; } + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var declComments = astOrSymbol.docComments ? astOrSymbol.docComments() : TypeScript.docComments(astOrSymbol); + this.writeDeclarationComments(declComments, endLine); + }; + + DeclarationEmitter.prototype.writeDeclarationComments = function (declComments, endLine) { + if (typeof endLine === "undefined") { endLine = true; } + if (declComments.length > 0) { + for (var i = 0; i < declComments.length; i++) { + this.emitComment(declComments[i]); + } + + if (endLine) { + if (!this.declFile.onNewLine) { + this.declFile.WriteLine(""); + } + } else { + if (this.declFile.onNewLine) { + this.emitIndent(); + } + } + } + }; + + DeclarationEmitter.prototype.emitTypeOfVariableDeclaratorOrParameter = function (boundDecl) { + var start = new Date().getTime(); + var decl = this.semanticInfoChain.getDeclForAST(boundDecl); + var pullSymbol = decl.getSymbol(); + TypeScript.declarationEmitGetBoundDeclTypeTime += new Date().getTime() - start; + + var type = pullSymbol.type; + TypeScript.Debug.assert(type); + + this.declFile.Write(": "); + this.emitTypeSignature(boundDecl, type); + }; + + DeclarationEmitter.prototype.emitPropertySignature = function (varDecl) { + this.emitDeclarationComments(varDecl); + this.emitIndent(); + this.declFile.Write(varDecl.propertyName.text()); + if (varDecl.questionToken) { + this.declFile.Write("?"); + } + + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitVariableDeclarator = function (varDecl, isFirstVarInList, isLastVarInList) { + if (this.canEmitDeclarations(varDecl)) { + this.emitDeclarationComments(varDecl); + + if (isFirstVarInList) { + this.emitDeclFlags(varDecl, "var"); + } + + this.declFile.Write(varDecl.propertyName.text()); + + if (!TypeScript.hasModifier(TypeScript.getVariableDeclaratorModifiers(varDecl), 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + } + + if (isLastVarInList) { + this.declFile.WriteLine(";"); + } else { + this.declFile.Write(", "); + } + } + }; + + DeclarationEmitter.prototype.emitClassElementModifiers = function (modifiers) { + if (TypeScript.hasModifier(modifiers, 16 /* Static */)) { + if (TypeScript.hasModifier(modifiers, 2 /* Private */)) { + this.declFile.Write("private "); + } + this.declFile.Write("static "); + } else { + if (TypeScript.hasModifier(modifiers, 2 /* Private */)) { + this.declFile.Write("private "); + } else { + this.declFile.Write("public "); + } + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForMemberVariableDeclaration = function (varDecl) { + if (this.canEmitDeclarations(varDecl)) { + this.emitDeclarationComments(varDecl); + + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(varDecl.modifiers); + ; + + this.declFile.Write(varDecl.variableDeclarator.propertyName.text()); + + if (!TypeScript.hasModifier(varDecl.modifiers, 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(varDecl); + } + + this.declFile.WriteLine(";"); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForVariableStatement = function (variableStatement) { + this.emitDeclarationsForVariableDeclaration(variableStatement.declaration); + }; + + DeclarationEmitter.prototype.emitDeclarationsForVariableDeclaration = function (variableDeclaration) { + var varListCount = variableDeclaration.declarators.nonSeparatorCount(); + for (var i = 0; i < varListCount; i++) { + this.emitVariableDeclarator(variableDeclaration.declarators.nonSeparatorAt(i), i == 0, i == varListCount - 1); + } + }; + + DeclarationEmitter.prototype.emitArgDecl = function (argDecl, id, isOptional, isPrivate) { + this.indenter.increaseIndent(); + + this.emitDeclarationComments(argDecl, false); + this.declFile.Write(id.text()); + if (isOptional) { + this.declFile.Write("?"); + } + + this.indenter.decreaseIndent(); + + if (!isPrivate) { + this.emitTypeOfVariableDeclaratorOrParameter(argDecl); + } + }; + + DeclarationEmitter.prototype.isOverloadedCallSignature = function (funcDecl) { + var start = new Date().getTime(); + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSymbol = functionDecl.getSymbol(); + TypeScript.declarationEmitIsOverloadedCallSignatureTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + var signatures = funcTypeSymbol.getCallSignatures(); + var result = signatures && signatures.length > 1; + + return result; + }; + + DeclarationEmitter.prototype.emitDeclarationsForConstructorDeclaration = function (funcDecl) { + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + if (funcDecl.block) { + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } + } + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("constructor"); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.parameterList)); + this.declFile.Write(")"); + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitParameterList = function (isPrivate, parameterList) { + this.declFile.Write("("); + this.emitParameters(isPrivate, TypeScript.Parameters.fromParameterList(parameterList)); + this.declFile.Write(")"); + }; + + DeclarationEmitter.prototype.emitParameters = function (isPrivate, parameterList) { + var hasLastParameterRestParameter = parameterList.lastParameterIsRest(); + var argsLen = parameterList.length; + if (hasLastParameterRestParameter) { + argsLen--; + } + + for (var i = 0; i < argsLen; i++) { + this.emitArgDecl(parameterList.astAt(i), parameterList.identifierAt(i), parameterList.isOptionalAt(i), isPrivate); + if (i < (argsLen - 1)) { + this.declFile.Write(", "); + } + } + + if (hasLastParameterRestParameter) { + if (parameterList.length > 1) { + this.declFile.Write(", ..."); + } else { + this.declFile.Write("..."); + } + + var index = parameterList.length - 1; + this.emitArgDecl(parameterList.astAt(index), parameterList.identifierAt(index), parameterList.isOptionalAt(index), isPrivate); + } + }; + + DeclarationEmitter.prototype.emitMemberFunctionDeclaration = function (funcDecl) { + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + var funcTypeSymbol = funcSymbol.type; + if (funcDecl.block) { + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } else if (this.isOverloadedCallSignature(funcDecl)) { + return; + } + } else if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */) && this.isOverloadedCallSignature(funcDecl)) { + var callSignatures = funcTypeSymbol.getCallSignatures(); + TypeScript.Debug.assert(callSignatures && callSignatures.length > 1); + var firstSignature = callSignatures[0].isDefinition() ? callSignatures[1] : callSignatures[0]; + var firstSignatureDecl = firstSignature.getDeclarations()[0]; + var firstFuncDecl = this.semanticInfoChain.getASTForDecl(firstSignatureDecl); + if (firstFuncDecl !== funcDecl) { + return; + } + } + + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitDeclarationComments(funcDecl); + + this.emitDeclFlags(funcDecl, "function"); + var id = funcDecl.propertyName.text(); + this.declFile.Write(id); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + var isPrivate = TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */); + + this.emitParameterList(isPrivate, funcDecl.callSignature.parameterList); + + if (!isPrivate) { + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + this.emitTypeSignature(funcDecl, returnType); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitCallSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + this.emitDeclarationComments(funcDecl); + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.typeParameterList, funcSignature); + + this.emitIndent(); + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitConstructSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("new"); + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitMethodSignature = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write(funcDecl.propertyName.text()); + if (funcDecl.questionToken) { + this.declFile.Write("? "); + } + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForFunctionDeclaration = function (funcDecl) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + + var start = new Date().getTime(); + var funcSymbol = this.semanticInfoChain.getSymbolForAST(funcDecl); + + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime += new Date().getTime() - start; + + if (funcDecl.block) { + var funcTypeSymbol = funcSymbol.type; + var constructSignatures = funcTypeSymbol.getConstructSignatures(); + if (constructSignatures && constructSignatures.length > 1) { + return; + } else if (this.isOverloadedCallSignature(funcDecl)) { + return; + } + } + + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + this.emitDeclarationComments(funcDecl); + + var id = funcDecl.identifier.text(); + this.emitDeclFlags(funcDecl, "function"); + if (id !== "" || !funcDecl.identifier || funcDecl.identifier.text().length > 0) { + this.declFile.Write(id); + } else if (funcPullDecl.kind === 2097152 /* ConstructSignature */) { + this.declFile.Write("new"); + } + + var funcSignature = funcPullDecl.getSignatureSymbol(); + this.emitTypeParameters(funcDecl.callSignature.typeParameterList, funcSignature); + + this.declFile.Write("("); + this.emitParameters(false, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList)); + this.declFile.Write(")"); + + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + if (returnType) { + this.emitTypeSignature(funcDecl, returnType); + } else { + this.declFile.Write("any"); + } + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitIndexMemberDeclaration = function (funcDecl) { + this.emitDeclarationsForAST(funcDecl.indexSignature); + }; + + DeclarationEmitter.prototype.emitIndexSignature = function (funcDecl) { + if (!this.canEmitDeclarations(funcDecl)) { + return; + } + + this.emitDeclarationComments(funcDecl); + + this.emitIndent(); + this.declFile.Write("["); + this.emitParameters(false, TypeScript.Parameters.fromParameter(funcDecl.parameter)); + this.declFile.Write("]"); + + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSignature = funcPullDecl.getSignatureSymbol(); + var returnType = funcSignature.returnType; + this.declFile.Write(": "); + this.emitTypeSignature(funcDecl, returnType); + + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitBaseList = function (bases, useExtendsList) { + if (bases && (bases.nonSeparatorCount() > 0)) { + var qual = useExtendsList ? "extends" : "implements"; + this.declFile.Write(" " + qual + " "); + var basesLen = bases.nonSeparatorCount(); + for (var i = 0; i < basesLen; i++) { + if (i > 0) { + this.declFile.Write(", "); + } + var base = bases.nonSeparatorAt(i); + var baseType = this.semanticInfoChain.getSymbolForAST(base); + this.emitTypeSignature(base, baseType); + } + } + }; + + DeclarationEmitter.prototype.emitAccessorDeclarationComments = function (funcDecl) { + if (this.emitOptions.compilationSettings().removeComments()) { + return; + } + + var start = new Date().getTime(); + var accessors = TypeScript.PullHelpers.getGetterAndSetterFunction(funcDecl, this.semanticInfoChain); + TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime(); + + var comments = []; + if (accessors.getter) { + comments = comments.concat(TypeScript.docComments(accessors.getter)); + } + if (accessors.setter) { + comments = comments.concat(TypeScript.docComments(accessors.setter)); + } + + this.writeDeclarationComments(comments); + }; + + DeclarationEmitter.prototype.emitDeclarationsForGetAccessor = function (funcDecl) { + this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName); + }; + + DeclarationEmitter.prototype.emitDeclarationsForSetAccessor = function (funcDecl) { + this.emitMemberAccessorDeclaration(funcDecl, funcDecl.modifiers, funcDecl.propertyName); + }; + + DeclarationEmitter.prototype.emitMemberAccessorDeclaration = function (funcDecl, modifiers, name) { + var start = new Date().getTime(); + var accessorSymbol = TypeScript.PullHelpers.getAccessorSymbol(funcDecl, this.semanticInfoChain); + TypeScript.declarationEmitGetAccessorFunctionTime += new Date().getTime(); + + if (funcDecl.kind() === 140 /* SetAccessor */ && accessorSymbol.getGetter()) { + return; + } + + var isPrivate = TypeScript.hasModifier(modifiers, 2 /* Private */); + this.emitAccessorDeclarationComments(funcDecl); + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(modifiers); + this.declFile.Write(name.text()); + if (!isPrivate) { + this.declFile.Write(" : "); + var type = accessorSymbol.type; + this.emitTypeSignature(funcDecl, type); + } + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.emitClassMembersFromConstructorDefinition = function (funcDecl) { + if (funcDecl.parameterList) { + var argsLen = funcDecl.parameterList.parameters.nonSeparatorCount(); + if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) { + argsLen--; + } + + for (var i = 0; i < argsLen; i++) { + var parameter = funcDecl.parameterList.parameters.nonSeparatorAt(i); + var parameterDecl = this.semanticInfoChain.getDeclForAST(parameter); + if (TypeScript.hasFlag(parameterDecl.flags, 8388608 /* PropertyParameter */)) { + var funcPullDecl = this.semanticInfoChain.getDeclForAST(funcDecl); + this.emitDeclarationComments(parameter); + this.declFile.Write(this.getIndentString()); + this.emitClassElementModifiers(parameter.modifiers); + this.declFile.Write(parameter.identifier.text()); + + if (!TypeScript.hasModifier(parameter.modifiers, 2 /* Private */)) { + this.emitTypeOfVariableDeclaratorOrParameter(parameter); + } + this.declFile.WriteLine(";"); + } + } + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForClassDeclaration = function (classDecl) { + if (!this.canEmitDeclarations(classDecl)) { + return; + } + + var className = classDecl.identifier.text(); + this.emitDeclarationComments(classDecl); + var classPullDecl = this.semanticInfoChain.getDeclForAST(classDecl); + this.emitDeclFlags(classDecl, "class"); + this.declFile.Write(className); + + this.emitTypeParameters(classDecl.typeParameterList); + this.emitHeritageClauses(classDecl.heritageClauses); + this.declFile.WriteLine(" {"); + + this.indenter.increaseIndent(); + var constructorDecl = TypeScript.getLastConstructor(classDecl); + if (constructorDecl) { + this.emitClassMembersFromConstructorDefinition(constructorDecl); + } + + this.emitDeclarationsForList(classDecl.classElements); + + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitHeritageClauses = function (clauses) { + if (clauses) { + for (var i = 0, n = clauses.childCount(); i < n; i++) { + this.emitHeritageClause(clauses.childAt(i)); + } + } + }; + + DeclarationEmitter.prototype.emitHeritageClause = function (clause) { + this.emitBaseList(clause.typeNames, clause.kind() === 230 /* ExtendsHeritageClause */); + }; + + DeclarationEmitter.prototype.getEnclosingContainer = function (ast) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 131 /* ClassDeclaration */ || ast.kind() === 128 /* InterfaceDeclaration */ || ast.kind() === 130 /* ModuleDeclaration */ || ast.kind() === 120 /* SourceUnit */) { + return ast; + } + + ast = ast.parent; + } + + return null; + }; + + DeclarationEmitter.prototype.emitTypeParameters = function (typeParams, funcSignature) { + if (!typeParams || !typeParams.typeParameters.nonSeparatorCount()) { + return; + } + + this.declFile.Write("<"); + var containerAst = this.getEnclosingContainer(typeParams); + + var start = new Date().getTime(); + var containerDecl = this.semanticInfoChain.getDeclForAST(containerAst); + var containerSymbol = containerDecl.getSymbol(); + TypeScript.declarationEmitGetTypeParameterSymbolTime += new Date().getTime() - start; + + var typars; + if (funcSignature) { + typars = funcSignature.getTypeParameters(); + } else { + typars = containerSymbol.getTypeArgumentsOrTypeParameters(); + } + + for (var i = 0; i < typars.length; i++) { + if (i) { + this.declFile.Write(", "); + } + + var memberName = typars[i].getScopedNameEx(containerSymbol, false, true); + this.emitTypeNamesMember(memberName); + } + + this.declFile.Write(">"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForInterfaceDeclaration = function (interfaceDecl) { + if (!this.canEmitDeclarations(interfaceDecl)) { + return; + } + + var interfaceName = interfaceDecl.identifier.text(); + this.emitDeclarationComments(interfaceDecl); + var interfacePullDecl = this.semanticInfoChain.getDeclForAST(interfaceDecl); + this.emitDeclFlags(interfaceDecl, "interface"); + this.declFile.Write(interfaceName); + + this.emitTypeParameters(interfaceDecl.typeParameterList); + this.emitHeritageClauses(interfaceDecl.heritageClauses); + this.declFile.WriteLine(" {"); + + this.indenter.increaseIndent(); + + this.emitSeparatedList(interfaceDecl.body.typeMembers); + + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForImportDeclaration = function (importDeclAST) { + var importDecl = this.semanticInfoChain.getDeclForAST(importDeclAST); + var importSymbol = importDecl.getSymbol(); + var isExportedImportDecl = TypeScript.hasModifier(importDeclAST.modifiers, 1 /* Exported */); + + if (isExportedImportDecl || importSymbol.typeUsedExternally() || TypeScript.PullContainerSymbol.usedAsSymbol(importSymbol.getContainer(), importSymbol)) { + this.emitDeclarationComments(importDeclAST); + this.emitIndent(); + if (isExportedImportDecl) { + this.declFile.Write("export "); + } + this.declFile.Write("import "); + this.declFile.Write(importDeclAST.identifier.text() + " = "); + if (importDeclAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + this.declFile.WriteLine("require(" + importDeclAST.moduleReference.stringLiteral.text() + ");"); + } else { + this.declFile.WriteLine(this.getFullName(importDeclAST.moduleReference.moduleName) + ";"); + } + } + }; + + DeclarationEmitter.prototype.getFullName = function (name) { + if (name.kind() === 11 /* IdentifierName */) { + return name.text(); + } else { + var dotExpr = name; + return this.getFullName(dotExpr.left) + "." + this.getFullName(dotExpr.right); + } + }; + + DeclarationEmitter.prototype.emitDeclarationsForEnumDeclaration = function (moduleDecl) { + if (!this.canEmitDeclarations(moduleDecl)) { + return; + } + + this.emitDeclarationComments(moduleDecl); + var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.emitDeclFlags(moduleDecl, "enum"); + this.declFile.WriteLine(moduleDecl.identifier.text() + " {"); + + this.indenter.increaseIndent(); + var membersLen = moduleDecl.enumElements.nonSeparatorCount(); + for (var j = 0; j < membersLen; j++) { + var memberDecl = moduleDecl.enumElements.nonSeparatorAt(j); + var enumElement = memberDecl; + var enumElementDecl = this.semanticInfoChain.getDeclForAST(enumElement); + this.emitDeclarationComments(enumElement); + this.emitIndent(); + this.declFile.Write(enumElement.propertyName.text()); + if (enumElementDecl.constantValue != null) { + this.declFile.Write(" = " + enumElementDecl.constantValue); + } + this.declFile.WriteLine(","); + } + this.indenter.decreaseIndent(); + + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForModuleDeclaration = function (moduleDecl) { + if (!this.canEmitDeclarations(moduleDecl)) { + return; + } + + var modulePullDecl = this.semanticInfoChain.getDeclForAST(moduleDecl); + this.emitDeclarationComments(moduleDecl); + + var name = moduleDecl.stringLiteral || TypeScript.ArrayUtilities.first(TypeScript.getModuleNames(moduleDecl.name)); + this.emitDeclFlags(name, "module"); + + if (moduleDecl.stringLiteral) { + this.declFile.Write(moduleDecl.stringLiteral.text()); + } else { + this.declFile.Write(this.getFullName(moduleDecl.name)); + } + + this.declFile.WriteLine(" {"); + this.indenter.increaseIndent(); + + this.emitDeclarationsForList(moduleDecl.moduleElements); + + this.indenter.decreaseIndent(); + this.emitIndent(); + this.declFile.WriteLine("}"); + }; + + DeclarationEmitter.prototype.emitDeclarationsForExportAssignment = function (ast) { + this.emitIndent(); + this.declFile.Write("export = "); + this.declFile.Write(ast.identifier.text()); + this.declFile.WriteLine(";"); + }; + + DeclarationEmitter.prototype.resolveScriptReference = function (document, reference) { + if (!this.emitOptions.compilationSettings().noResolve() || TypeScript.isRooted(reference)) { + return reference; + } + + var documentDir = TypeScript.convertToDirectoryPath(TypeScript.switchToForwardSlashes(TypeScript.getRootFilePath(document.fileName))); + var resolvedReferencePath = this.emitOptions.resolvePath(documentDir + reference); + return resolvedReferencePath; + }; + + DeclarationEmitter.prototype.emitReferencePaths = function (sourceUnit) { + if (this.emittedReferencePaths) { + return; + } + + var documents = []; + if (this.document.emitToOwnOutputFile()) { + var scriptReferences = this.document.referencedFiles; + var addedGlobalDocument = false; + for (var j = 0; j < scriptReferences.length; j++) { + var currentReference = this.resolveScriptReference(this.document, scriptReferences[j]); + var document = this.compiler.getDocument(currentReference); + + if (document && (document.emitToOwnOutputFile() || document.isDeclareFile() || !addedGlobalDocument)) { + documents = documents.concat(document); + + if (!document.isDeclareFile() && document.isExternalModule()) { + addedGlobalDocument = true; + } + } + } + } else { + var fileNames = this.compiler.fileNames(); + for (var i = 0; i < fileNames.length; i++) { + var doc = this.compiler.getDocument(fileNames[i]); + if (!doc.isDeclareFile() && !doc.isExternalModule()) { + var scriptReferences = doc.referencedFiles; + for (var j = 0; j < scriptReferences.length; j++) { + var currentReference = this.resolveScriptReference(doc, scriptReferences[j]); + var document = this.compiler.getDocument(currentReference); + + if (document && (document.isDeclareFile() || document.isExternalModule())) { + for (var k = 0; k < documents.length; k++) { + if (documents[k] == document) { + break; + } + } + + if (k == documents.length) { + documents = documents.concat(document); + } + } + } + } + } + } + + var emittingFilePath = documents.length ? TypeScript.getRootFilePath(this.emittingFileName) : null; + for (var i = 0; i < documents.length; i++) { + var document = documents[i]; + var declFileName; + if (document.isDeclareFile()) { + declFileName = document.fileName; + } else { + declFileName = this.compiler.mapOutputFileName(document, this.emitOptions, TypeScript.TypeScriptCompiler.mapToDTSFileName); + } + + declFileName = TypeScript.getRelativePathToFixedPath(emittingFilePath, declFileName, false); + this.declFile.WriteLine('/// '); + } + + this.emittedReferencePaths = true; + }; + + DeclarationEmitter.prototype.emitDeclarationsForSourceUnit = function (sourceUnit) { + this.emitReferencePaths(sourceUnit); + this.emitDeclarationsForList(sourceUnit.moduleElements); + }; + return DeclarationEmitter; + })(); + TypeScript.DeclarationEmitter = DeclarationEmitter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var BloomFilter = (function () { + function BloomFilter(expectedCount) { + var m = Math.max(1, BloomFilter.computeM(expectedCount)); + var k = Math.max(1, BloomFilter.computeK(expectedCount)); + ; + + var sizeInEvenBytes = (m + 7) & ~7; + + this.bitArray = []; + for (var i = 0, len = sizeInEvenBytes; i < len; i++) { + this.bitArray[i] = false; + } + this.hashFunctionCount = k; + } + BloomFilter.computeM = function (expectedCount) { + var p = BloomFilter.falsePositiveProbability; + var n = expectedCount; + + var numerator = n * Math.log(p); + var denominator = Math.log(1.0 / Math.pow(2.0, Math.log(2.0))); + return Math.ceil(numerator / denominator); + }; + + BloomFilter.computeK = function (expectedCount) { + var n = expectedCount; + var m = BloomFilter.computeM(expectedCount); + + var temp = Math.log(2.0) * m / n; + return Math.round(temp); + }; + + BloomFilter.prototype.computeHash = function (key, seed) { + return TypeScript.Hash.computeMurmur2StringHashCode(key, seed); + }; + + BloomFilter.prototype.addKeys = function (keys) { + for (var name in keys) { + if (keys[name]) { + this.add(name); + } + } + }; + + BloomFilter.prototype.add = function (value) { + for (var i = 0; i < this.hashFunctionCount; i++) { + var hash = this.computeHash(value, i); + hash = hash % this.bitArray.length; + this.bitArray[Math.abs(hash)] = true; + } + }; + + BloomFilter.prototype.probablyContains = function (value) { + for (var i = 0; i < this.hashFunctionCount; i++) { + var hash = this.computeHash(value, i); + hash = hash % this.bitArray.length; + if (!this.bitArray[Math.abs(hash)]) { + return false; + } + } + + return true; + }; + + BloomFilter.prototype.isEquivalent = function (filter) { + return BloomFilter.isEquivalent(this.bitArray, filter.bitArray) && this.hashFunctionCount == filter.hashFunctionCount; + }; + + BloomFilter.isEquivalent = function (array1, array2) { + if (array1.length != array2.length) { + return false; + } + + for (var i = 0; i < array1.length; i++) { + if (array1[i] != array2[i]) { + return false; + } + } + + return true; + }; + BloomFilter.falsePositiveProbability = 0.0001; + return BloomFilter; + })(); + TypeScript.BloomFilter = BloomFilter; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var IdentifierWalker = (function (_super) { + __extends(IdentifierWalker, _super); + function IdentifierWalker(list) { + _super.call(this); + this.list = list; + } + IdentifierWalker.prototype.visitToken = function (token) { + this.list[token.text()] = true; + }; + return IdentifierWalker; + })(TypeScript.SyntaxWalker); + TypeScript.IdentifierWalker = IdentifierWalker; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CompilationSettings = (function () { + function CompilationSettings() { + this.propagateEnumConstants = false; + this.removeComments = false; + this.watch = false; + this.noResolve = false; + this.allowAutomaticSemicolonInsertion = true; + this.noImplicitAny = false; + this.noLib = false; + this.codeGenTarget = 0 /* EcmaScript3 */; + this.moduleGenTarget = 0 /* Unspecified */; + this.outFileOption = ""; + this.outDirOption = ""; + this.mapSourceFiles = false; + this.mapRoot = ""; + this.sourceRoot = ""; + this.generateDeclarationFiles = false; + this.useCaseSensitiveFileResolution = false; + this.gatherDiagnostics = false; + this.codepage = null; + } + return CompilationSettings; + })(); + TypeScript.CompilationSettings = CompilationSettings; + + var ImmutableCompilationSettings = (function () { + function ImmutableCompilationSettings(propagateEnumConstants, removeComments, watch, noResolve, allowAutomaticSemicolonInsertion, noImplicitAny, noLib, codeGenTarget, moduleGenTarget, outFileOption, outDirOption, mapSourceFiles, mapRoot, sourceRoot, generateDeclarationFiles, useCaseSensitiveFileResolution, gatherDiagnostics, codepage) { + this._propagateEnumConstants = propagateEnumConstants; + this._removeComments = removeComments; + this._watch = watch; + this._noResolve = noResolve; + this._allowAutomaticSemicolonInsertion = allowAutomaticSemicolonInsertion; + this._noImplicitAny = noImplicitAny; + this._noLib = noLib; + this._codeGenTarget = codeGenTarget; + this._moduleGenTarget = moduleGenTarget; + this._outFileOption = outFileOption; + this._outDirOption = outDirOption; + this._mapSourceFiles = mapSourceFiles; + this._mapRoot = mapRoot; + this._sourceRoot = sourceRoot; + this._generateDeclarationFiles = generateDeclarationFiles; + this._useCaseSensitiveFileResolution = useCaseSensitiveFileResolution; + this._gatherDiagnostics = gatherDiagnostics; + this._codepage = codepage; + } + ImmutableCompilationSettings.prototype.propagateEnumConstants = function () { + return this._propagateEnumConstants; + }; + ImmutableCompilationSettings.prototype.removeComments = function () { + return this._removeComments; + }; + ImmutableCompilationSettings.prototype.watch = function () { + return this._watch; + }; + ImmutableCompilationSettings.prototype.noResolve = function () { + return this._noResolve; + }; + ImmutableCompilationSettings.prototype.allowAutomaticSemicolonInsertion = function () { + return this._allowAutomaticSemicolonInsertion; + }; + ImmutableCompilationSettings.prototype.noImplicitAny = function () { + return this._noImplicitAny; + }; + ImmutableCompilationSettings.prototype.noLib = function () { + return this._noLib; + }; + ImmutableCompilationSettings.prototype.codeGenTarget = function () { + return this._codeGenTarget; + }; + ImmutableCompilationSettings.prototype.moduleGenTarget = function () { + return this._moduleGenTarget; + }; + ImmutableCompilationSettings.prototype.outFileOption = function () { + return this._outFileOption; + }; + ImmutableCompilationSettings.prototype.outDirOption = function () { + return this._outDirOption; + }; + ImmutableCompilationSettings.prototype.mapSourceFiles = function () { + return this._mapSourceFiles; + }; + ImmutableCompilationSettings.prototype.mapRoot = function () { + return this._mapRoot; + }; + ImmutableCompilationSettings.prototype.sourceRoot = function () { + return this._sourceRoot; + }; + ImmutableCompilationSettings.prototype.generateDeclarationFiles = function () { + return this._generateDeclarationFiles; + }; + ImmutableCompilationSettings.prototype.useCaseSensitiveFileResolution = function () { + return this._useCaseSensitiveFileResolution; + }; + ImmutableCompilationSettings.prototype.gatherDiagnostics = function () { + return this._gatherDiagnostics; + }; + ImmutableCompilationSettings.prototype.codepage = function () { + return this._codepage; + }; + + ImmutableCompilationSettings.defaultSettings = function () { + if (!ImmutableCompilationSettings._defaultSettings) { + ImmutableCompilationSettings._defaultSettings = ImmutableCompilationSettings.fromCompilationSettings(new CompilationSettings()); + } + + return ImmutableCompilationSettings._defaultSettings; + }; + + ImmutableCompilationSettings.fromCompilationSettings = function (settings) { + return new ImmutableCompilationSettings(settings.propagateEnumConstants, settings.removeComments, settings.watch, settings.noResolve, settings.allowAutomaticSemicolonInsertion, settings.noImplicitAny, settings.noLib, settings.codeGenTarget, settings.moduleGenTarget, settings.outFileOption, settings.outDirOption, settings.mapSourceFiles, settings.mapRoot, settings.sourceRoot, settings.generateDeclarationFiles, settings.useCaseSensitiveFileResolution, settings.gatherDiagnostics, settings.codepage); + }; + + ImmutableCompilationSettings.prototype.toCompilationSettings = function () { + var result = new CompilationSettings(); + + for (var name in this) { + if (this.hasOwnProperty(name) && TypeScript.StringUtilities.startsWith(name, "_")) { + result[name.substr(1)] = this[name]; + } + } + + return result; + }; + return ImmutableCompilationSettings; + })(); + TypeScript.ImmutableCompilationSettings = ImmutableCompilationSettings; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (PullElementFlags) { + PullElementFlags[PullElementFlags["None"] = 0] = "None"; + PullElementFlags[PullElementFlags["Exported"] = 1] = "Exported"; + PullElementFlags[PullElementFlags["Private"] = 1 << 1] = "Private"; + PullElementFlags[PullElementFlags["Public"] = 1 << 2] = "Public"; + PullElementFlags[PullElementFlags["Ambient"] = 1 << 3] = "Ambient"; + PullElementFlags[PullElementFlags["Static"] = 1 << 4] = "Static"; + PullElementFlags[PullElementFlags["Optional"] = 1 << 7] = "Optional"; + PullElementFlags[PullElementFlags["Signature"] = 1 << 11] = "Signature"; + PullElementFlags[PullElementFlags["Enum"] = 1 << 12] = "Enum"; + PullElementFlags[PullElementFlags["ArrowFunction"] = 1 << 13] = "ArrowFunction"; + + PullElementFlags[PullElementFlags["ClassConstructorVariable"] = 1 << 14] = "ClassConstructorVariable"; + PullElementFlags[PullElementFlags["InitializedModule"] = 1 << 15] = "InitializedModule"; + PullElementFlags[PullElementFlags["InitializedDynamicModule"] = 1 << 16] = "InitializedDynamicModule"; + + PullElementFlags[PullElementFlags["MustCaptureThis"] = 1 << 18] = "MustCaptureThis"; + + PullElementFlags[PullElementFlags["DeclaredInAWithBlock"] = 1 << 21] = "DeclaredInAWithBlock"; + + PullElementFlags[PullElementFlags["HasReturnStatement"] = 1 << 22] = "HasReturnStatement"; + + PullElementFlags[PullElementFlags["PropertyParameter"] = 1 << 23] = "PropertyParameter"; + + PullElementFlags[PullElementFlags["IsAnnotatedWithAny"] = 1 << 24] = "IsAnnotatedWithAny"; + + PullElementFlags[PullElementFlags["HasDefaultArgs"] = 1 << 25] = "HasDefaultArgs"; + + PullElementFlags[PullElementFlags["ConstructorParameter"] = 1 << 26] = "ConstructorParameter"; + + PullElementFlags[PullElementFlags["ImplicitVariable"] = PullElementFlags.ClassConstructorVariable | PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "ImplicitVariable"; + PullElementFlags[PullElementFlags["SomeInitializedModule"] = PullElementFlags.InitializedModule | PullElementFlags.InitializedDynamicModule | PullElementFlags.Enum] = "SomeInitializedModule"; + })(TypeScript.PullElementFlags || (TypeScript.PullElementFlags = {})); + var PullElementFlags = TypeScript.PullElementFlags; + + function hasModifier(modifiers, flag) { + for (var i = 0, n = modifiers.length; i < n; i++) { + if (TypeScript.hasFlag(modifiers[i], flag)) { + return true; + } + } + + return false; + } + TypeScript.hasModifier = hasModifier; + + (function (PullElementKind) { + PullElementKind[PullElementKind["None"] = 0] = "None"; + PullElementKind[PullElementKind["Global"] = 0] = "Global"; + + PullElementKind[PullElementKind["Script"] = 1 << 0] = "Script"; + PullElementKind[PullElementKind["Primitive"] = 1 << 1] = "Primitive"; + + PullElementKind[PullElementKind["Container"] = 1 << 2] = "Container"; + PullElementKind[PullElementKind["Class"] = 1 << 3] = "Class"; + PullElementKind[PullElementKind["Interface"] = 1 << 4] = "Interface"; + PullElementKind[PullElementKind["DynamicModule"] = 1 << 5] = "DynamicModule"; + PullElementKind[PullElementKind["Enum"] = 1 << 6] = "Enum"; + PullElementKind[PullElementKind["TypeAlias"] = 1 << 7] = "TypeAlias"; + PullElementKind[PullElementKind["ObjectLiteral"] = 1 << 8] = "ObjectLiteral"; + + PullElementKind[PullElementKind["Variable"] = 1 << 9] = "Variable"; + PullElementKind[PullElementKind["CatchVariable"] = 1 << 10] = "CatchVariable"; + PullElementKind[PullElementKind["Parameter"] = 1 << 11] = "Parameter"; + PullElementKind[PullElementKind["Property"] = 1 << 12] = "Property"; + PullElementKind[PullElementKind["TypeParameter"] = 1 << 13] = "TypeParameter"; + + PullElementKind[PullElementKind["Function"] = 1 << 14] = "Function"; + PullElementKind[PullElementKind["ConstructorMethod"] = 1 << 15] = "ConstructorMethod"; + PullElementKind[PullElementKind["Method"] = 1 << 16] = "Method"; + PullElementKind[PullElementKind["FunctionExpression"] = 1 << 17] = "FunctionExpression"; + + PullElementKind[PullElementKind["GetAccessor"] = 1 << 18] = "GetAccessor"; + PullElementKind[PullElementKind["SetAccessor"] = 1 << 19] = "SetAccessor"; + + PullElementKind[PullElementKind["CallSignature"] = 1 << 20] = "CallSignature"; + PullElementKind[PullElementKind["ConstructSignature"] = 1 << 21] = "ConstructSignature"; + PullElementKind[PullElementKind["IndexSignature"] = 1 << 22] = "IndexSignature"; + + PullElementKind[PullElementKind["ObjectType"] = 1 << 23] = "ObjectType"; + PullElementKind[PullElementKind["FunctionType"] = 1 << 24] = "FunctionType"; + PullElementKind[PullElementKind["ConstructorType"] = 1 << 25] = "ConstructorType"; + + PullElementKind[PullElementKind["EnumMember"] = 1 << 26] = "EnumMember"; + + PullElementKind[PullElementKind["WithBlock"] = 1 << 27] = "WithBlock"; + PullElementKind[PullElementKind["CatchBlock"] = 1 << 28] = "CatchBlock"; + + PullElementKind[PullElementKind["All"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Container | PullElementKind.Class | PullElementKind.Interface | PullElementKind.DynamicModule | PullElementKind.Enum | PullElementKind.TypeAlias | PullElementKind.ObjectLiteral | PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.TypeParameter | PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor | PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.EnumMember | PullElementKind.WithBlock | PullElementKind.CatchBlock] = "All"; + + PullElementKind[PullElementKind["SomeFunction"] = PullElementKind.Function | PullElementKind.ConstructorMethod | PullElementKind.Method | PullElementKind.FunctionExpression | PullElementKind.GetAccessor | PullElementKind.SetAccessor] = "SomeFunction"; + + PullElementKind[PullElementKind["SomeValue"] = PullElementKind.Variable | PullElementKind.Parameter | PullElementKind.Property | PullElementKind.EnumMember | PullElementKind.SomeFunction] = "SomeValue"; + + PullElementKind[PullElementKind["SomeType"] = PullElementKind.Script | PullElementKind.Global | PullElementKind.Primitive | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType | PullElementKind.TypeParameter] = "SomeType"; + + PullElementKind[PullElementKind["AcceptableAlias"] = PullElementKind.Variable | PullElementKind.SomeFunction | PullElementKind.Class | PullElementKind.Interface | PullElementKind.Enum | PullElementKind.Container | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "AcceptableAlias"; + + PullElementKind[PullElementKind["SomeContainer"] = PullElementKind.Container | PullElementKind.DynamicModule | PullElementKind.TypeAlias] = "SomeContainer"; + + PullElementKind[PullElementKind["SomeSignature"] = PullElementKind.CallSignature | PullElementKind.ConstructSignature | PullElementKind.IndexSignature] = "SomeSignature"; + + PullElementKind[PullElementKind["SomeTypeReference"] = PullElementKind.Interface | PullElementKind.ObjectType | PullElementKind.FunctionType | PullElementKind.ConstructorType] = "SomeTypeReference"; + + PullElementKind[PullElementKind["SomeInstantiatableType"] = PullElementKind.Class | PullElementKind.Interface | PullElementKind.TypeParameter] = "SomeInstantiatableType"; + })(TypeScript.PullElementKind || (TypeScript.PullElementKind = {})); + var PullElementKind = TypeScript.PullElementKind; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.pullDeclID = 0; + var sentinelEmptyPullDeclArray = []; + + var PullDecl = (function () { + function PullDecl(declName, displayName, kind, declFlags, span) { + this.declID = TypeScript.pullDeclID++; + this.flags = 0 /* None */; + this.declGroups = null; + this.childDecls = null; + this.typeParameters = null; + this.synthesizedValDecl = null; + this.childDeclTypeCache = null; + this.childDeclValueCache = null; + this.childDeclNamespaceCache = null; + this.childDeclTypeParameterCache = null; + this.name = declName; + this.kind = kind; + this.flags = declFlags; + this.span = span; + + if (displayName !== this.name) { + this.declDisplayName = displayName; + } + } + PullDecl.prototype.fileName = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getParentPath = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getParentDecl = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.semanticInfoChain = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.isExternalModule = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype.getEnclosingDecl = function () { + throw TypeScript.Errors.abstract(); + }; + + PullDecl.prototype._getEnclosingDeclFromParentDecl = function () { + var decl = this; + while (decl) { + switch (decl.kind) { + default: + return decl; + case 512 /* Variable */: + case 8192 /* TypeParameter */: + case 2048 /* Parameter */: + case 128 /* TypeAlias */: + case 67108864 /* EnumMember */: + } + + decl = decl.getParentDecl(); + } + + TypeScript.Debug.fail(); + }; + + PullDecl.prototype.getDisplayName = function () { + return this.declDisplayName === undefined ? this.name : this.declDisplayName; + }; + + PullDecl.prototype.setSymbol = function (symbol) { + this.semanticInfoChain().setSymbolForDecl(this, symbol); + }; + + PullDecl.prototype.ensureSymbolIsBound = function (bindSignatureSymbol) { + if (typeof bindSignatureSymbol === "undefined") { bindSignatureSymbol = false; } + if (!((bindSignatureSymbol && this.hasSignatureSymbol()) || this.hasSymbol()) && this.kind != 1 /* Script */) { + var binder = this.semanticInfoChain().getBinder(); + binder.bindDeclToPullSymbol(this); + } + }; + + PullDecl.prototype.getSymbol = function () { + if (this.kind == 1 /* Script */) { + return null; + } + + this.ensureSymbolIsBound(); + + return this.semanticInfoChain().getSymbolForDecl(this); + }; + + PullDecl.prototype.hasSymbol = function () { + var symbol = this.semanticInfoChain().getSymbolForDecl(this); + return !!symbol; + }; + + PullDecl.prototype.setSignatureSymbol = function (signatureSymbol) { + this.semanticInfoChain().setSignatureSymbolForDecl(this, signatureSymbol); + }; + + PullDecl.prototype.getSignatureSymbol = function () { + this.ensureSymbolIsBound(true); + + return this.semanticInfoChain().getSignatureSymbolForDecl(this); + }; + + PullDecl.prototype.hasSignatureSymbol = function () { + var signatureSymbol = this.semanticInfoChain().getSignatureSymbolForDecl(this); + return !!signatureSymbol; + }; + + PullDecl.prototype.setFlags = function (flags) { + this.flags = flags; + }; + + PullDecl.prototype.setFlag = function (flags) { + this.flags |= flags; + }; + + PullDecl.prototype.getSpan = function () { + return this.span; + }; + + PullDecl.prototype.setValueDecl = function (valDecl) { + this.synthesizedValDecl = valDecl; + }; + + PullDecl.prototype.getValueDecl = function () { + return this.synthesizedValDecl; + }; + + PullDecl.prototype.isEqual = function (other) { + return (this.name === other.name) && (this.kind === other.kind) && (this.flags === other.flags) && (this.fileName() === other.fileName()) && (this.span.start() === other.span.start()) && (this.span.end() === other.span.end()); + }; + + PullDecl.prototype.getChildDeclCache = function (declKind) { + if (declKind === 8192 /* TypeParameter */) { + if (!this.childDeclTypeParameterCache) { + this.childDeclTypeParameterCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclTypeParameterCache; + } else if (TypeScript.hasFlag(declKind, 164 /* SomeContainer */)) { + if (!this.childDeclNamespaceCache) { + this.childDeclNamespaceCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclNamespaceCache; + } else if (TypeScript.hasFlag(declKind, 58728539 /* SomeType */)) { + if (!this.childDeclTypeCache) { + this.childDeclTypeCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclTypeCache; + } else { + if (!this.childDeclValueCache) { + this.childDeclValueCache = TypeScript.createIntrinsicsObject(); + } + + return this.childDeclValueCache; + } + }; + + PullDecl.prototype.addChildDecl = function (childDecl) { + if (childDecl.kind === 8192 /* TypeParameter */) { + if (!this.typeParameters) { + this.typeParameters = []; + } + this.typeParameters[this.typeParameters.length] = childDecl; + } else { + if (!this.childDecls) { + this.childDecls = []; + } + this.childDecls[this.childDecls.length] = childDecl; + } + + var declName = childDecl.name; + + if (!(childDecl.kind & 7340032 /* SomeSignature */)) { + var cache = this.getChildDeclCache(childDecl.kind); + var childrenOfName = cache[declName]; + if (!childrenOfName) { + childrenOfName = []; + } + + childrenOfName.push(childDecl); + cache[declName] = childrenOfName; + } + }; + + PullDecl.prototype.searchChildDecls = function (declName, searchKind) { + var cacheVal = null; + + if (searchKind & 58728539 /* SomeType */) { + cacheVal = this.childDeclTypeCache ? this.childDeclTypeCache[declName] : null; + } else if (searchKind & 164 /* SomeContainer */) { + cacheVal = this.childDeclNamespaceCache ? this.childDeclNamespaceCache[declName] : null; + } else { + cacheVal = this.childDeclValueCache ? this.childDeclValueCache[declName] : null; + } + + if (cacheVal) { + return cacheVal; + } else { + if (searchKind & 58728539 /* SomeType */) { + cacheVal = this.childDeclTypeParameterCache ? this.childDeclTypeParameterCache[declName] : null; + + if (cacheVal) { + return cacheVal; + } + } + + return sentinelEmptyPullDeclArray; + } + }; + + PullDecl.prototype.getChildDecls = function () { + return this.childDecls ? this.childDecls : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.getTypeParameters = function () { + return this.typeParameters ? this.typeParameters : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.addVariableDeclToGroup = function (decl) { + if (!this.declGroups) { + this.declGroups = TypeScript.createIntrinsicsObject(); + } + + var declGroup = this.declGroups[decl.name]; + if (declGroup) { + declGroup.addDecl(decl); + } else { + declGroup = new PullDeclGroup(decl.name); + declGroup.addDecl(decl); + this.declGroups[decl.name] = declGroup; + } + }; + + PullDecl.prototype.getVariableDeclGroups = function () { + var declGroups = null; + + if (this.declGroups) { + for (var declName in this.declGroups) { + if (this.declGroups[declName]) { + if (declGroups === null) { + declGroups = []; + } + + declGroups.push(this.declGroups[declName].getDecls()); + } + } + } + + return declGroups ? declGroups : sentinelEmptyPullDeclArray; + }; + + PullDecl.prototype.hasBeenBound = function () { + return this.hasSymbol() || this.hasSignatureSymbol(); + }; + + PullDecl.prototype.isSynthesized = function () { + return false; + }; + + PullDecl.prototype.ast = function () { + var semanticInfoChain = this.semanticInfoChain(); + return semanticInfoChain ? semanticInfoChain.getASTForDecl(this) : null; + }; + return PullDecl; + })(); + TypeScript.PullDecl = PullDecl; + + var RootPullDecl = (function (_super) { + __extends(RootPullDecl, _super); + function RootPullDecl(name, fileName, kind, declFlags, span, semanticInfoChain, isExternalModule) { + _super.call(this, name, name, kind, declFlags, span); + this._semanticInfoChain = semanticInfoChain; + this._isExternalModule = isExternalModule; + this._fileName = fileName; + } + RootPullDecl.prototype.fileName = function () { + return this._fileName; + }; + + RootPullDecl.prototype.getParentPath = function () { + return [this]; + }; + + RootPullDecl.prototype.getParentDecl = function () { + return null; + }; + + RootPullDecl.prototype.semanticInfoChain = function () { + return this._semanticInfoChain; + }; + + RootPullDecl.prototype.isExternalModule = function () { + return this._isExternalModule; + }; + + RootPullDecl.prototype.getEnclosingDecl = function () { + return this; + }; + return RootPullDecl; + })(PullDecl); + TypeScript.RootPullDecl = RootPullDecl; + + var NormalPullDecl = (function (_super) { + __extends(NormalPullDecl, _super); + function NormalPullDecl(declName, displayName, kind, declFlags, parentDecl, span, addToParent) { + if (typeof addToParent === "undefined") { addToParent = true; } + _super.call(this, declName, displayName, kind, declFlags, span); + this.parentDecl = null; + this.parentPath = null; + + this.parentDecl = parentDecl; + if (addToParent) { + parentDecl.addChildDecl(this); + } + } + NormalPullDecl.prototype.fileName = function () { + return this.parentDecl ? this.parentDecl.fileName() : ""; + }; + + NormalPullDecl.prototype.getParentDecl = function () { + return this.parentDecl; + }; + + NormalPullDecl.prototype.getParentPath = function () { + if (!this.parentPath) { + var path = [this]; + var parentDecl = this.parentDecl; + + while (parentDecl) { + if (parentDecl && path[path.length - 1] != parentDecl && !(parentDecl.kind & 256 /* ObjectLiteral */)) { + path.unshift(parentDecl); + } + + parentDecl = parentDecl.getParentDecl(); + } + + this.parentPath = path; + } + + return this.parentPath; + }; + + NormalPullDecl.prototype.semanticInfoChain = function () { + var parent = this.getParentDecl(); + return parent ? parent.semanticInfoChain() : null; + }; + + NormalPullDecl.prototype.isExternalModule = function () { + return false; + }; + + NormalPullDecl.prototype.getEnclosingDecl = function () { + return this.parentDecl && this.parentDecl._getEnclosingDeclFromParentDecl(); + }; + return NormalPullDecl; + })(PullDecl); + TypeScript.NormalPullDecl = NormalPullDecl; + + var PullEnumElementDecl = (function (_super) { + __extends(PullEnumElementDecl, _super); + function PullEnumElementDecl(declName, displayName, parentDecl, span) { + _super.call(this, declName, displayName, 67108864 /* EnumMember */, 4 /* Public */, parentDecl, span); + this.constantValue = null; + } + return PullEnumElementDecl; + })(NormalPullDecl); + TypeScript.PullEnumElementDecl = PullEnumElementDecl; + + var PullFunctionExpressionDecl = (function (_super) { + __extends(PullFunctionExpressionDecl, _super); + function PullFunctionExpressionDecl(expressionName, declFlags, parentDecl, span, displayName) { + if (typeof displayName === "undefined") { displayName = ""; } + _super.call(this, "", displayName, 131072 /* FunctionExpression */, declFlags, parentDecl, span); + this.functionExpressionName = expressionName; + } + PullFunctionExpressionDecl.prototype.getFunctionExpressionName = function () { + return this.functionExpressionName; + }; + return PullFunctionExpressionDecl; + })(NormalPullDecl); + TypeScript.PullFunctionExpressionDecl = PullFunctionExpressionDecl; + + var PullSynthesizedDecl = (function (_super) { + __extends(PullSynthesizedDecl, _super); + function PullSynthesizedDecl(declName, displayName, kind, declFlags, parentDecl, span, semanticInfoChain) { + _super.call(this, declName, displayName, kind, declFlags, parentDecl, span, false); + this._semanticInfoChain = semanticInfoChain; + } + PullSynthesizedDecl.prototype.semanticInfoChain = function () { + return this._semanticInfoChain; + }; + + PullSynthesizedDecl.prototype.isSynthesized = function () { + return true; + }; + return PullSynthesizedDecl; + })(NormalPullDecl); + TypeScript.PullSynthesizedDecl = PullSynthesizedDecl; + + var PullDeclGroup = (function () { + function PullDeclGroup(name) { + this.name = name; + this._decls = []; + } + PullDeclGroup.prototype.addDecl = function (decl) { + if (decl.name === this.name) { + this._decls[this._decls.length] = decl; + } + }; + + PullDeclGroup.prototype.getDecls = function () { + return this._decls; + }; + return PullDeclGroup; + })(); + TypeScript.PullDeclGroup = PullDeclGroup; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.pullSymbolID = 0; + TypeScript.globalTyvarID = 0; + TypeScript.sentinelEmptyArray = []; + + var PullSymbol = (function () { + function PullSymbol(name, declKind) { + this.pullSymbolID = TypeScript.pullSymbolID++; + this._container = null; + this.type = null; + this._declarations = null; + this.isResolved = false; + this.isOptional = false; + this.inResolution = false; + this.isSynthesized = false; + this.isVarArg = false; + this.rootSymbol = null; + this._enclosingSignature = null; + this._docComments = null; + this.isPrinting = false; + this.name = name; + this.kind = declKind; + } + PullSymbol.prototype.isAny = function () { + return false; + }; + + PullSymbol.prototype.isType = function () { + return (this.kind & 58728539 /* SomeType */) != 0; + }; + + PullSymbol.prototype.isTypeReference = function () { + return false; + }; + + PullSymbol.prototype.isSignature = function () { + return (this.kind & 7340032 /* SomeSignature */) != 0; + }; + + PullSymbol.prototype.isArrayNamedTypeReference = function () { + return false; + }; + + PullSymbol.prototype.isPrimitive = function () { + return this.kind === 2 /* Primitive */; + }; + + PullSymbol.prototype.isAccessor = function () { + return false; + }; + + PullSymbol.prototype.isError = function () { + return false; + }; + + PullSymbol.prototype.isInterface = function () { + return this.kind === 16 /* Interface */; + }; + + PullSymbol.prototype.isMethod = function () { + return this.kind === 65536 /* Method */; + }; + + PullSymbol.prototype.isProperty = function () { + return this.kind === 4096 /* Property */; + }; + + PullSymbol.prototype.isAlias = function () { + return false; + }; + + PullSymbol.prototype.isContainer = function () { + return false; + }; + + PullSymbol.prototype.findAliasedType = function (scopeSymbol, skipScopeSymbolAliasesLookIn, lookIntoOnlyExportedAlias, aliasSymbols, visitedScopeDeclarations) { + if (typeof aliasSymbols === "undefined") { aliasSymbols = []; } + if (typeof visitedScopeDeclarations === "undefined") { visitedScopeDeclarations = []; } + var scopeDeclarations = scopeSymbol.getDeclarations(); + var scopeSymbolAliasesToLookIn = []; + + for (var i = 0; i < scopeDeclarations.length; i++) { + var scopeDecl = scopeDeclarations[i]; + if (!TypeScript.ArrayUtilities.contains(visitedScopeDeclarations, scopeDecl)) { + visitedScopeDeclarations.push(scopeDecl); + + var childDecls = scopeDecl.getChildDecls(); + for (var j = 0; j < childDecls.length; j++) { + var childDecl = childDecls[j]; + if (childDecl.kind === 128 /* TypeAlias */ && (!lookIntoOnlyExportedAlias || (childDecl.flags & 1 /* Exported */))) { + var symbol = childDecl.getSymbol(); + + if (PullContainerSymbol.usedAsSymbol(symbol, this) || (this.rootSymbol && PullContainerSymbol.usedAsSymbol(symbol, this.rootSymbol))) { + aliasSymbols.push(symbol); + return aliasSymbols; + } + + if (!skipScopeSymbolAliasesLookIn && this.isExternalModuleReferenceAlias(symbol) && (!symbol.assignedContainer().hasExportAssignment() || (symbol.assignedContainer().getExportAssignedContainerSymbol() && symbol.assignedContainer().getExportAssignedContainerSymbol().kind == 32 /* DynamicModule */))) { + scopeSymbolAliasesToLookIn.push(symbol); + } + } + } + } + } + + for (var i = 0; i < scopeSymbolAliasesToLookIn.length; i++) { + var scopeSymbolAlias = scopeSymbolAliasesToLookIn[i]; + + aliasSymbols.push(scopeSymbolAlias); + var result = this.findAliasedType(scopeSymbolAlias.assignedContainer().hasExportAssignment() ? scopeSymbolAlias.assignedContainer().getExportAssignedContainerSymbol() : scopeSymbolAlias.assignedContainer(), false, true, aliasSymbols, visitedScopeDeclarations); + if (result) { + return result; + } + + aliasSymbols.pop(); + } + + return null; + }; + + PullSymbol.prototype.getExternalAliasedSymbols = function (scopeSymbol) { + if (!scopeSymbol) { + return null; + } + + var scopePath = scopeSymbol.pathToRoot(); + if (scopePath.length && scopePath[scopePath.length - 1].kind === 32 /* DynamicModule */) { + var symbols = this.findAliasedType(scopePath[scopePath.length - 1]); + return symbols; + } + + return null; + }; + + PullSymbol.prototype.isExternalModuleReferenceAlias = function (aliasSymbol) { + if (aliasSymbol) { + if (aliasSymbol.assignedValue()) { + return false; + } + + if (aliasSymbol.assignedType() && aliasSymbol.assignedType() != aliasSymbol.assignedContainer()) { + return false; + } + + if (aliasSymbol.assignedContainer() && aliasSymbol.assignedContainer().kind != 32 /* DynamicModule */) { + return false; + } + + return true; + } + + return false; + }; + + PullSymbol.prototype.getExportedInternalAliasSymbol = function (scopeSymbol) { + if (scopeSymbol) { + if (this.kind != 128 /* TypeAlias */) { + var scopePath = scopeSymbol.pathToRoot(); + for (var i = 0; i < scopePath.length; i++) { + var internalAliases = this.findAliasedType(scopeSymbol, true, true); + if (internalAliases) { + TypeScript.Debug.assert(internalAliases.length == 1); + return internalAliases[0]; + } + } + } + } + + return null; + }; + + PullSymbol.prototype.getAliasSymbolName = function (scopeSymbol, aliasNameGetter, aliasPartsNameGetter, skipInternalAlias) { + if (!skipInternalAlias) { + var internalAlias = this.getExportedInternalAliasSymbol(scopeSymbol); + if (internalAlias) { + return aliasNameGetter(internalAlias); + } + } + + var externalAliases = this.getExternalAliasedSymbols(scopeSymbol); + + if (externalAliases && this.isExternalModuleReferenceAlias(externalAliases[externalAliases.length - 1])) { + var aliasFullName = ""; + for (var i = 1, symbolsLen = externalAliases.length; i < symbolsLen; i++) { + aliasFullName = aliasFullName + "." + aliasPartsNameGetter(externalAliases[i]); + } + return aliasNameGetter(externalAliases[0]) + aliasFullName; + } + + return null; + }; + + PullSymbol.prototype._getResolver = function () { + TypeScript.Debug.assert(this._declarations && this._declarations.length > 0); + return this._declarations[0].semanticInfoChain().getResolver(); + }; + + PullSymbol.prototype._resolveDeclaredSymbol = function () { + return this._getResolver().resolveDeclaredSymbol(this); + }; + + PullSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + var aliasName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getName(scopeSymbol, useConstraintInName); + }, function (symbol) { + return symbol.getName(); + }); + if (aliasName != null) { + return aliasName; + } + + return this.name; + }; + + PullSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + var aliasDisplayName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getDisplayName(scopeSymbol, useConstraintInName); + }, function (symbol) { + return symbol.getDisplayName(); + }, skipInternalAliasName); + if (aliasDisplayName != null) { + return aliasDisplayName; + } + + var decls = this.getDeclarations(); + var name = decls.length && decls[0].getDisplayName(); + + return (name && name.length) ? name : this.name; + }; + + PullSymbol.prototype.getIsSpecialized = function () { + return false; + }; + + PullSymbol.prototype.getRootSymbol = function () { + if (!this.rootSymbol) { + return this; + } + return this.rootSymbol; + }; + PullSymbol.prototype.setRootSymbol = function (symbol) { + this.rootSymbol = symbol; + }; + + PullSymbol.prototype.setIsSynthesized = function (value) { + if (typeof value === "undefined") { value = true; } + this.isSynthesized = value; + }; + + PullSymbol.prototype.getIsSynthesized = function () { + return this.isSynthesized; + }; + + PullSymbol.prototype.setEnclosingSignature = function (signature) { + this._enclosingSignature = signature; + }; + + PullSymbol.prototype.getEnclosingSignature = function () { + return this._enclosingSignature; + }; + + PullSymbol.prototype.addDeclaration = function (decl) { + TypeScript.Debug.assert(!!decl); + + if (this.rootSymbol) { + return; + } + + if (!this._declarations) { + this._declarations = [decl]; + } else { + this._declarations[this._declarations.length] = decl; + } + }; + + PullSymbol.prototype.getDeclarations = function () { + if (this.rootSymbol) { + return this.rootSymbol.getDeclarations(); + } + + if (!this._declarations) { + this._declarations = []; + } + + return this._declarations; + }; + + PullSymbol.prototype.hasDeclaration = function (decl) { + if (!this._declarations) { + return false; + } + + return TypeScript.ArrayUtilities.any(this._declarations, function (eachDecl) { + return eachDecl === decl; + }); + }; + + PullSymbol.prototype.setContainer = function (containerSymbol) { + if (this.rootSymbol) { + return; + } + + this._container = containerSymbol; + }; + + PullSymbol.prototype.getContainer = function () { + if (this.rootSymbol) { + return this.rootSymbol.getContainer(); + } + + return this._container; + }; + + PullSymbol.prototype.setResolved = function () { + this.isResolved = true; + this.inResolution = false; + }; + + PullSymbol.prototype.startResolving = function () { + this.inResolution = true; + }; + + PullSymbol.prototype.setUnresolved = function () { + this.isResolved = false; + this.inResolution = false; + }; + + PullSymbol.prototype.anyDeclHasFlag = function (flag) { + var declarations = this.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + if (TypeScript.hasFlag(declarations[i].flags, flag)) { + return true; + } + } + return false; + }; + + PullSymbol.prototype.allDeclsHaveFlag = function (flag) { + var declarations = this.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + if (!TypeScript.hasFlag(declarations[i].flags, flag)) { + return false; + } + } + return true; + }; + + PullSymbol.prototype.pathToRoot = function () { + var path = []; + var node = this; + while (node) { + if (node.isType()) { + var associatedContainerSymbol = node.getAssociatedContainerType(); + if (associatedContainerSymbol) { + node = associatedContainerSymbol; + } + } + path[path.length] = node; + var nodeKind = node.kind; + if (nodeKind == 2048 /* Parameter */) { + break; + } else { + node = node.getContainer(); + } + } + return path; + }; + + PullSymbol.prototype.findCommonAncestorPath = function (b) { + var aPath = this.pathToRoot(); + if (aPath.length === 1) { + return aPath; + } + + var bPath; + if (b) { + bPath = b.pathToRoot(); + } else { + return aPath; + } + + var commonNodeIndex = -1; + for (var i = 0, aLen = aPath.length; i < aLen; i++) { + var aNode = aPath[i]; + for (var j = 0, bLen = bPath.length; j < bLen; j++) { + var bNode = bPath[j]; + if (aNode === bNode) { + var aDecl = null; + if (i > 0) { + var decls = aPath[i - 1].getDeclarations(); + if (decls.length) { + aDecl = decls[0].getParentDecl(); + } + } + var bDecl = null; + if (j > 0) { + var decls = bPath[j - 1].getDeclarations(); + if (decls.length) { + bDecl = decls[0].getParentDecl(); + } + } + if (!aDecl || !bDecl || aDecl == bDecl) { + commonNodeIndex = i; + break; + } + } + } + if (commonNodeIndex >= 0) { + break; + } + } + + if (commonNodeIndex >= 0) { + return aPath.slice(0, commonNodeIndex); + } else { + return aPath; + } + }; + + PullSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var str = this.getNameAndTypeName(scopeSymbol); + return str; + }; + + PullSymbol.prototype.getNamePartForFullName = function () { + return this.getDisplayName(null, true); + }; + + PullSymbol.prototype.fullName = function (scopeSymbol) { + var path = this.pathToRoot(); + var fullName = ""; + + var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.fullName(scopeSymbol); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }); + if (aliasFullName != null) { + return aliasFullName; + } + + for (var i = 1; i < path.length; i++) { + var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.fullName(scopeSymbol); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }); + if (aliasFullName != null) { + fullName = aliasFullName + "." + fullName; + break; + } + + var scopedName = path[i].getNamePartForFullName(); + if (path[i].kind == 32 /* DynamicModule */ && !TypeScript.isQuoted(scopedName)) { + break; + } + + if (scopedName === "") { + break; + } + + fullName = scopedName + "." + fullName; + } + + fullName = fullName + this.getNamePartForFullName(); + return fullName; + }; + + PullSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) { + var path = this.findCommonAncestorPath(scopeSymbol); + var fullName = ""; + + var aliasFullName = this.getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }, skipInternalAliasName); + if (aliasFullName != null) { + return aliasFullName; + } + + for (var i = 1; i < path.length; i++) { + var kind = path[i].kind; + if (kind === 4 /* Container */ || kind === 32 /* DynamicModule */) { + var aliasFullName = path[i].getAliasSymbolName(scopeSymbol, function (symbol) { + return symbol.getScopedName(scopeSymbol, skipTypeParametersInName, false, skipInternalAliasName); + }, function (symbol) { + return symbol.getNamePartForFullName(); + }, skipInternalAliasName); + if (aliasFullName != null) { + fullName = aliasFullName + "." + fullName; + break; + } + + if (kind === 4 /* Container */) { + fullName = path[i].getDisplayName() + "." + fullName; + } else { + var displayName = path[i].getDisplayName(); + if (TypeScript.isQuoted(displayName)) { + fullName = displayName + "." + fullName; + } + break; + } + } else { + break; + } + } + fullName = fullName + this.getDisplayName(scopeSymbol, useConstraintInName, skipInternalAliasName); + return fullName; + }; + + PullSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) { + var name = this.getScopedName(scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + return TypeScript.MemberName.create(name); + }; + + PullSymbol.prototype.getTypeName = function (scopeSymbol, getPrettyTypeName) { + var memberName = this.getTypeNameEx(scopeSymbol, getPrettyTypeName); + return memberName.toString(); + }; + + PullSymbol.prototype.getTypeNameEx = function (scopeSymbol, getPrettyTypeName) { + var type = this.type; + if (type) { + var memberName = getPrettyTypeName ? this.getTypeNameForFunctionSignature("", scopeSymbol, getPrettyTypeName) : null; + if (!memberName) { + memberName = type.getScopedNameEx(scopeSymbol, false, true, getPrettyTypeName); + } + + return memberName; + } + return TypeScript.MemberName.create(""); + }; + + PullSymbol.prototype.getTypeNameForFunctionSignature = function (prefix, scopeSymbol, getPrettyTypeName) { + var type = this.type; + if (type && !type.isNamedTypeSymbol() && this.kind != 4096 /* Property */ && this.kind != 512 /* Variable */ && this.kind != 2048 /* Parameter */) { + var signatures = type.getCallSignatures(); + if (signatures.length == 1 || (getPrettyTypeName && signatures.length)) { + var typeName = new TypeScript.MemberNameArray(); + var signatureName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, prefix, false, false, scopeSymbol, getPrettyTypeName); + typeName.addAll(signatureName); + return typeName; + } + } + + return null; + }; + + PullSymbol.prototype.getNameAndTypeName = function (scopeSymbol) { + var nameAndTypeName = this.getNameAndTypeNameEx(scopeSymbol); + return nameAndTypeName.toString(); + }; + + PullSymbol.prototype.getNameAndTypeNameEx = function (scopeSymbol) { + var type = this.type; + var nameStr = this.getDisplayName(scopeSymbol); + if (type) { + nameStr = nameStr + (this.isOptional ? "?" : ""); + var memberName = this.getTypeNameForFunctionSignature(nameStr, scopeSymbol); + if (!memberName) { + var typeNameEx = type.getScopedNameEx(scopeSymbol); + memberName = TypeScript.MemberName.create(typeNameEx, nameStr + ": ", ""); + } + return memberName; + } + return TypeScript.MemberName.create(nameStr); + }; + + PullSymbol.getTypeParameterString = function (typars, scopeSymbol, useContraintInName) { + return PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, undefined, useContraintInName).toString(); + }; + + PullSymbol.getTypeParameterStringEx = function (typeParameters, scopeSymbol, getTypeParamMarkerInfo, useContraintInName) { + var builder = new TypeScript.MemberNameArray(); + builder.prefix = ""; + + if (typeParameters && typeParameters.length) { + builder.add(TypeScript.MemberName.create("<")); + + for (var i = 0; i < typeParameters.length; i++) { + if (i) { + builder.add(TypeScript.MemberName.create(", ")); + } + + if (getTypeParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + + builder.add(typeParameters[i].getScopedNameEx(scopeSymbol, false, useContraintInName)); + + if (getTypeParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + } + + builder.add(TypeScript.MemberName.create(">")); + } + + return builder; + }; + + PullSymbol.getIsExternallyVisible = function (symbol, fromIsExternallyVisibleSymbol, inIsExternallyVisibleSymbols) { + if (inIsExternallyVisibleSymbols) { + for (var i = 0; i < inIsExternallyVisibleSymbols.length; i++) { + if (inIsExternallyVisibleSymbols[i] === symbol) { + return true; + } + } + } else { + inIsExternallyVisibleSymbols = []; + } + + if (fromIsExternallyVisibleSymbol === symbol) { + return true; + } + + inIsExternallyVisibleSymbols.push(fromIsExternallyVisibleSymbol); + + var result = symbol.isExternallyVisible(inIsExternallyVisibleSymbols); + + TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(inIsExternallyVisibleSymbols) === fromIsExternallyVisibleSymbol); + inIsExternallyVisibleSymbols.pop(); + + return result; + }; + + PullSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) { + var kind = this.kind; + if (kind === 2 /* Primitive */) { + return true; + } + + if (this.rootSymbol) { + return PullSymbol.getIsExternallyVisible(this.rootSymbol, this, inIsExternallyVisibleSymbols); + } + + if (this.isType()) { + var associatedContainerSymbol = this.getAssociatedContainerType(); + if (associatedContainerSymbol) { + return PullSymbol.getIsExternallyVisible(associatedContainerSymbol, this, inIsExternallyVisibleSymbols); + } + } + + if (this.anyDeclHasFlag(2 /* Private */)) { + return false; + } + + var container = this.getContainer(); + if (container === null) { + var decls = this.getDeclarations(); + if (decls.length) { + var parentDecl = decls[0].getParentDecl(); + if (parentDecl) { + var parentSymbol = parentDecl.getSymbol(); + if (!parentSymbol || parentDecl.kind == 1 /* Script */) { + return true; + } + + return PullSymbol.getIsExternallyVisible(parentSymbol, this, inIsExternallyVisibleSymbols); + } + } + + return true; + } + + if (container.kind == 32 /* DynamicModule */ || (container.getAssociatedContainerType() && container.getAssociatedContainerType().kind == 32 /* DynamicModule */)) { + var containerSymbol = container.kind == 32 /* DynamicModule */ ? container : container.getAssociatedContainerType(); + if (PullContainerSymbol.usedAsSymbol(containerSymbol, this)) { + return true; + } + } + + if (!this.anyDeclHasFlag(1 /* Exported */) && kind != 4096 /* Property */ && kind != 65536 /* Method */) { + return false; + } + + return PullSymbol.getIsExternallyVisible(container, this, inIsExternallyVisibleSymbols); + }; + + PullSymbol.prototype.getDocCommentsOfDecl = function (decl) { + var ast = decl.ast(); + + if (ast) { + var enclosingModuleDeclaration = TypeScript.getEnclosingModuleDeclaration(ast); + if (TypeScript.isLastNameOfModule(enclosingModuleDeclaration, ast)) { + return TypeScript.docComments(enclosingModuleDeclaration); + } + + if (ast.kind() != 130 /* ModuleDeclaration */ || decl.kind != 512 /* Variable */) { + return TypeScript.docComments(ast); + } + } + + return []; + }; + + PullSymbol.prototype.getDocCommentArray = function (symbol) { + var docComments = []; + if (!symbol) { + return docComments; + } + + var isParameter = symbol.kind == 2048 /* Parameter */; + var decls = symbol.getDeclarations(); + for (var i = 0; i < decls.length; i++) { + if (isParameter && decls[i].kind == 4096 /* Property */) { + continue; + } + docComments = docComments.concat(this.getDocCommentsOfDecl(decls[i])); + } + return docComments; + }; + + PullSymbol.getDefaultConstructorSymbolForDocComments = function (classSymbol) { + if (classSymbol.getHasDefaultConstructor()) { + var extendedTypes = classSymbol.getExtendedTypes(); + if (extendedTypes.length) { + return PullSymbol.getDefaultConstructorSymbolForDocComments(extendedTypes[0]); + } + } + + return classSymbol.type.getConstructSignatures()[0]; + }; + + PullSymbol.prototype.getDocCommentText = function (comments) { + var docCommentText = new Array(); + for (var c = 0; c < comments.length; c++) { + var commentText = this.getDocCommentTextValue(comments[c]); + if (commentText !== "") { + docCommentText.push(commentText); + } + } + return docCommentText.join("\n"); + }; + + PullSymbol.prototype.getDocCommentTextValue = function (comment) { + return this.cleanJSDocComment(comment.fullText()); + }; + + PullSymbol.prototype.docComments = function (useConstructorAsClass) { + var decls = this.getDeclarations(); + if (useConstructorAsClass && decls.length && decls[0].kind == 32768 /* ConstructorMethod */) { + var classDecl = decls[0].getParentDecl(); + return this.getDocCommentText(this.getDocCommentsOfDecl(classDecl)); + } + + if (this._docComments === null) { + var docComments = ""; + if (!useConstructorAsClass && this.kind == 2097152 /* ConstructSignature */ && decls.length && decls[0].kind == 8 /* Class */) { + var classSymbol = this.returnType; + var extendedTypes = classSymbol.getExtendedTypes(); + if (extendedTypes.length) { + docComments = extendedTypes[0].getConstructorMethod().docComments(); + } else { + docComments = ""; + } + } else if (this.kind == 2048 /* Parameter */) { + var parameterComments = []; + + var funcContainer = this.getEnclosingSignature(); + var funcDocComments = this.getDocCommentArray(funcContainer); + var paramComment = this.getParameterDocCommentText(this.getDisplayName(), funcDocComments); + if (paramComment != "") { + parameterComments.push(paramComment); + } + + var paramSelfComment = this.getDocCommentText(this.getDocCommentArray(this)); + if (paramSelfComment != "") { + parameterComments.push(paramSelfComment); + } + docComments = parameterComments.join("\n"); + } else { + var getSymbolComments = true; + if (this.kind == 16777216 /* FunctionType */) { + var functionSymbol = this.getFunctionSymbol(); + + if (functionSymbol) { + docComments = functionSymbol._docComments || ""; + getSymbolComments = false; + } else { + var declarationList = this.getDeclarations(); + if (declarationList.length > 0) { + docComments = declarationList[0].getSymbol()._docComments || ""; + getSymbolComments = false; + } + } + } + if (getSymbolComments) { + docComments = this.getDocCommentText(this.getDocCommentArray(this)); + if (docComments == "") { + if (this.kind == 1048576 /* CallSignature */) { + var callTypeSymbol = this.functionType; + if (callTypeSymbol && callTypeSymbol.getCallSignatures().length == 1) { + docComments = callTypeSymbol.docComments(); + } + } + } + } + } + + this._docComments = docComments; + } + + return this._docComments; + }; + + PullSymbol.prototype.getParameterDocCommentText = function (param, fncDocComments) { + if (fncDocComments.length === 0 || fncDocComments[0].kind() !== 6 /* MultiLineCommentTrivia */) { + return ""; + } + + for (var i = 0; i < fncDocComments.length; i++) { + var commentContents = fncDocComments[i].fullText(); + for (var j = commentContents.indexOf("@param", 0); 0 <= j; j = commentContents.indexOf("@param", j)) { + j += 6; + if (!this.isSpaceChar(commentContents, j)) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j); + if (j === -1) { + break; + } + + if (commentContents.charCodeAt(j) === 123 /* openBrace */) { + j++; + + var charCode = 0; + for (var curlies = 1; j < commentContents.length; j++) { + charCode = commentContents.charCodeAt(j); + + if (charCode === 123 /* openBrace */) { + curlies++; + continue; + } + + if (charCode === 125 /* closeBrace */) { + curlies--; + if (curlies === 0) { + break; + } else { + continue; + } + } + + if (charCode === 64 /* at */) { + break; + } + } + + if (j === commentContents.length) { + break; + } + + if (charCode === 64 /* at */) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j + 1); + if (j === -1) { + break; + } + } + + if (param !== commentContents.substr(j, param.length) || !this.isSpaceChar(commentContents, j + param.length)) { + continue; + } + + j = this.consumeLeadingSpace(commentContents, j + param.length); + if (j === -1) { + return ""; + } + + var endOfParam = commentContents.indexOf("@", j); + var paramHelpString = commentContents.substring(j, endOfParam < 0 ? commentContents.length : endOfParam); + + var paramSpacesToRemove = undefined; + var paramLineIndex = commentContents.substring(0, j).lastIndexOf("\n") + 1; + if (paramLineIndex !== 0) { + if (paramLineIndex < j && commentContents.charAt(paramLineIndex + 1) === "\r") { + paramLineIndex++; + } + } + var startSpaceRemovalIndex = this.consumeLeadingSpace(commentContents, paramLineIndex); + if (startSpaceRemovalIndex !== j && commentContents.charAt(startSpaceRemovalIndex) === "*") { + paramSpacesToRemove = j - startSpaceRemovalIndex - 1; + } + + return this.cleanJSDocComment(paramHelpString, paramSpacesToRemove); + } + } + + return ""; + }; + + PullSymbol.prototype.cleanJSDocComment = function (content, spacesToRemove) { + var docCommentLines = new Array(); + content = content.replace("/**", ""); + if (content.length >= 2 && content.charAt(content.length - 1) === "/" && content.charAt(content.length - 2) === "*") { + content = content.substring(0, content.length - 2); + } + var lines = content.split("\n"); + var inParamTag = false; + for (var l = 0; l < lines.length; l++) { + var line = lines[l]; + var cleanLinePos = this.cleanDocCommentLine(line, true, spacesToRemove); + if (!cleanLinePos) { + continue; + } + + var docCommentText = ""; + var prevPos = cleanLinePos.start; + for (var i = line.indexOf("@", cleanLinePos.start); 0 <= i && i < cleanLinePos.end; i = line.indexOf("@", i + 1)) { + var wasInParamtag = inParamTag; + + if (line.indexOf("param", i + 1) === i + 1 && this.isSpaceChar(line, i + 6)) { + if (!wasInParamtag) { + docCommentText += line.substring(prevPos, i); + } + + prevPos = i; + inParamTag = true; + } else if (wasInParamtag) { + prevPos = i; + inParamTag = false; + } + } + + if (!inParamTag) { + docCommentText += line.substring(prevPos, cleanLinePos.end); + } + + var newCleanPos = this.cleanDocCommentLine(docCommentText, false); + if (newCleanPos) { + if (spacesToRemove === undefined) { + spacesToRemove = cleanLinePos.jsDocSpacesRemoved; + } + docCommentLines.push(docCommentText); + } + } + + return docCommentLines.join("\n"); + }; + + PullSymbol.prototype.consumeLeadingSpace = function (line, startIndex, maxSpacesToRemove) { + var endIndex = line.length; + if (maxSpacesToRemove !== undefined) { + endIndex = TypeScript.MathPrototype.min(startIndex + maxSpacesToRemove, endIndex); + } + + for (; startIndex < endIndex; startIndex++) { + var charCode = line.charCodeAt(startIndex); + if (charCode !== 32 /* space */ && charCode !== 9 /* tab */) { + return startIndex; + } + } + + if (endIndex !== line.length) { + return endIndex; + } + + return -1; + }; + + PullSymbol.prototype.isSpaceChar = function (line, index) { + var length = line.length; + if (index < length) { + var charCode = line.charCodeAt(index); + + return charCode === 32 /* space */ || charCode === 9 /* tab */; + } + + return index === length; + }; + + PullSymbol.prototype.cleanDocCommentLine = function (line, jsDocStyleComment, jsDocLineSpaceToRemove) { + var nonSpaceIndex = this.consumeLeadingSpace(line, 0); + if (nonSpaceIndex !== -1) { + var jsDocSpacesRemoved = nonSpaceIndex; + if (jsDocStyleComment && line.charAt(nonSpaceIndex) === '*') { + var startIndex = nonSpaceIndex + 1; + nonSpaceIndex = this.consumeLeadingSpace(line, startIndex, jsDocLineSpaceToRemove); + + if (nonSpaceIndex !== -1) { + jsDocSpacesRemoved = nonSpaceIndex - startIndex; + } else { + return null; + } + } + + return { + start: nonSpaceIndex, + end: line.charAt(line.length - 1) === "\r" ? line.length - 1 : line.length, + jsDocSpacesRemoved: jsDocSpacesRemoved + }; + } + + return null; + }; + return PullSymbol; + })(); + TypeScript.PullSymbol = PullSymbol; + + var PullSignatureSymbol = (function (_super) { + __extends(PullSignatureSymbol, _super); + function PullSignatureSymbol(kind) { + _super.call(this, "", kind); + this._memberTypeParameterNameCache = null; + this._stringConstantOverload = undefined; + this.parameters = TypeScript.sentinelEmptyArray; + this.typeParameters = null; + this.returnType = null; + this.functionType = null; + this.hasOptionalParam = false; + this.nonOptionalParamCount = 0; + this.hasVarArgs = false; + this.hasAGenericParameter = false; + this.hasBeenChecked = false; + this.inWrapCheck = false; + } + PullSignatureSymbol.prototype.isDefinition = function () { + return false; + }; + + PullSignatureSymbol.prototype.isGeneric = function () { + return this.hasAGenericParameter || (this.typeParameters && this.typeParameters.length != 0); + }; + + PullSignatureSymbol.prototype.addParameter = function (parameter, isOptional) { + if (typeof isOptional === "undefined") { isOptional = false; } + if (this.parameters == TypeScript.sentinelEmptyArray) { + this.parameters = []; + } + + this.parameters[this.parameters.length] = parameter; + this.hasOptionalParam = isOptional; + + if (!parameter.getEnclosingSignature()) { + parameter.setEnclosingSignature(this); + } + + if (!isOptional) { + this.nonOptionalParamCount++; + } + }; + + PullSignatureSymbol.prototype.addTypeParameter = function (typeParameter) { + if (!this.typeParameters) { + this.typeParameters = []; + } + + if (!this._memberTypeParameterNameCache) { + this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject(); + } + + this.typeParameters[this.typeParameters.length] = typeParameter; + + this._memberTypeParameterNameCache[typeParameter.getName()] = typeParameter; + }; + + PullSignatureSymbol.prototype.getTypeParameters = function () { + if (!this.typeParameters) { + this.typeParameters = []; + } + + return this.typeParameters; + }; + + PullSignatureSymbol.prototype.findTypeParameter = function (name) { + var memberSymbol; + + if (!this._memberTypeParameterNameCache) { + this._memberTypeParameterNameCache = TypeScript.createIntrinsicsObject(); + + if (this.typeParameters) { + for (var i = 0; i < this.typeParameters.length; i++) { + this._memberTypeParameterNameCache[this.typeParameters[i].getName()] = this.typeParameters[i]; + } + } + } + + memberSymbol = this._memberTypeParameterNameCache[name]; + + return memberSymbol; + }; + + PullSignatureSymbol.prototype.isStringConstantOverloadSignature = function () { + if (this._stringConstantOverload === undefined) { + var params = this.parameters; + this._stringConstantOverload = false; + for (var i = 0; i < params.length; i++) { + var paramType = params[i].type; + if (paramType && paramType.isPrimitive() && paramType.isStringConstant()) { + this._stringConstantOverload = true; + } + } + } + + return this._stringConstantOverload; + }; + + PullSignatureSymbol.getSignatureTypeMemberName = function (candidateSignature, signatures, scopeSymbol) { + var allMemberNames = new TypeScript.MemberNameArray(); + var signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(signatures, "", false, false, scopeSymbol, true, candidateSignature); + allMemberNames.addAll(signatureMemberName); + return allMemberNames; + }; + + PullSignatureSymbol.getSignaturesTypeNameEx = function (signatures, prefix, shortform, brackets, scopeSymbol, getPrettyTypeName, candidateSignature) { + var result = []; + if (!signatures) { + return result; + } + + var len = signatures.length; + if (!getPrettyTypeName && len > 1) { + shortform = false; + } + + var foundDefinition = false; + if (candidateSignature && candidateSignature.isDefinition() && len > 1) { + candidateSignature = null; + } + + for (var i = 0; i < len; i++) { + if (len > 1 && signatures[i].isDefinition()) { + foundDefinition = true; + continue; + } + + var signature = signatures[i]; + if (getPrettyTypeName && candidateSignature) { + signature = candidateSignature; + } + + result.push(signature.getSignatureTypeNameEx(prefix, shortform, brackets, scopeSymbol)); + if (getPrettyTypeName) { + break; + } + } + + if (getPrettyTypeName && result.length && len > 1) { + var lastMemberName = result[result.length - 1]; + for (var i = i + 1; i < len; i++) { + if (signatures[i].isDefinition()) { + foundDefinition = true; + break; + } + } + var overloadString = TypeScript.getLocalizedText(TypeScript.DiagnosticCode._0_overload_s, [foundDefinition ? len - 2 : len - 1]); + lastMemberName.add(TypeScript.MemberName.create(overloadString)); + } + + return result; + }; + + PullSignatureSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var s = this.getSignatureTypeNameEx(this.getScopedNameEx().toString(), false, false, scopeSymbol, undefined, useConstraintInName).toString(); + return s; + }; + + PullSignatureSymbol.prototype.getSignatureTypeNameEx = function (prefix, shortform, brackets, scopeSymbol, getParamMarkerInfo, getTypeParamMarkerInfo) { + var typeParamterBuilder = new TypeScript.MemberNameArray(); + + typeParamterBuilder.add(PullSymbol.getTypeParameterStringEx(this.getTypeParameters(), scopeSymbol, getTypeParamMarkerInfo, true)); + + if (brackets) { + typeParamterBuilder.add(TypeScript.MemberName.create("[")); + } else { + typeParamterBuilder.add(TypeScript.MemberName.create("(")); + } + + var builder = new TypeScript.MemberNameArray(); + builder.prefix = prefix; + + if (getTypeParamMarkerInfo) { + builder.prefix = prefix; + builder.addAll(typeParamterBuilder.entries); + } else { + builder.prefix = prefix + typeParamterBuilder.toString(); + } + + var params = this.parameters; + var paramLen = params.length; + for (var i = 0; i < paramLen; i++) { + var paramType = params[i].type; + var typeString = paramType ? ": " : ""; + var paramIsVarArg = params[i].isVarArg; + var varArgPrefix = paramIsVarArg ? "..." : ""; + var optionalString = (!paramIsVarArg && params[i].isOptional) ? "?" : ""; + if (getParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + builder.add(TypeScript.MemberName.create(varArgPrefix + params[i].getScopedNameEx(scopeSymbol).toString() + optionalString + typeString)); + if (paramType) { + builder.add(paramType.getScopedNameEx(scopeSymbol)); + } + if (getParamMarkerInfo) { + builder.add(new TypeScript.MemberName()); + } + if (i < paramLen - 1) { + builder.add(TypeScript.MemberName.create(", ")); + } + } + + if (shortform) { + if (brackets) { + builder.add(TypeScript.MemberName.create("] => ")); + } else { + builder.add(TypeScript.MemberName.create(") => ")); + } + } else { + if (brackets) { + builder.add(TypeScript.MemberName.create("]: ")); + } else { + builder.add(TypeScript.MemberName.create("): ")); + } + } + + if (this.returnType) { + builder.add(this.returnType.getScopedNameEx(scopeSymbol)); + } else { + builder.add(TypeScript.MemberName.create("any")); + } + + return builder; + }; + + PullSignatureSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) { + var signature = this; + if (signature.inWrapCheck) { + return false; + } + + signature.inWrapCheck = true; + + var wrapsSomeTypeParameter = false; + + if (signature.returnType && signature.returnType.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + } + + if (!wrapsSomeTypeParameter) { + var parameters = signature.parameters; + + for (var i = 0; i < parameters.length; i++) { + if (!parameters[i].type) { + parameters[i]._resolveDeclaredSymbol(); + } + + if (parameters[i].type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + signature.inWrapCheck = false; + + return wrapsSomeTypeParameter; + }; + + PullSignatureSymbol.prototype.wrapsSomeNestedTypeIntoInfiniteExpansion = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + if (this.inWrapCheck) { + return isCheckingTypeArgumentList; + } + + if (knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID) != undefined) { + return knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID); + } + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, isCheckingTypeArgumentList); + + this.inWrapCheck = true; + + var wrapsSomeWrappedTypeParameter = false; + + if (this.returnType && this.returnType._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + wrapsSomeWrappedTypeParameter = true; + } + + if (!wrapsSomeWrappedTypeParameter) { + var parameters = this.parameters; + + for (var i = 0; i < parameters.length; i++) { + if (parameters[i].type && parameters[i].type._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + wrapsSomeWrappedTypeParameter = true; + break; + } + } + } + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, wrapsSomeWrappedTypeParameter); + + this.inWrapCheck = false; + + return wrapsSomeWrappedTypeParameter; + }; + return PullSignatureSymbol; + })(PullSymbol); + TypeScript.PullSignatureSymbol = PullSignatureSymbol; + + var PullTypeSymbol = (function (_super) { + __extends(PullTypeSymbol, _super); + function PullTypeSymbol(name, kind) { + _super.call(this, name, kind); + this._members = TypeScript.sentinelEmptyArray; + this._enclosedMemberTypes = null; + this._enclosedMemberContainers = null; + this._typeParameters = null; + this._specializedVersionsOfThisType = null; + this._arrayVersionOfThisType = null; + this._implementedTypes = null; + this._extendedTypes = null; + this._typesThatExplicitlyImplementThisType = null; + this._typesThatExtendThisType = null; + this._callSignatures = null; + this._allCallSignatures = null; + this._constructSignatures = null; + this._indexSignatures = null; + this._allIndexSignatures = null; + this._memberNameCache = null; + this._enclosedTypeNameCache = null; + this._enclosedContainerCache = null; + this._typeParameterNameCache = null; + this._containedNonMemberNameCache = null; + this._containedNonMemberTypeNameCache = null; + this._containedNonMemberContainerCache = null; + this._simpleInstantiationCache = null; + this._complexInstantiationCache = null; + this._hasGenericSignature = false; + this._hasGenericMember = false; + this._hasBaseTypeConflict = false; + this._knownBaseTypeCount = 0; + this._associatedContainerTypeSymbol = null; + this._constructorMethod = null; + this._hasDefaultConstructor = false; + this._functionSymbol = null; + this._inMemberTypeNameEx = false; + this.inSymbolPrivacyCheck = false; + this.inWrapCheck = false; + this.typeReference = null; + this._isArrayNamedTypeReference = undefined; + this.type = this; + } + PullTypeSymbol.prototype.isArrayNamedTypeReference = function () { + if (this._isArrayNamedTypeReference === undefined) { + this._isArrayNamedTypeReference = this.computeIsArrayNamedTypeReference(); + } + + return this._isArrayNamedTypeReference; + }; + + PullTypeSymbol.prototype.computeIsArrayNamedTypeReference = function () { + var typeArgs = this.getTypeArguments(); + if (typeArgs && this.getTypeArguments().length === 1 && this.name === "Array") { + var container = this.getContainer(); + var declaration = this.getDeclarations()[0]; + + if (declaration && declaration.getParentDecl() && declaration.getParentDecl().getParentDecl() === null) { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.isType = function () { + return true; + }; + PullTypeSymbol.prototype.isClass = function () { + return this.kind == 8 /* Class */ || (this._constructorMethod != null); + }; + PullTypeSymbol.prototype.isFunction = function () { + return (this.kind & (33554432 /* ConstructorType */ | 16777216 /* FunctionType */)) != 0; + }; + PullTypeSymbol.prototype.isConstructor = function () { + return this.kind == 33554432 /* ConstructorType */; + }; + PullTypeSymbol.prototype.isTypeParameter = function () { + return false; + }; + PullTypeSymbol.prototype.isTypeVariable = function () { + return false; + }; + PullTypeSymbol.prototype.isError = function () { + return false; + }; + PullTypeSymbol.prototype.isEnum = function () { + return this.kind == 64 /* Enum */; + }; + + PullTypeSymbol.prototype.getTypeParameterArgumentMap = function () { + return null; + }; + + PullTypeSymbol.prototype.isObject = function () { + return TypeScript.hasFlag(this.kind, 8 /* Class */ | 33554432 /* ConstructorType */ | 64 /* Enum */ | 16777216 /* FunctionType */ | 16 /* Interface */ | 8388608 /* ObjectType */); + }; + + PullTypeSymbol.prototype.getKnownBaseTypeCount = function () { + return this._knownBaseTypeCount; + }; + PullTypeSymbol.prototype.resetKnownBaseTypeCount = function () { + this._knownBaseTypeCount = 0; + }; + PullTypeSymbol.prototype.incrementKnownBaseCount = function () { + this._knownBaseTypeCount++; + }; + + PullTypeSymbol.prototype.setHasBaseTypeConflict = function () { + this._hasBaseTypeConflict = true; + }; + PullTypeSymbol.prototype.hasBaseTypeConflict = function () { + return this._hasBaseTypeConflict; + }; + + PullTypeSymbol.prototype.hasMembers = function () { + if (this._members != TypeScript.sentinelEmptyArray) { + return true; + } + + var parents = this.getExtendedTypes(); + + for (var i = 0; i < parents.length; i++) { + if (parents[i].hasMembers()) { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.setHasGenericSignature = function () { + this._hasGenericSignature = true; + }; + PullTypeSymbol.prototype.getHasGenericSignature = function () { + return this._hasGenericSignature; + }; + + PullTypeSymbol.prototype.setHasGenericMember = function () { + this._hasGenericMember = true; + }; + PullTypeSymbol.prototype.getHasGenericMember = function () { + return this._hasGenericMember; + }; + + PullTypeSymbol.prototype.setAssociatedContainerType = function (type) { + this._associatedContainerTypeSymbol = type; + }; + + PullTypeSymbol.prototype.getAssociatedContainerType = function () { + return this._associatedContainerTypeSymbol; + }; + + PullTypeSymbol.prototype.getArrayType = function () { + return this._arrayVersionOfThisType; + }; + + PullTypeSymbol.prototype.getElementType = function () { + return null; + }; + + PullTypeSymbol.prototype.setArrayType = function (arrayType) { + this._arrayVersionOfThisType = arrayType; + }; + + PullTypeSymbol.prototype.getFunctionSymbol = function () { + return this._functionSymbol; + }; + + PullTypeSymbol.prototype.setFunctionSymbol = function (symbol) { + if (symbol) { + this._functionSymbol = symbol; + } + }; + + PullTypeSymbol.prototype.findContainedNonMember = function (name) { + if (!this._containedNonMemberNameCache) { + return null; + } + + return this._containedNonMemberNameCache[name]; + }; + + PullTypeSymbol.prototype.findContainedNonMemberType = function (typeName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + if (!this._containedNonMemberTypeNameCache) { + return null; + } + + var nonMemberSymbol = this._containedNonMemberTypeNameCache[typeName]; + + if (nonMemberSymbol && kind != 0 /* None */) { + nonMemberSymbol = ((nonMemberSymbol.kind & kind) != 0) ? nonMemberSymbol : null; + } + + return nonMemberSymbol; + }; + + PullTypeSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + if (!this._containedNonMemberContainerCache) { + return null; + } + + var nonMemberSymbol = this._containedNonMemberContainerCache[containerName]; + + if (nonMemberSymbol && kind != 0 /* None */) { + nonMemberSymbol = ((nonMemberSymbol.kind & kind) != 0) ? nonMemberSymbol : null; + } + + return nonMemberSymbol; + }; + + PullTypeSymbol.prototype.addMember = function (memberSymbol) { + if (!memberSymbol) { + return; + } + + memberSymbol.setContainer(this); + + if (!this._memberNameCache) { + this._memberNameCache = TypeScript.createIntrinsicsObject(); + } + + if (this._members === TypeScript.sentinelEmptyArray) { + this._members = []; + } + + this._members.push(memberSymbol); + this._memberNameCache[memberSymbol.name] = memberSymbol; + }; + + PullTypeSymbol.prototype.addEnclosedMemberType = function (enclosedType) { + if (!enclosedType) { + return; + } + + enclosedType.setContainer(this); + + if (!this._enclosedTypeNameCache) { + this._enclosedTypeNameCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._enclosedMemberTypes) { + this._enclosedMemberTypes = []; + } + + this._enclosedMemberTypes[this._enclosedMemberTypes.length] = enclosedType; + this._enclosedTypeNameCache[enclosedType.name] = enclosedType; + }; + + PullTypeSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) { + if (!enclosedContainer) { + return; + } + + enclosedContainer.setContainer(this); + + if (!this._enclosedContainerCache) { + this._enclosedContainerCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._enclosedMemberContainers) { + this._enclosedMemberContainers = []; + } + + this._enclosedMemberContainers[this._enclosedMemberContainers.length] = enclosedContainer; + this._enclosedContainerCache[enclosedContainer.name] = enclosedContainer; + }; + + PullTypeSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) { + if (!enclosedNonMember) { + return; + } + + enclosedNonMember.setContainer(this); + + if (!this._containedNonMemberNameCache) { + this._containedNonMemberNameCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberNameCache[enclosedNonMember.name] = enclosedNonMember; + }; + + PullTypeSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) { + if (!enclosedNonMemberType) { + return; + } + + enclosedNonMemberType.setContainer(this); + + if (!this._containedNonMemberTypeNameCache) { + this._containedNonMemberTypeNameCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberTypeNameCache[enclosedNonMemberType.name] = enclosedNonMemberType; + }; + + PullTypeSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) { + if (!enclosedNonMemberContainer) { + return; + } + + enclosedNonMemberContainer.setContainer(this); + + if (!this._containedNonMemberContainerCache) { + this._containedNonMemberContainerCache = TypeScript.createIntrinsicsObject(); + } + + this._containedNonMemberContainerCache[enclosedNonMemberContainer.name] = enclosedNonMemberContainer; + }; + + PullTypeSymbol.prototype.addTypeParameter = function (typeParameter) { + if (!typeParameter) { + return; + } + + if (!typeParameter.getContainer()) { + typeParameter.setContainer(this); + } + + if (!this._typeParameterNameCache) { + this._typeParameterNameCache = TypeScript.createIntrinsicsObject(); + } + + if (!this._typeParameters) { + this._typeParameters = []; + } + + this._typeParameters[this._typeParameters.length] = typeParameter; + this._typeParameterNameCache[typeParameter.getName()] = typeParameter; + }; + + PullTypeSymbol.prototype.addConstructorTypeParameter = function (typeParameter) { + this.addTypeParameter(typeParameter); + + var constructSignatures = this.getConstructSignatures(); + + for (var i = 0; i < constructSignatures.length; i++) { + constructSignatures[i].addTypeParameter(typeParameter); + } + }; + + PullTypeSymbol.prototype.getMembers = function () { + return this._members; + }; + + PullTypeSymbol.prototype.setHasDefaultConstructor = function (hasOne) { + if (typeof hasOne === "undefined") { hasOne = true; } + this._hasDefaultConstructor = hasOne; + }; + + PullTypeSymbol.prototype.getHasDefaultConstructor = function () { + return this._hasDefaultConstructor; + }; + + PullTypeSymbol.prototype.getConstructorMethod = function () { + return this._constructorMethod; + }; + + PullTypeSymbol.prototype.setConstructorMethod = function (constructorMethod) { + this._constructorMethod = constructorMethod; + }; + + PullTypeSymbol.prototype.getTypeParameters = function () { + if (!this._typeParameters) { + return TypeScript.sentinelEmptyArray; + } + + return this._typeParameters; + }; + + PullTypeSymbol.prototype.isGeneric = function () { + return (this._typeParameters && this._typeParameters.length > 0) || this._hasGenericSignature || this._hasGenericMember || this.isArrayNamedTypeReference(); + }; + + PullTypeSymbol.prototype.canUseSimpleInstantiationCache = function (substitutingTypes) { + return substitutingTypes.length === 1 && substitutingTypes[0].kind !== 8388608 /* ObjectType */; + }; + + PullTypeSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) { + if (!substitutingTypes || !substitutingTypes.length) { + return; + } + + if (this.canUseSimpleInstantiationCache(substitutingTypes)) { + if (!this._simpleInstantiationCache) { + this._simpleInstantiationCache = []; + } + + this._simpleInstantiationCache[substitutingTypes[0].pullSymbolID] = specializedVersionOfThisType; + } else { + if (!this._complexInstantiationCache) { + this._complexInstantiationCache = TypeScript.createIntrinsicsObject(); + } + + this._complexInstantiationCache[getIDForTypeSubstitutions(substitutingTypes)] = specializedVersionOfThisType; + } + + if (!this._specializedVersionsOfThisType) { + this._specializedVersionsOfThisType = []; + } + + this._specializedVersionsOfThisType.push(specializedVersionOfThisType); + }; + + PullTypeSymbol.prototype.getSpecialization = function (substitutingTypes) { + if (!substitutingTypes || !substitutingTypes.length) { + return null; + } + + if (this.canUseSimpleInstantiationCache(substitutingTypes)) { + if (!this._simpleInstantiationCache) { + return null; + } + + var result = this._simpleInstantiationCache[substitutingTypes[0].pullSymbolID]; + return result ? result : null; + } else { + if (!this._complexInstantiationCache) { + return null; + } + + var result = this._complexInstantiationCache[getIDForTypeSubstitutions(substitutingTypes)]; + return result ? result : null; + } + }; + + PullTypeSymbol.prototype.getKnownSpecializations = function () { + if (!this._specializedVersionsOfThisType) { + return TypeScript.sentinelEmptyArray; + } + + return this._specializedVersionsOfThisType; + }; + + PullTypeSymbol.prototype.getTypeArguments = function () { + return null; + }; + + PullTypeSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + return this.getTypeParameters(); + }; + + PullTypeSymbol.prototype.addCallSignature = function (callSignature) { + if (!this._callSignatures) { + this._callSignatures = []; + } + + this._callSignatures[this._callSignatures.length] = callSignature; + + if (callSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + callSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addConstructSignature = function (constructSignature) { + if (!this._constructSignatures) { + this._constructSignatures = []; + } + + this._constructSignatures[this._constructSignatures.length] = constructSignature; + + if (constructSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + constructSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addIndexSignature = function (indexSignature) { + if (!this._indexSignatures) { + this._indexSignatures = []; + } + + this._indexSignatures[this._indexSignatures.length] = indexSignature; + + if (indexSignature.isGeneric()) { + this._hasGenericSignature = true; + } + + indexSignature.functionType = this; + }; + + PullTypeSymbol.prototype.addUnhiddenSignaturesFromBaseType = function (derivedTypeSignatures, baseTypeSignatures, signaturesBeingAggregated) { + if (!derivedTypeSignatures) { + signaturesBeingAggregated.push.apply(signaturesBeingAggregated, baseTypeSignatures); + return; + } + + var resolver = this._getResolver(); + for (var i = 0; i < baseTypeSignatures.length; i++) { + var baseSignature = baseTypeSignatures[i]; + + var signatureIsHidden = TypeScript.ArrayUtilities.any(derivedTypeSignatures, function (sig) { + return resolver.signaturesAreIdentical(baseSignature, sig, false); + }); + + if (!signatureIsHidden) { + signaturesBeingAggregated.push(baseSignature); + } + } + }; + + PullTypeSymbol.prototype.hasOwnCallSignatures = function () { + return this._callSignatures !== null; + }; + + PullTypeSymbol.prototype.getCallSignatures = function () { + if (this._allCallSignatures) { + return this._allCallSignatures; + } + + var signatures = []; + + if (this._callSignatures) { + signatures = signatures.concat(this._callSignatures); + } + + if (this._extendedTypes && this.kind === 16 /* Interface */) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._callSignatures, this._extendedTypes[i].getCallSignatures(), signatures); + } + } + + this._allCallSignatures = signatures; + + return signatures; + }; + + PullTypeSymbol.prototype.hasOwnConstructSignatures = function () { + return this._constructSignatures !== null; + }; + + PullTypeSymbol.prototype.getConstructSignatures = function () { + var signatures = []; + + if (this._constructSignatures) { + signatures = signatures.concat(this._constructSignatures); + } + + if (this._extendedTypes && this.kind === 16 /* Interface */) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._constructSignatures, this._extendedTypes[i].getConstructSignatures(), signatures); + } + } + + return signatures; + }; + + PullTypeSymbol.prototype.hasOwnIndexSignatures = function () { + return this._indexSignatures !== null; + }; + + PullTypeSymbol.prototype.getOwnIndexSignatures = function () { + return this._indexSignatures || TypeScript.sentinelEmptyArray; + }; + + PullTypeSymbol.prototype.getIndexSignatures = function () { + if (this._allIndexSignatures) { + return this._allIndexSignatures; + } + + var signatures = []; + + if (this._indexSignatures) { + signatures = signatures.concat(this._indexSignatures); + } + + if (this._extendedTypes) { + for (var i = 0; i < this._extendedTypes.length; i++) { + if (this._extendedTypes[i].hasBase(this)) { + continue; + } + + this.addUnhiddenSignaturesFromBaseType(this._indexSignatures, this._extendedTypes[i].getIndexSignatures(), signatures); + } + } + + this._allIndexSignatures = signatures; + + return signatures; + }; + + PullTypeSymbol.prototype.addImplementedType = function (implementedType) { + if (!implementedType) { + return; + } + + if (!this._implementedTypes) { + this._implementedTypes = []; + } + + this._implementedTypes[this._implementedTypes.length] = implementedType; + + implementedType.addTypeThatExplicitlyImplementsThisType(this); + }; + + PullTypeSymbol.prototype.getImplementedTypes = function () { + if (!this._implementedTypes) { + return TypeScript.sentinelEmptyArray; + } + + return this._implementedTypes; + }; + + PullTypeSymbol.prototype.addExtendedType = function (extendedType) { + if (!extendedType) { + return; + } + + if (!this._extendedTypes) { + this._extendedTypes = []; + } + + this._extendedTypes[this._extendedTypes.length] = extendedType; + + extendedType.addTypeThatExtendsThisType(this); + }; + + PullTypeSymbol.prototype.getExtendedTypes = function () { + if (!this._extendedTypes) { + return TypeScript.sentinelEmptyArray; + } + + return this._extendedTypes; + }; + + PullTypeSymbol.prototype.addTypeThatExtendsThisType = function (type) { + if (!type) { + return; + } + + if (!this._typesThatExtendThisType) { + this._typesThatExtendThisType = []; + } + + this._typesThatExtendThisType[this._typesThatExtendThisType.length] = type; + }; + + PullTypeSymbol.prototype.getTypesThatExtendThisType = function () { + if (!this._typesThatExtendThisType) { + this._typesThatExtendThisType = []; + } + + return this._typesThatExtendThisType; + }; + + PullTypeSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) { + if (!type) { + return; + } + + if (!this._typesThatExplicitlyImplementThisType) { + this._typesThatExplicitlyImplementThisType = []; + } + + this._typesThatExplicitlyImplementThisType[this._typesThatExplicitlyImplementThisType.length] = type; + }; + + PullTypeSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () { + if (!this._typesThatExplicitlyImplementThisType) { + this._typesThatExplicitlyImplementThisType = []; + } + + return this._typesThatExplicitlyImplementThisType; + }; + + PullTypeSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + if (this === potentialBase || this.getRootSymbol() === potentialBase || this === potentialBase.getRootSymbol()) { + return true; + } + + if (TypeScript.ArrayUtilities.contains(visited, this)) { + return true; + } + + visited.push(this); + + var extendedTypes = this.getExtendedTypes(); + + for (var i = 0; i < extendedTypes.length; i++) { + if (extendedTypes[i].hasBase(potentialBase, visited)) { + return true; + } + } + + var implementedTypes = this.getImplementedTypes(); + + for (var i = 0; i < implementedTypes.length; i++) { + if (implementedTypes[i].hasBase(potentialBase, visited)) { + return true; + } + } + + visited.pop(); + + return false; + }; + + PullTypeSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) { + if (baseType.isError()) { + return false; + } + + var thisIsClass = this.isClass(); + if (isExtendedType) { + if (thisIsClass) { + return baseType.kind === 8 /* Class */; + } + } else { + if (!thisIsClass) { + return false; + } + } + + return !!(baseType.kind & (16 /* Interface */ | 8 /* Class */)); + }; + + PullTypeSymbol.prototype.findMember = function (name, lookInParent) { + var memberSymbol = null; + + if (this._memberNameCache) { + memberSymbol = this._memberNameCache[name]; + } + + if (memberSymbol || !lookInParent) { + return memberSymbol; + } + + if (this._extendedTypes) { + for (var i = 0; i < this._extendedTypes.length; i++) { + memberSymbol = this._extendedTypes[i].findMember(name, lookInParent); + + if (memberSymbol) { + return memberSymbol; + } + } + } + + return null; + }; + + PullTypeSymbol.prototype.findNestedType = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + var memberSymbol; + + if (!this._enclosedTypeNameCache) { + return null; + } + + memberSymbol = this._enclosedTypeNameCache[name]; + + if (memberSymbol && kind != 0 /* None */) { + memberSymbol = ((memberSymbol.kind & kind) != 0) ? memberSymbol : null; + } + + return memberSymbol; + }; + + PullTypeSymbol.prototype.findNestedContainer = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + var memberSymbol; + + if (!this._enclosedContainerCache) { + return null; + } + + memberSymbol = this._enclosedContainerCache[name]; + + if (memberSymbol && kind != 0 /* None */) { + memberSymbol = ((memberSymbol.kind & kind) != 0) ? memberSymbol : null; + } + + return memberSymbol; + }; + + PullTypeSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + var allMembers = []; + + if (this._members != TypeScript.sentinelEmptyArray) { + for (var i = 0, n = this._members.length; i < n; i++) { + var member = this._members[i]; + if ((member.kind & searchDeclKind) && (memberVisiblity !== 2 /* externallyVisible */ || !member.anyDeclHasFlag(2 /* Private */))) { + allMembers[allMembers.length] = member; + } + } + } + + if (this._extendedTypes) { + var extenedMembersVisibility = memberVisiblity !== 0 /* all */ ? 2 /* externallyVisible */ : 0 /* all */; + + for (var i = 0, n = this._extendedTypes.length; i < n; i++) { + var extendedMembers = this._extendedTypes[i].getAllMembers(searchDeclKind, extenedMembersVisibility); + + for (var j = 0, m = extendedMembers.length; j < m; j++) { + var extendedMember = extendedMembers[j]; + if (!(this._memberNameCache && this._memberNameCache[extendedMember.name])) { + allMembers[allMembers.length] = extendedMember; + } + } + } + } + + if (this.isContainer()) { + if (this._enclosedMemberTypes) { + for (var i = 0; i < this._enclosedMemberTypes.length; i++) { + allMembers[allMembers.length] = this._enclosedMemberTypes[i]; + } + } + if (this._enclosedMemberContainers) { + for (var i = 0; i < this._enclosedMemberContainers.length; i++) { + allMembers[allMembers.length] = this._enclosedMemberContainers[i]; + } + } + } + + return allMembers; + }; + + PullTypeSymbol.prototype.findTypeParameter = function (name) { + if (!this._typeParameterNameCache) { + return null; + } + + return this._typeParameterNameCache[name]; + }; + + PullTypeSymbol.prototype.setResolved = function () { + _super.prototype.setResolved.call(this); + }; + + PullTypeSymbol.prototype.getNamePartForFullName = function () { + var name = _super.prototype.getNamePartForFullName.call(this); + + var typars = this.getTypeArgumentsOrTypeParameters(); + var typarString = PullSymbol.getTypeParameterString(typars, this, true); + return name + typarString; + }; + + PullTypeSymbol.prototype.getScopedName = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName) { + return this.getScopedNameEx(scopeSymbol, skipTypeParametersInName, useConstraintInName, false, false, skipInternalAliasName).toString(); + }; + + PullTypeSymbol.prototype.isNamedTypeSymbol = function () { + var kind = this.kind; + if (kind === 2 /* Primitive */ || kind === 8 /* Class */ || kind === 4 /* Container */ || kind === 32 /* DynamicModule */ || kind === 128 /* TypeAlias */ || kind === 64 /* Enum */ || kind === 8192 /* TypeParameter */ || ((kind === 16 /* Interface */ || kind === 8388608 /* ObjectType */) && this.name != "")) { + return true; + } + + return false; + }; + + PullTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + var s = this.getScopedNameEx(scopeSymbol, false, useConstraintInName).toString(); + return s; + }; + + PullTypeSymbol.prototype.getScopedNameEx = function (scopeSymbol, skipTypeParametersInName, useConstraintInName, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) { + if (this.isArrayNamedTypeReference()) { + var elementType = this.getElementType(); + var elementMemberName = elementType ? (elementType.isArrayNamedTypeReference() || elementType.isNamedTypeSymbol() ? elementType.getScopedNameEx(scopeSymbol, false, false, getPrettyTypeName, getTypeParamMarkerInfo, skipInternalAliasName) : elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : TypeScript.MemberName.create("any"); + return TypeScript.MemberName.create(elementMemberName, "", "[]"); + } + + if (!this.isNamedTypeSymbol()) { + return this.getMemberTypeNameEx(true, scopeSymbol, getPrettyTypeName); + } + + if (skipTypeParametersInName) { + return TypeScript.MemberName.create(_super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName)); + } else { + var builder = new TypeScript.MemberNameArray(); + builder.prefix = _super.prototype.getScopedName.call(this, scopeSymbol, skipTypeParametersInName, useConstraintInName, skipInternalAliasName); + + var typars = this.getTypeArgumentsOrTypeParameters(); + builder.add(PullSymbol.getTypeParameterStringEx(typars, scopeSymbol, getTypeParamMarkerInfo, useConstraintInName)); + + return builder; + } + }; + + PullTypeSymbol.prototype.hasOnlyOverloadCallSignatures = function () { + var members = this.getMembers(); + var callSignatures = this.getCallSignatures(); + var constructSignatures = this.getConstructSignatures(); + return members.length === 0 && constructSignatures.length === 0 && callSignatures.length > 1; + }; + + PullTypeSymbol.prototype.getTypeOfSymbol = function () { + var associatedContainerType = this.getAssociatedContainerType(); + if (associatedContainerType && associatedContainerType.isNamedTypeSymbol()) { + return associatedContainerType; + } + + var functionSymbol = this.getFunctionSymbol(); + if (functionSymbol && functionSymbol.kind == 16384 /* Function */ && !TypeScript.PullHelpers.isSymbolLocal(functionSymbol)) { + return functionSymbol; + } + + return null; + }; + + PullTypeSymbol.prototype.getMemberTypeNameEx = function (topLevel, scopeSymbol, getPrettyTypeName) { + var members = this.getMembers(); + var callSignatures = this.getCallSignatures(); + var constructSignatures = this.getConstructSignatures(); + var indexSignatures = this.getIndexSignatures(); + + if (members.length > 0 || callSignatures.length > 0 || constructSignatures.length > 0 || indexSignatures.length > 0) { + var typeOfSymbol = this.getTypeOfSymbol(); + if (typeOfSymbol) { + var nameForTypeOf = typeOfSymbol.getScopedNameEx(scopeSymbol, true); + return TypeScript.MemberName.create(nameForTypeOf, "typeof ", ""); + } + + if (this._inMemberTypeNameEx) { + return TypeScript.MemberName.create("any"); + } + + this._inMemberTypeNameEx = true; + + var allMemberNames = new TypeScript.MemberNameArray(); + var curlies = !topLevel || indexSignatures.length != 0; + var delim = "; "; + for (var i = 0; i < members.length; i++) { + if (members[i].kind == 65536 /* Method */ && members[i].type.hasOnlyOverloadCallSignatures()) { + var methodCallSignatures = members[i].type.getCallSignatures(); + var nameStr = members[i].getDisplayName(scopeSymbol) + (members[i].isOptional ? "?" : ""); + ; + var methodMemberNames = PullSignatureSymbol.getSignaturesTypeNameEx(methodCallSignatures, nameStr, false, false, scopeSymbol); + allMemberNames.addAll(methodMemberNames); + } else { + var memberTypeName = members[i].getNameAndTypeNameEx(scopeSymbol); + if (memberTypeName.isArray() && memberTypeName.delim === delim) { + allMemberNames.addAll(memberTypeName.entries); + } else { + allMemberNames.add(memberTypeName); + } + } + curlies = true; + } + + var getPrettyFunctionOverload = getPrettyTypeName && !curlies && this.hasOnlyOverloadCallSignatures(); + + var signatureCount = callSignatures.length + constructSignatures.length + indexSignatures.length; + var useShortFormSignature = !curlies && (signatureCount === 1); + var signatureMemberName; + + if (callSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(callSignatures, "", useShortFormSignature, false, scopeSymbol, getPrettyFunctionOverload); + allMemberNames.addAll(signatureMemberName); + } + + if (constructSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(constructSignatures, "new", useShortFormSignature, false, scopeSymbol); + allMemberNames.addAll(signatureMemberName); + } + + if (indexSignatures.length > 0) { + signatureMemberName = PullSignatureSymbol.getSignaturesTypeNameEx(indexSignatures, "", useShortFormSignature, true, scopeSymbol); + allMemberNames.addAll(signatureMemberName); + } + + if ((curlies) || (!getPrettyFunctionOverload && (signatureCount > 1) && topLevel)) { + allMemberNames.prefix = "{ "; + allMemberNames.suffix = "}"; + allMemberNames.delim = delim; + } else if (allMemberNames.entries.length > 1) { + allMemberNames.delim = delim; + } + + this._inMemberTypeNameEx = false; + + return allMemberNames; + } + + return TypeScript.MemberName.create("{}"); + }; + + PullTypeSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) { + return 2 /* Closed */; + }; + + PullTypeSymbol.prototype.wrapsSomeTypeParameter = function (typeParameterArgumentMap) { + var type = this; + + var wrapsSomeTypeParameter = false; + + if (type.isTypeParameter()) { + if (typeParameterArgumentMap[type.pullSymbolID]) { + return true; + } + + var constraint = type.getConstraint(); + + if (constraint && constraint.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return true; + } + + return false; + } + + if (type.inWrapCheck) { + return wrapsSomeTypeParameter; + } + + type.inWrapCheck = true; + + if (!wrapsSomeTypeParameter) { + var typeArguments = type.getTypeArguments(); + + if (type.isGeneric() && !typeArguments) { + typeArguments = type.getTypeParameters(); + } + + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (typeArguments[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + } + + if (!(type.kind & 8216 /* SomeInstantiatableType */) || !type.name) { + if (!wrapsSomeTypeParameter) { + var members = type.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + for (var i = 0; i < members.length; i++) { + if (members[i].type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + var sigs = type.getCallSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + sigs = type.getConstructSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + + if (!wrapsSomeTypeParameter) { + sigs = type.getIndexSignatures(); + + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeTypeParameter(typeParameterArgumentMap)) { + wrapsSomeTypeParameter = true; + break; + } + } + } + } + + type.inWrapCheck = false; + + return wrapsSomeTypeParameter; + }; + + PullTypeSymbol.prototype.wrapsSomeNestedTypeIntoInfiniteExpansion = function (typeBeingWrapped) { + if (!this.isArrayNamedTypeReference() && this.isNamedTypeSymbol()) { + var knownWrapMap = TypeScript.BitMatrix.getBitMatrix(true); + var result = this._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, false, knownWrapMap); + knownWrapMap.release(); + + return result; + } + + return false; + }; + + PullTypeSymbol.prototype.isTypeEquivalentToRootSymbol = function () { + if (this.isTypeReference()) { + if (this.getIsSpecialized()) { + var typeArguments = this.getTypeArguments(); + var rootTypeArguments = this.getRootSymbol().getTypeArguments(); + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (!typeArguments[i].isTypeParameter() && !(rootTypeArguments && rootTypeArguments[i] == typeArguments[i].getRootSymbol())) { + return false; + } + } + return true; + } + + return false; + } else { + return true; + } + } + + return false; + }; + + PullTypeSymbol.prototype.isTypeBeingWrapped = function (typeBeingWrapped) { + if (this.inWrapCheck || this == typeBeingWrapped) { + return true; + } + + if (typeBeingWrapped.isTypeEquivalentToRootSymbol()) { + return this.isTypeBeingWrapped(typeBeingWrapped.getRootSymbol()); + } + + return false; + }; + + PullTypeSymbol.prototype.anyRootTypeBeingWrapped = function (typeBeingWrapped) { + var prevRootType = this; + var rootType = this.getRootSymbol(); + while (rootType != prevRootType) { + if (rootType.isTypeBeingWrapped(typeBeingWrapped)) { + return true; + } + + prevRootType = rootType; + rootType = rootType.getRootSymbol(); + } + + return false; + }; + + PullTypeSymbol.prototype._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + if (this.isArrayNamedTypeReference()) { + return this.getElementType()._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap); + } + + if (this.isTypeBeingWrapped(typeBeingWrapped)) { + return isCheckingTypeArgumentList; + } + + if (knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID) != undefined) { + return knownWrapMap.valueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID); + } + + if (this.isPrimitive() || this.isTypeParameter()) { + return false; + } + + this.inWrapCheck = true; + + var wrapsSomeWrappedTypeParameter = false; + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, false); + + wrapsSomeWrappedTypeParameter = this._wrapsSomeNestedTypeIntoInfiniteExpansionWorker(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap); + + knownWrapMap.setValueAt(this.pullSymbolID, typeBeingWrapped.pullSymbolID, wrapsSomeWrappedTypeParameter); + + this.inWrapCheck = false; + + return wrapsSomeWrappedTypeParameter; + }; + + PullTypeSymbol.prototype._wrapsSomeNestedTypeIntoInfiniteExpansionWorker = function (typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap) { + var typeArguments = this.getTypeArguments(); + if (typeArguments) { + for (var i = 0; i < typeArguments.length; i++) { + if (typeArguments[i]._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, true, knownWrapMap)) { + return true; + } + } + } + + if (this.anyRootTypeBeingWrapped(typeBeingWrapped)) { + if (isCheckingTypeArgumentList && this.isTypeReference() && !this.getIsSpecialized()) { + return true; + } + + return false; + } else if (!this.isNamedTypeSymbol() || this.isGeneric()) { + var isTypeEquivalentToRootSymbol = this.isTypeEquivalentToRootSymbol(); + var rootType = TypeScript.PullHelpers.getRootType(this); + if (isTypeEquivalentToRootSymbol) { + rootType.inWrapCheck = true; + } + + var members = this.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + for (var i = 0; i < members.length; i++) { + if (members[i].type && members[i].type._wrapsSomeNestedTypeIntoInfiniteExpansionRecurse(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + var sigs = this.getCallSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + sigs = this.getConstructSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + sigs = this.getIndexSignatures(); + for (var i = 0; i < sigs.length; i++) { + if (sigs[i].wrapsSomeNestedTypeIntoInfiniteExpansion(typeBeingWrapped, isCheckingTypeArgumentList, knownWrapMap)) { + return true; + } + } + + if (isTypeEquivalentToRootSymbol) { + rootType.inWrapCheck = false; + } + + return false; + } + }; + return PullTypeSymbol; + })(PullSymbol); + TypeScript.PullTypeSymbol = PullTypeSymbol; + + var PullPrimitiveTypeSymbol = (function (_super) { + __extends(PullPrimitiveTypeSymbol, _super); + function PullPrimitiveTypeSymbol(name) { + _super.call(this, name, 2 /* Primitive */); + + this.isResolved = true; + } + PullPrimitiveTypeSymbol.prototype.isAny = function () { + return this.name === "any"; + }; + + PullPrimitiveTypeSymbol.prototype.isStringConstant = function () { + return false; + }; + + PullPrimitiveTypeSymbol.prototype.setUnresolved = function () { + }; + return PullPrimitiveTypeSymbol; + })(PullTypeSymbol); + TypeScript.PullPrimitiveTypeSymbol = PullPrimitiveTypeSymbol; + + var PullStringConstantTypeSymbol = (function (_super) { + __extends(PullStringConstantTypeSymbol, _super); + function PullStringConstantTypeSymbol(name) { + _super.call(this, name); + } + PullStringConstantTypeSymbol.prototype.isStringConstant = function () { + return true; + }; + return PullStringConstantTypeSymbol; + })(PullPrimitiveTypeSymbol); + TypeScript.PullStringConstantTypeSymbol = PullStringConstantTypeSymbol; + + var PullErrorTypeSymbol = (function (_super) { + __extends(PullErrorTypeSymbol, _super); + function PullErrorTypeSymbol(anyType, name) { + _super.call(this, name); + this.anyType = anyType; + + this.isResolved = true; + } + PullErrorTypeSymbol.prototype.isError = function () { + return true; + }; + + PullErrorTypeSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + + PullErrorTypeSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + + PullErrorTypeSymbol.prototype.toString = function (scopeSymbol, useConstraintInName) { + return this.anyType.getName(scopeSymbol, useConstraintInName); + }; + return PullErrorTypeSymbol; + })(PullPrimitiveTypeSymbol); + TypeScript.PullErrorTypeSymbol = PullErrorTypeSymbol; + + var PullContainerSymbol = (function (_super) { + __extends(PullContainerSymbol, _super); + function PullContainerSymbol(name, kind) { + _super.call(this, name, kind); + this.instanceSymbol = null; + this.assignedValue = null; + this.assignedType = null; + this.assignedContainer = null; + } + PullContainerSymbol.prototype.isContainer = function () { + return true; + }; + + PullContainerSymbol.prototype.setInstanceSymbol = function (symbol) { + this.instanceSymbol = symbol; + }; + + PullContainerSymbol.prototype.getInstanceSymbol = function () { + return this.instanceSymbol; + }; + + PullContainerSymbol.prototype.setExportAssignedValueSymbol = function (symbol) { + this.assignedValue = symbol; + }; + + PullContainerSymbol.prototype.getExportAssignedValueSymbol = function () { + return this.assignedValue; + }; + + PullContainerSymbol.prototype.setExportAssignedTypeSymbol = function (type) { + this.assignedType = type; + }; + + PullContainerSymbol.prototype.getExportAssignedTypeSymbol = function () { + return this.assignedType; + }; + + PullContainerSymbol.prototype.setExportAssignedContainerSymbol = function (container) { + this.assignedContainer = container; + }; + + PullContainerSymbol.prototype.getExportAssignedContainerSymbol = function () { + return this.assignedContainer; + }; + + PullContainerSymbol.prototype.hasExportAssignment = function () { + return !!this.assignedValue || !!this.assignedType || !!this.assignedContainer; + }; + + PullContainerSymbol.usedAsSymbol = function (containerSymbol, symbol) { + if (!containerSymbol || !containerSymbol.isContainer()) { + return false; + } + + if (!containerSymbol.isAlias() && containerSymbol.type == symbol) { + return true; + } + + var moduleSymbol = containerSymbol; + var valueExportSymbol = moduleSymbol.getExportAssignedValueSymbol(); + var typeExportSymbol = moduleSymbol.getExportAssignedTypeSymbol(); + var containerExportSymbol = moduleSymbol.getExportAssignedContainerSymbol(); + if (valueExportSymbol || typeExportSymbol || containerExportSymbol) { + return valueExportSymbol == symbol || typeExportSymbol == symbol || containerExportSymbol == symbol || PullContainerSymbol.usedAsSymbol(containerExportSymbol, symbol); + } + + return false; + }; + + PullContainerSymbol.prototype.getInstanceType = function () { + return this.instanceSymbol ? this.instanceSymbol.type : null; + }; + return PullContainerSymbol; + })(PullTypeSymbol); + TypeScript.PullContainerSymbol = PullContainerSymbol; + + var PullTypeAliasSymbol = (function (_super) { + __extends(PullTypeAliasSymbol, _super); + function PullTypeAliasSymbol(name) { + _super.call(this, name, 128 /* TypeAlias */); + this._assignedValue = null; + this._assignedType = null; + this._assignedContainer = null; + this._isUsedAsValue = false; + this._typeUsedExternally = false; + this.retrievingExportAssignment = false; + } + PullTypeAliasSymbol.prototype.typeUsedExternally = function () { + this._resolveDeclaredSymbol(); + return this._typeUsedExternally; + }; + + PullTypeAliasSymbol.prototype.isUsedAsValue = function () { + this._resolveDeclaredSymbol(); + return this._isUsedAsValue; + }; + + PullTypeAliasSymbol.prototype.setTypeUsedExternally = function (value) { + this._typeUsedExternally = value; + }; + + PullTypeAliasSymbol.prototype.setIsUsedAsValue = function (value) { + this._isUsedAsValue = value; + + this._resolveDeclaredSymbol(); + var resolver = this._getResolver(); + var importDeclStatement = resolver.semanticInfoChain.getASTForDecl(this.getDeclarations()[0]); + var aliasSymbol = resolver.semanticInfoChain.getAliasSymbolForAST(importDeclStatement.moduleReference); + if (aliasSymbol) { + aliasSymbol.setIsUsedAsValue(value); + } + }; + + PullTypeAliasSymbol.prototype.assignedValue = function () { + this._resolveDeclaredSymbol(); + return this._assignedValue; + }; + + PullTypeAliasSymbol.prototype.assignedType = function () { + this._resolveDeclaredSymbol(); + return this._assignedType; + }; + + PullTypeAliasSymbol.prototype.assignedContainer = function () { + this._resolveDeclaredSymbol(); + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.isAlias = function () { + return true; + }; + PullTypeAliasSymbol.prototype.isContainer = function () { + return true; + }; + + PullTypeAliasSymbol.prototype.setAssignedValueSymbol = function (symbol) { + this._assignedValue = symbol; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedValueSymbol = function () { + if (this._assignedValue) { + return this._assignedValue; + } + + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedValueSymbol(); + this.retrievingExportAssignment = false; + return sym; + } + + return null; + }; + + PullTypeAliasSymbol.prototype.setAssignedTypeSymbol = function (type) { + this._assignedType = type; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedTypeSymbol = function () { + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedType) { + if (this._assignedType.isAlias()) { + this.retrievingExportAssignment = true; + var sym = this._assignedType.getExportAssignedTypeSymbol(); + this.retrievingExportAssignment = false; + } else if (this._assignedType != this._assignedContainer) { + return this._assignedType; + } + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedTypeSymbol(); + this.retrievingExportAssignment = false; + if (sym) { + return sym; + } + } + + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.setAssignedContainerSymbol = function (container) { + this._assignedContainer = container; + }; + + PullTypeAliasSymbol.prototype.getExportAssignedContainerSymbol = function () { + if (this.retrievingExportAssignment) { + return null; + } + + if (this._assignedContainer) { + this.retrievingExportAssignment = true; + var sym = this._assignedContainer.getExportAssignedContainerSymbol(); + this.retrievingExportAssignment = false; + if (sym) { + return sym; + } + } + + return this._assignedContainer; + }; + + PullTypeAliasSymbol.prototype.getMembers = function () { + if (this._assignedType) { + return this._assignedType.getMembers(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getCallSignatures = function () { + if (this._assignedType) { + return this._assignedType.getCallSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getConstructSignatures = function () { + if (this._assignedType) { + return this._assignedType.getConstructSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.getIndexSignatures = function () { + if (this._assignedType) { + return this._assignedType.getIndexSignatures(); + } + + return TypeScript.sentinelEmptyArray; + }; + + PullTypeAliasSymbol.prototype.findMember = function (name) { + if (this._assignedType) { + return this._assignedType.findMember(name, true); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.findNestedType = function (name) { + if (this._assignedType) { + return this._assignedType.findNestedType(name); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.findNestedContainer = function (name) { + if (this._assignedType) { + return this._assignedType.findNestedContainer(name); + } + + return null; + }; + + PullTypeAliasSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisibility) { + if (this._assignedType) { + return this._assignedType.getAllMembers(searchDeclKind, memberVisibility); + } + + return TypeScript.sentinelEmptyArray; + }; + return PullTypeAliasSymbol; + })(PullTypeSymbol); + TypeScript.PullTypeAliasSymbol = PullTypeAliasSymbol; + + var PullDefinitionSignatureSymbol = (function (_super) { + __extends(PullDefinitionSignatureSymbol, _super); + function PullDefinitionSignatureSymbol() { + _super.apply(this, arguments); + } + PullDefinitionSignatureSymbol.prototype.isDefinition = function () { + return true; + }; + return PullDefinitionSignatureSymbol; + })(PullSignatureSymbol); + TypeScript.PullDefinitionSignatureSymbol = PullDefinitionSignatureSymbol; + + var PullTypeParameterSymbol = (function (_super) { + __extends(PullTypeParameterSymbol, _super); + function PullTypeParameterSymbol(name, _isFunctionTypeParameter) { + _super.call(this, name, 8192 /* TypeParameter */); + this._isFunctionTypeParameter = _isFunctionTypeParameter; + this._constraint = null; + } + PullTypeParameterSymbol.prototype.isTypeParameter = function () { + return true; + }; + PullTypeParameterSymbol.prototype.isFunctionTypeParameter = function () { + return this._isFunctionTypeParameter; + }; + + PullTypeParameterSymbol.prototype.setConstraint = function (constraintType) { + this._constraint = constraintType; + }; + + PullTypeParameterSymbol.prototype.getConstraint = function () { + return this._constraint; + }; + + PullTypeParameterSymbol.prototype.getCallSignatures = function () { + if (this._constraint) { + return this._constraint.getCallSignatures(); + } + + return _super.prototype.getCallSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.getConstructSignatures = function () { + if (this._constraint) { + return this._constraint.getConstructSignatures(); + } + + return _super.prototype.getConstructSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.getIndexSignatures = function () { + if (this._constraint) { + return this._constraint.getIndexSignatures(); + } + + return _super.prototype.getIndexSignatures.call(this); + }; + + PullTypeParameterSymbol.prototype.isGeneric = function () { + return true; + }; + + PullTypeParameterSymbol.prototype.fullName = function (scopeSymbol) { + var name = this.getDisplayName(scopeSymbol); + var container = this.getContainer(); + if (container) { + var containerName = container.fullName(scopeSymbol); + name = name + " in " + containerName; + } + + return name; + }; + + PullTypeParameterSymbol.prototype.getName = function (scopeSymbol, useConstraintInName) { + var name = _super.prototype.getName.call(this, scopeSymbol); + + if (this.isPrinting) { + return name; + } + + this.isPrinting = true; + + if (useConstraintInName && this._constraint) { + name += " extends " + this._constraint.toString(scopeSymbol); + } + + this.isPrinting = false; + + return name; + }; + + PullTypeParameterSymbol.prototype.getDisplayName = function (scopeSymbol, useConstraintInName, skipInternalAliasName) { + var name = _super.prototype.getDisplayName.call(this, scopeSymbol, useConstraintInName, skipInternalAliasName); + + if (this.isPrinting) { + return name; + } + + this.isPrinting = true; + + if (useConstraintInName && this._constraint) { + name += " extends " + this._constraint.toString(scopeSymbol); + } + + this.isPrinting = false; + + return name; + }; + + PullTypeParameterSymbol.prototype.isExternallyVisible = function (inIsExternallyVisibleSymbols) { + return true; + }; + return PullTypeParameterSymbol; + })(PullTypeSymbol); + TypeScript.PullTypeParameterSymbol = PullTypeParameterSymbol; + + var PullAccessorSymbol = (function (_super) { + __extends(PullAccessorSymbol, _super); + function PullAccessorSymbol(name) { + _super.call(this, name, 4096 /* Property */); + this._getterSymbol = null; + this._setterSymbol = null; + } + PullAccessorSymbol.prototype.isAccessor = function () { + return true; + }; + + PullAccessorSymbol.prototype.setSetter = function (setter) { + if (!setter) { + return; + } + + this._setterSymbol = setter; + }; + + PullAccessorSymbol.prototype.getSetter = function () { + return this._setterSymbol; + }; + + PullAccessorSymbol.prototype.setGetter = function (getter) { + if (!getter) { + return; + } + + this._getterSymbol = getter; + }; + + PullAccessorSymbol.prototype.getGetter = function () { + return this._getterSymbol; + }; + return PullAccessorSymbol; + })(PullSymbol); + TypeScript.PullAccessorSymbol = PullAccessorSymbol; + + function getIDForTypeSubstitutions(types) { + var substitution = ""; + var members = null; + + for (var i = 0; i < types.length; i++) { + if (types[i].kind !== 8388608 /* ObjectType */) { + substitution += types[i].pullSymbolID + "#"; + } else { + var structure = getIDForTypeSubstitutionsFromObjectType(types[i]); + + if (structure) { + substitution += structure; + } else { + substitution += types[i].pullSymbolID + "#"; + } + } + } + + return substitution; + } + TypeScript.getIDForTypeSubstitutions = getIDForTypeSubstitutions; + + function getIDForTypeSubstitutionsFromObjectType(type) { + var structure = ""; + + if (type.isResolved) { + var members = type.getMembers(); + if (members && members.length) { + for (var j = 0; j < members.length; j++) { + structure += members[j].name + "@" + getIDForTypeSubstitutions([members[j].type]); + } + } + + var callSignatures = type.getCallSignatures(); + if (callSignatures && callSignatures.length) { + for (var j = 0; j < callSignatures.length; j++) { + structure += getIDForTypeSubstitutionFromSignature(callSignatures[j]); + } + } + + var constructSignatures = type.getConstructSignatures(); + if (constructSignatures && constructSignatures.length) { + for (var j = 0; j < constructSignatures.length; j++) { + structure += "new" + getIDForTypeSubstitutionFromSignature(constructSignatures[j]); + } + } + + var indexSignatures = type.getIndexSignatures(); + if (indexSignatures && indexSignatures.length) { + for (var j = 0; j < indexSignatures.length; j++) { + structure += "[]" + getIDForTypeSubstitutionFromSignature(indexSignatures[j]); + } + } + } + + if (structure !== "") { + return "{" + structure + "}"; + } + + return null; + } + + function getIDForTypeSubstitutionFromSignature(signature) { + var structure = "("; + var parameters = signature.parameters; + if (parameters && parameters.length) { + for (var k = 0; k < parameters.length; k++) { + structure += parameters[k].name + "@" + getIDForTypeSubstitutions([parameters[k].type]); + } + } + + structure += ")" + getIDForTypeSubstitutions([signature.returnType]); + return structure; + } + + (function (GetAllMembersVisiblity) { + GetAllMembersVisiblity[GetAllMembersVisiblity["all"] = 0] = "all"; + + GetAllMembersVisiblity[GetAllMembersVisiblity["internallyVisible"] = 1] = "internallyVisible"; + + GetAllMembersVisiblity[GetAllMembersVisiblity["externallyVisible"] = 2] = "externallyVisible"; + })(TypeScript.GetAllMembersVisiblity || (TypeScript.GetAllMembersVisiblity = {})); + var GetAllMembersVisiblity = TypeScript.GetAllMembersVisiblity; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var CandidateInferenceInfo = (function () { + function CandidateInferenceInfo() { + this.typeParameter = null; + this.isFixed = false; + this.inferenceCandidates = []; + } + CandidateInferenceInfo.prototype.addCandidate = function (candidate) { + if (!this.isFixed) { + this.inferenceCandidates[this.inferenceCandidates.length] = candidate; + } + }; + return CandidateInferenceInfo; + })(); + TypeScript.CandidateInferenceInfo = CandidateInferenceInfo; + + var ArgumentInferenceContext = (function () { + function ArgumentInferenceContext(resolver, argumentsOrParameters) { + this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false); + this.candidateCache = []; + this.fixedParameterTypes = null; + this.resolver = null; + this.argumentASTs = null; + this.resolver = resolver; + + if (argumentsOrParameters.nonSeparatorAt != undefined) { + this.argumentASTs = argumentsOrParameters; + } else { + this.fixedParameterTypes = argumentsOrParameters; + } + } + ArgumentInferenceContext.prototype.alreadyRelatingTypes = function (objectType, parameterType) { + if (this.inferenceCache.valueAt(objectType.pullSymbolID, parameterType.pullSymbolID)) { + return true; + } else { + this.inferenceCache.setValueAt(objectType.pullSymbolID, parameterType.pullSymbolID, true); + return false; + } + }; + + ArgumentInferenceContext.prototype.resetRelationshipCache = function () { + this.inferenceCache.release(); + this.inferenceCache = TypeScript.BitMatrix.getBitMatrix(false); + }; + + ArgumentInferenceContext.prototype.addInferenceRoot = function (param) { + var info = this.candidateCache[param.pullSymbolID]; + + if (!info) { + info = new CandidateInferenceInfo(); + info.typeParameter = param; + this.candidateCache[param.pullSymbolID] = info; + } + }; + + ArgumentInferenceContext.prototype.getInferenceInfo = function (param) { + return this.candidateCache[param.pullSymbolID]; + }; + + ArgumentInferenceContext.prototype.addCandidateForInference = function (param, candidate, fix) { + var info = this.getInferenceInfo(param); + + if (info) { + if (candidate) { + info.addCandidate(candidate); + } + + if (!info.isFixed) { + info.isFixed = fix; + } + } + }; + + ArgumentInferenceContext.prototype.getInferenceArgumentCount = function () { + if (this.fixedParameterTypes) { + return this.fixedParameterTypes.length; + } else { + return this.argumentASTs.nonSeparatorCount(); + } + }; + + ArgumentInferenceContext.prototype.getArgumentTypeSymbolAtIndex = function (i, context) { + TypeScript.Debug.assert(i >= 0, "invalid inference argument position"); + + if (this.fixedParameterTypes && i < this.getInferenceArgumentCount()) { + return this.fixedParameterTypes[i]; + } else if (i < this.getInferenceArgumentCount()) { + return this.resolver.resolveAST(this.argumentASTs.nonSeparatorAt(i), true, context).type; + } + + return null; + }; + + ArgumentInferenceContext.prototype.getInferenceCandidates = function () { + var inferenceCandidates = []; + + for (var infoKey in this.candidateCache) { + if (this.candidateCache.hasOwnProperty(infoKey)) { + var info = this.candidateCache[infoKey]; + + for (var i = 0; i < info.inferenceCandidates.length; i++) { + var val = []; + val[info.typeParameter.pullSymbolID] = info.inferenceCandidates[i]; + inferenceCandidates.push(val); + } + } + } + + return inferenceCandidates; + }; + + ArgumentInferenceContext.prototype.inferArgumentTypes = function (resolver, context) { + var collection; + + var bestCommonType; + + var results = []; + + var unfit = false; + + for (var infoKey in this.candidateCache) { + if (this.candidateCache.hasOwnProperty(infoKey)) { + var info = this.candidateCache[infoKey]; + + if (!info.inferenceCandidates.length) { + results[results.length] = { param: info.typeParameter, type: null }; + continue; + } + + collection = { + getLength: function () { + return info.inferenceCandidates.length; + }, + getTypeAtIndex: function (index) { + return info.inferenceCandidates[index].type; + } + }; + + bestCommonType = resolver.widenType(resolver.findBestCommonType(collection, context, new TypeScript.TypeComparisonInfo())); + + if (!bestCommonType) { + unfit = true; + } else { + for (var i = 0; i < results.length; i++) { + if (results[i].type == info.typeParameter) { + results[i].type = bestCommonType; + } + } + } + + results[results.length] = { param: info.typeParameter, type: bestCommonType }; + } + } + + return { results: results, unfit: unfit }; + }; + return ArgumentInferenceContext; + })(); + TypeScript.ArgumentInferenceContext = ArgumentInferenceContext; + + var PullContextualTypeContext = (function () { + function PullContextualTypeContext(contextualType, provisional, substitutions) { + this.contextualType = contextualType; + this.provisional = provisional; + this.substitutions = substitutions; + this.provisionallyTypedSymbols = []; + this.hasProvisionalErrors = false; + this.astSymbolMap = []; + } + PullContextualTypeContext.prototype.recordProvisionallyTypedSymbol = function (symbol) { + this.provisionallyTypedSymbols[this.provisionallyTypedSymbols.length] = symbol; + }; + + PullContextualTypeContext.prototype.invalidateProvisionallyTypedSymbols = function () { + for (var i = 0; i < this.provisionallyTypedSymbols.length; i++) { + this.provisionallyTypedSymbols[i].setUnresolved(); + } + }; + + PullContextualTypeContext.prototype.setSymbolForAST = function (ast, symbol) { + this.astSymbolMap[ast.syntaxID()] = symbol; + }; + + PullContextualTypeContext.prototype.getSymbolForAST = function (ast) { + return this.astSymbolMap[ast.syntaxID()]; + }; + return PullContextualTypeContext; + })(); + TypeScript.PullContextualTypeContext = PullContextualTypeContext; + + var PullTypeResolutionContext = (function () { + function PullTypeResolutionContext(resolver, inTypeCheck, fileName) { + if (typeof inTypeCheck === "undefined") { inTypeCheck = false; } + if (typeof fileName === "undefined") { fileName = null; } + this.resolver = resolver; + this.inTypeCheck = inTypeCheck; + this.fileName = fileName; + this.contextStack = []; + this.typeCheckedNodes = null; + this.inBaseTypeResolution = false; + if (inTypeCheck) { + TypeScript.Debug.assert(fileName, "A file name must be provided if you are typechecking"); + this.typeCheckedNodes = TypeScript.BitVector.getBitVector(false); + } + } + PullTypeResolutionContext.prototype.setTypeChecked = function (ast) { + if (!this.inProvisionalResolution()) { + this.typeCheckedNodes.setValueAt(ast.syntaxID(), true); + } + }; + + PullTypeResolutionContext.prototype.canTypeCheckAST = function (ast) { + return this.typeCheck() && !this.typeCheckedNodes.valueAt(ast.syntaxID()) && this.fileName === ast.fileName(); + }; + + PullTypeResolutionContext.prototype.pushContextualType = function (type, provisional, substitutions) { + this.contextStack.push(new PullContextualTypeContext(type, provisional, substitutions)); + }; + + PullTypeResolutionContext.prototype.popContextualType = function () { + var tc = this.contextStack.pop(); + + tc.invalidateProvisionallyTypedSymbols(); + + if (tc.hasProvisionalErrors && this.inProvisionalResolution()) { + this.contextStack[this.contextStack.length - 1].hasProvisionalErrors = true; + } + + return tc; + }; + + PullTypeResolutionContext.prototype.hasProvisionalErrors = function () { + return this.contextStack.length ? this.contextStack[this.contextStack.length - 1].hasProvisionalErrors : false; + }; + + PullTypeResolutionContext.prototype.findSubstitution = function (type) { + var substitution = null; + + if (this.contextStack.length) { + for (var i = this.contextStack.length - 1; i >= 0; i--) { + if (this.contextStack[i].substitutions) { + substitution = this.contextStack[i].substitutions[type.pullSymbolID]; + + if (substitution) { + break; + } + } + } + } + + return substitution; + }; + + PullTypeResolutionContext.prototype.getContextualType = function () { + var context = !this.contextStack.length ? null : this.contextStack[this.contextStack.length - 1]; + + if (context) { + var type = context.contextualType; + + if (!type) { + return null; + } + + if (type.isTypeParameter() && type.getConstraint()) { + type = type.getConstraint(); + } + + var substitution = this.findSubstitution(type); + + return substitution ? substitution : type; + } + + return null; + }; + + PullTypeResolutionContext.prototype.inProvisionalResolution = function () { + return (!this.contextStack.length ? false : this.contextStack[this.contextStack.length - 1].provisional); + }; + + PullTypeResolutionContext.prototype.isInBaseTypeResolution = function () { + return this.inBaseTypeResolution; + }; + + PullTypeResolutionContext.prototype.startBaseTypeResolution = function () { + var wasInBaseTypeResoltion = this.inBaseTypeResolution; + this.inBaseTypeResolution = true; + return wasInBaseTypeResoltion; + }; + + PullTypeResolutionContext.prototype.doneBaseTypeResolution = function (wasInBaseTypeResolution) { + this.inBaseTypeResolution = wasInBaseTypeResolution; + }; + + PullTypeResolutionContext.prototype.setTypeInContext = function (symbol, type) { + var substitution = this.findSubstitution(type); + + symbol.type = substitution ? substitution : type; + + if (this.contextStack.length && this.inProvisionalResolution()) { + this.contextStack[this.contextStack.length - 1].recordProvisionallyTypedSymbol(symbol); + } + }; + + PullTypeResolutionContext.prototype.postDiagnostic = function (diagnostic) { + if (diagnostic) { + if (this.inProvisionalResolution()) { + (this.contextStack[this.contextStack.length - 1]).hasProvisionalErrors = true; + } else if (this.inTypeCheck && this.resolver) { + this.resolver.semanticInfoChain.addDiagnostic(diagnostic); + } + } + }; + + PullTypeResolutionContext.prototype.typeCheck = function () { + return this.inTypeCheck && !this.inProvisionalResolution(); + }; + + PullTypeResolutionContext.prototype.setSymbolForAST = function (ast, symbol) { + this.contextStack[this.contextStack.length - 1].setSymbolForAST(ast, symbol); + }; + + PullTypeResolutionContext.prototype.getSymbolForAST = function (ast) { + for (var i = this.contextStack.length - 1; i >= 0; i--) { + var typeContext = this.contextStack[i]; + if (!typeContext.provisional) { + break; + } + + var symbol = typeContext.getSymbolForAST(ast); + if (symbol) { + return symbol; + } + } + + return null; + }; + return PullTypeResolutionContext; + })(); + TypeScript.PullTypeResolutionContext = PullTypeResolutionContext; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var OverloadApplicabilityStatus; + (function (OverloadApplicabilityStatus) { + OverloadApplicabilityStatus[OverloadApplicabilityStatus["NotAssignable"] = 0] = "NotAssignable"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableButWithProvisionalErrors"] = 1] = "AssignableButWithProvisionalErrors"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["AssignableWithNoProvisionalErrors"] = 2] = "AssignableWithNoProvisionalErrors"; + OverloadApplicabilityStatus[OverloadApplicabilityStatus["Subtype"] = 3] = "Subtype"; + })(OverloadApplicabilityStatus || (OverloadApplicabilityStatus = {})); + + var PullAdditionalCallResolutionData = (function () { + function PullAdditionalCallResolutionData() { + this.targetSymbol = null; + this.resolvedSignatures = null; + this.candidateSignature = null; + this.actualParametersContextTypeSymbols = null; + this.diagnosticsFromOverloadResolution = []; + } + return PullAdditionalCallResolutionData; + })(); + TypeScript.PullAdditionalCallResolutionData = PullAdditionalCallResolutionData; + + var PullAdditionalObjectLiteralResolutionData = (function () { + function PullAdditionalObjectLiteralResolutionData() { + this.membersContextTypeSymbols = null; + } + return PullAdditionalObjectLiteralResolutionData; + })(); + TypeScript.PullAdditionalObjectLiteralResolutionData = PullAdditionalObjectLiteralResolutionData; + + var MemberWithBaseOrigin = (function () { + function MemberWithBaseOrigin(memberSymbol, baseOrigin) { + this.memberSymbol = memberSymbol; + this.baseOrigin = baseOrigin; + } + return MemberWithBaseOrigin; + })(); + + var SignatureWithBaseOrigin = (function () { + function SignatureWithBaseOrigin(signature, baseOrigin) { + this.signature = signature; + this.baseOrigin = baseOrigin; + } + return SignatureWithBaseOrigin; + })(); + + var InheritedIndexSignatureInfo = (function () { + function InheritedIndexSignatureInfo() { + } + return InheritedIndexSignatureInfo; + })(); + + var CompilerReservedNames; + (function (CompilerReservedNames) { + CompilerReservedNames[CompilerReservedNames["_this"] = 1] = "_this"; + CompilerReservedNames[CompilerReservedNames["_super"] = 2] = "_super"; + CompilerReservedNames[CompilerReservedNames["arguments"] = 3] = "arguments"; + CompilerReservedNames[CompilerReservedNames["_i"] = 4] = "_i"; + CompilerReservedNames[CompilerReservedNames["require"] = 5] = "require"; + CompilerReservedNames[CompilerReservedNames["exports"] = 6] = "exports"; + })(CompilerReservedNames || (CompilerReservedNames = {})); + + function getCompilerReservedName(name) { + var nameText = name.valueText(); + var index = CompilerReservedNames[nameText]; + return CompilerReservedNames[index] ? index : undefined; + } + + var PullTypeResolver = (function () { + function PullTypeResolver(compilationSettings, semanticInfoChain) { + this.compilationSettings = compilationSettings; + this.semanticInfoChain = semanticInfoChain; + this._cachedArrayInterfaceType = null; + this._cachedNumberInterfaceType = null; + this._cachedStringInterfaceType = null; + this._cachedBooleanInterfaceType = null; + this._cachedObjectInterfaceType = null; + this._cachedFunctionInterfaceType = null; + this._cachedIArgumentsInterfaceType = null; + this._cachedRegExpInterfaceType = null; + this._cachedAnyTypeArgs = null; + this.typeCheckCallBacks = []; + this.postTypeCheckWorkitems = []; + this._cachedFunctionArgumentsSymbol = null; + this.assignableCache = TypeScript.BitMatrix.getBitMatrix(true); + this.subtypeCache = TypeScript.BitMatrix.getBitMatrix(true); + this.identicalCache = TypeScript.BitMatrix.getBitMatrix(true); + } + PullTypeResolver.prototype.cachedArrayInterfaceType = function () { + if (!this._cachedArrayInterfaceType) { + this._cachedArrayInterfaceType = this.getSymbolFromDeclPath("Array", [], 16 /* Interface */); + } + + if (!this._cachedArrayInterfaceType) { + this._cachedArrayInterfaceType = this.semanticInfoChain.anyTypeSymbol; + } + + if (!this._cachedArrayInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedArrayInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedArrayInterfaceType; + }; + + PullTypeResolver.prototype.getArrayNamedType = function () { + return this.cachedArrayInterfaceType(); + }; + + PullTypeResolver.prototype.cachedNumberInterfaceType = function () { + if (!this._cachedNumberInterfaceType) { + this._cachedNumberInterfaceType = this.getSymbolFromDeclPath("Number", [], 16 /* Interface */); + } + + if (this._cachedNumberInterfaceType && !this._cachedNumberInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedNumberInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedNumberInterfaceType; + }; + + PullTypeResolver.prototype.cachedStringInterfaceType = function () { + if (!this._cachedStringInterfaceType) { + this._cachedStringInterfaceType = this.getSymbolFromDeclPath("String", [], 16 /* Interface */); + } + + if (this._cachedStringInterfaceType && !this._cachedStringInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedStringInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedStringInterfaceType; + }; + + PullTypeResolver.prototype.cachedBooleanInterfaceType = function () { + if (!this._cachedBooleanInterfaceType) { + this._cachedBooleanInterfaceType = this.getSymbolFromDeclPath("Boolean", [], 16 /* Interface */); + } + + if (this._cachedBooleanInterfaceType && !this._cachedBooleanInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedBooleanInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedBooleanInterfaceType; + }; + + PullTypeResolver.prototype.cachedObjectInterfaceType = function () { + if (!this._cachedObjectInterfaceType) { + this._cachedObjectInterfaceType = this.getSymbolFromDeclPath("Object", [], 16 /* Interface */); + } + + if (!this._cachedObjectInterfaceType) { + this._cachedObjectInterfaceType = this.semanticInfoChain.anyTypeSymbol; + } + + if (!this._cachedObjectInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedObjectInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedObjectInterfaceType; + }; + + PullTypeResolver.prototype.cachedFunctionInterfaceType = function () { + if (!this._cachedFunctionInterfaceType) { + this._cachedFunctionInterfaceType = this.getSymbolFromDeclPath("Function", [], 16 /* Interface */); + } + + if (this._cachedFunctionInterfaceType && !this._cachedFunctionInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedFunctionInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedFunctionInterfaceType; + }; + + PullTypeResolver.prototype.cachedIArgumentsInterfaceType = function () { + if (!this._cachedIArgumentsInterfaceType) { + this._cachedIArgumentsInterfaceType = this.getSymbolFromDeclPath("IArguments", [], 16 /* Interface */); + } + + if (this._cachedIArgumentsInterfaceType && !this._cachedIArgumentsInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedIArgumentsInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedIArgumentsInterfaceType; + }; + + PullTypeResolver.prototype.cachedRegExpInterfaceType = function () { + if (!this._cachedRegExpInterfaceType) { + this._cachedRegExpInterfaceType = this.getSymbolFromDeclPath("RegExp", [], 16 /* Interface */); + } + + if (this._cachedRegExpInterfaceType && !this._cachedRegExpInterfaceType.isResolved) { + this.resolveDeclaredSymbol(this._cachedRegExpInterfaceType, new TypeScript.PullTypeResolutionContext(this)); + } + + return this._cachedRegExpInterfaceType; + }; + + PullTypeResolver.prototype.cachedFunctionArgumentsSymbol = function () { + if (!this._cachedFunctionArgumentsSymbol) { + this._cachedFunctionArgumentsSymbol = new TypeScript.PullSymbol("arguments", 512 /* Variable */); + this._cachedFunctionArgumentsSymbol.type = this.cachedIArgumentsInterfaceType() ? this.cachedIArgumentsInterfaceType() : this.semanticInfoChain.anyTypeSymbol; + this._cachedFunctionArgumentsSymbol.setResolved(); + + var functionArgumentsDecl = new TypeScript.PullSynthesizedDecl("arguments", "arguments", 2048 /* Parameter */, 0 /* None */, null, new TypeScript.TextSpan(0, 0), this.semanticInfoChain); + functionArgumentsDecl.setSymbol(this._cachedFunctionArgumentsSymbol); + this._cachedFunctionArgumentsSymbol.addDeclaration(functionArgumentsDecl); + } + + return this._cachedFunctionArgumentsSymbol; + }; + + PullTypeResolver.prototype.setTypeChecked = function (ast, context) { + context.setTypeChecked(ast); + }; + + PullTypeResolver.prototype.canTypeCheckAST = function (ast, context) { + return context.canTypeCheckAST(ast); + }; + + PullTypeResolver.prototype.setSymbolForAST = function (ast, symbol, context) { + if (context && context.inProvisionalResolution()) { + context.setSymbolForAST(ast, symbol); + } else { + this.semanticInfoChain.setSymbolForAST(ast, symbol); + } + }; + + PullTypeResolver.prototype.getSymbolForAST = function (ast, context) { + var symbol = this.semanticInfoChain.getSymbolForAST(ast); + + if (!symbol) { + if (context && context.inProvisionalResolution()) { + symbol = context.getSymbolForAST(ast); + } + } + + return symbol; + }; + + PullTypeResolver.prototype.getASTForDecl = function (decl) { + return this.semanticInfoChain.getASTForDecl(decl); + }; + + PullTypeResolver.prototype.getNewErrorTypeSymbol = function (name) { + if (typeof name === "undefined") { name = null; } + return new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, name); + }; + + PullTypeResolver.prototype.getEnclosingDecl = function (decl) { + var declPath = decl.getParentPath(); + + if (declPath.length > 1 && declPath[declPath.length - 1] === decl) { + return declPath[declPath.length - 2]; + } else { + return declPath[declPath.length - 1]; + } + }; + + PullTypeResolver.prototype.getExportedMemberSymbol = function (symbol, parent) { + if (!(symbol.kind & (65536 /* Method */ | 4096 /* Property */))) { + var isContainer = (parent.kind & (4 /* Container */ | 32 /* DynamicModule */)) != 0; + var containerType = !isContainer ? parent.getAssociatedContainerType() : parent; + + if (isContainer && containerType) { + if (symbol.anyDeclHasFlag(1 /* Exported */)) { + return symbol; + } + + return null; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.getMemberSymbol = function (symbolName, declSearchKind, parent) { + var member = null; + + if (declSearchKind & 68147712 /* SomeValue */) { + member = parent.findMember(symbolName, true); + } else if (declSearchKind & 58728539 /* SomeType */) { + member = parent.findNestedType(symbolName); + } else if (declSearchKind & 164 /* SomeContainer */) { + member = parent.findNestedContainer(symbolName); + } + + if (member) { + return this.getExportedMemberSymbol(member, parent); + } + + var containerType = parent.getAssociatedContainerType(); + + if (containerType) { + if (containerType.isClass()) { + return null; + } + + parent = containerType; + + if (declSearchKind & 68147712 /* SomeValue */) { + member = parent.findMember(symbolName, true); + } else if (declSearchKind & 58728539 /* SomeType */) { + member = parent.findNestedType(symbolName); + } else if (declSearchKind & 164 /* SomeContainer */) { + member = parent.findNestedContainer(symbolName); + } + + if (member) { + return this.getExportedMemberSymbol(member, parent); + } + } + + if (parent.kind & 164 /* SomeContainer */) { + var typeDeclarations = parent.getDeclarations(); + var childDecls = null; + + for (var j = 0; j < typeDeclarations.length; j++) { + childDecls = typeDeclarations[j].searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + member = childDecls[0].getSymbol(); + + if (!member) { + member = childDecls[0].getSignatureSymbol(); + } + return this.getExportedMemberSymbol(member, parent); + } + + if ((declSearchKind & 58728539 /* SomeType */) != 0 || (declSearchKind & 68147712 /* SomeValue */) != 0) { + childDecls = typeDeclarations[j].searchChildDecls(symbolName, 128 /* TypeAlias */); + if (childDecls.length && childDecls[0].kind == 128 /* TypeAlias */) { + var aliasSymbol = this.getExportedMemberSymbol(childDecls[0].getSymbol(), parent); + if (aliasSymbol) { + if ((declSearchKind & 58728539 /* SomeType */) != 0) { + var typeSymbol = aliasSymbol.getExportAssignedTypeSymbol(); + if (typeSymbol) { + return typeSymbol; + } + } else { + var valueSymbol = aliasSymbol.getExportAssignedValueSymbol(); + if (valueSymbol) { + return valueSymbol; + } + } + } + } + } + } + } + }; + + PullTypeResolver.prototype.getSymbolFromDeclPath = function (symbolName, declPath, declSearchKind) { + var symbol = null; + + var decl = null; + var childDecls; + var declSymbol = null; + var declMembers; + var pathDeclKind; + var valDecl = null; + var kind; + var instanceSymbol = null; + var instanceType = null; + var childSymbol = null; + + for (var i = declPath.length - 1; i >= 0; i--) { + decl = declPath[i]; + pathDeclKind = decl.kind; + + if (decl.flags & 2097152 /* DeclaredInAWithBlock */) { + return this.semanticInfoChain.anyTypeSymbol; + } + + if (pathDeclKind & (4 /* Container */ | 32 /* DynamicModule */)) { + childDecls = decl.searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + return childDecls[0].getSymbol(); + } + + if (declSearchKind & 68147712 /* SomeValue */) { + instanceSymbol = decl.getSymbol().getInstanceSymbol(); + + childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */); + + if (childDecls.length) { + var sym = childDecls[0].getSymbol(); + + if (sym.isAlias()) { + return sym; + } + } + + if (instanceSymbol) { + instanceType = instanceSymbol.type; + + childSymbol = this.getMemberSymbol(symbolName, declSearchKind, instanceType); + + if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) { + return childSymbol; + } + } + + valDecl = decl.getValueDecl(); + + if (valDecl) { + decl = valDecl; + } + } + + declSymbol = decl.getSymbol().type; + + var childSymbol = this.getMemberSymbol(symbolName, declSearchKind, declSymbol); + + if (childSymbol && (childSymbol.kind & declSearchKind) && !childSymbol.anyDeclHasFlag(16 /* Static */)) { + return childSymbol; + } + } else if ((declSearchKind & (58728539 /* SomeType */ | 164 /* SomeContainer */)) || !(pathDeclKind & 8 /* Class */)) { + var candidateSymbol = null; + + if (pathDeclKind === 131072 /* FunctionExpression */ && symbolName === decl.getFunctionExpressionName()) { + candidateSymbol = decl.getSymbol(); + } + + childDecls = decl.searchChildDecls(symbolName, declSearchKind); + + if (childDecls.length) { + if (decl.kind & 1032192 /* SomeFunction */) { + decl.ensureSymbolIsBound(); + } + return childDecls[0].getSymbol(); + } + + if (candidateSymbol) { + return candidateSymbol; + } + + if (declSearchKind & 68147712 /* SomeValue */) { + childDecls = decl.searchChildDecls(symbolName, 128 /* TypeAlias */); + + if (childDecls.length) { + var sym = childDecls[0].getSymbol(); + + if (sym.isAlias()) { + return sym; + } + } + } + } + } + + symbol = this.semanticInfoChain.findSymbol([symbolName], declSearchKind); + + return symbol; + }; + + PullTypeResolver.prototype.getVisibleDeclsFromDeclPath = function (declPath, declSearchKind) { + var result = []; + var decl = null; + var childDecls; + var pathDeclKind; + + for (var i = declPath.length - 1; i >= 0; i--) { + decl = declPath[i]; + pathDeclKind = decl.kind; + + var declKind = decl.kind; + + if (declKind !== 8 /* Class */ && declKind !== 16 /* Interface */) { + this.addFilteredDecls(decl.getChildDecls(), declSearchKind, result); + } + + switch (declKind) { + case 4 /* Container */: + case 32 /* DynamicModule */: + var otherDecls = this.semanticInfoChain.findDeclsFromPath(declPath.slice(0, i + 1), 164 /* SomeContainer */); + for (var j = 0, m = otherDecls.length; j < m; j++) { + var otherDecl = otherDecls[j]; + if (otherDecl === decl) { + continue; + } + + var otherDeclChildren = otherDecl.getChildDecls(); + for (var k = 0, s = otherDeclChildren.length; k < s; k++) { + var otherDeclChild = otherDeclChildren[k]; + if ((otherDeclChild.flags & 1 /* Exported */) && (otherDeclChild.kind & declSearchKind)) { + result.push(otherDeclChild); + } + } + } + + break; + + case 8 /* Class */: + case 16 /* Interface */: + var parameters = decl.getTypeParameters(); + if (parameters && parameters.length) { + this.addFilteredDecls(parameters, declSearchKind, result); + } + + break; + + case 131072 /* FunctionExpression */: + var functionExpressionName = decl.getFunctionExpressionName(); + if (functionExpressionName) { + result.push(decl); + } + + case 16384 /* Function */: + case 32768 /* ConstructorMethod */: + case 65536 /* Method */: + var parameters = decl.getTypeParameters(); + if (parameters && parameters.length) { + this.addFilteredDecls(parameters, declSearchKind, result); + } + + break; + } + } + + var topLevelDecls = this.semanticInfoChain.topLevelDecls(); + for (var i = 0, n = topLevelDecls.length; i < n; i++) { + var topLevelDecl = topLevelDecls[i]; + if (declPath.length > 0 && topLevelDecl.fileName() === declPath[0].fileName()) { + continue; + } + + if (!topLevelDecl.isExternalModule()) { + this.addFilteredDecls(topLevelDecl.getChildDecls(), declSearchKind, result); + } + } + + return result; + }; + + PullTypeResolver.prototype.addFilteredDecls = function (decls, declSearchKind, result) { + if (decls.length) { + for (var i = 0, n = decls.length; i < n; i++) { + var decl = decls[i]; + if (decl.kind & declSearchKind) { + result.push(decl); + } + } + } + }; + + PullTypeResolver.prototype.getVisibleDecls = function (enclosingDecl) { + var declPath = enclosingDecl.getParentPath(); + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + + return this.getVisibleDeclsFromDeclPath(declPath, declSearchKind); + }; + + PullTypeResolver.prototype.getVisibleContextSymbols = function (enclosingDecl, context) { + var contextualTypeSymbol = context.getContextualType(); + if (!contextualTypeSymbol || this.isAnyOrEquivalent(contextualTypeSymbol)) { + return null; + } + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + var members = contextualTypeSymbol.getAllMembers(declSearchKind, 2 /* externallyVisible */); + + for (var i = 0; i < members.length; i++) { + members[i].setUnresolved(); + } + + return members; + }; + + PullTypeResolver.prototype.getVisibleMembersFromExpression = function (expression, enclosingDecl, context) { + var lhs = this.resolveAST(expression, false, context); + + if (isTypesOnlyLocation(expression) && (lhs.kind === 8 /* Class */ || lhs.kind === 16 /* Interface */)) { + return null; + } + + var lhsType = lhs.type; + if (!lhsType) { + return null; + } + + this.resolveDeclaredSymbol(lhsType, context); + + if (lhsType.isContainer() && lhsType.isAlias()) { + lhsType = lhsType.getExportAssignedTypeSymbol(); + } + + while (lhsType.isTypeParameter()) { + lhsType = lhsType.getConstraint(); + if (!lhsType) { + return null; + } + } + + if (this.isAnyOrEquivalent(lhsType)) { + return null; + } + + var memberVisibilty = 2 /* externallyVisible */; + var containerSymbol = lhsType; + if (containerSymbol.kind === 33554432 /* ConstructorType */) { + containerSymbol = containerSymbol.getConstructSignatures()[0].returnType; + } + + if (containerSymbol && containerSymbol.isClass()) { + var declPath = enclosingDecl.getParentPath(); + if (declPath && declPath.length) { + var declarations = containerSymbol.getDeclarations(); + for (var i = 0, n = declarations.length; i < n; i++) { + var declaration = declarations[i]; + if (TypeScript.ArrayUtilities.contains(declPath, declaration)) { + memberVisibilty = 1 /* internallyVisible */; + break; + } + } + } + } + + var declSearchKind = 58728539 /* SomeType */ | 164 /* SomeContainer */ | 68147712 /* SomeValue */; + + var members = []; + + if (lhsType.isContainer()) { + var exportedAssignedContainerSymbol = lhsType.getExportAssignedContainerSymbol(); + if (exportedAssignedContainerSymbol) { + lhsType = exportedAssignedContainerSymbol; + } + } + + if (lhsType.isTypeParameter()) { + var constraint = lhsType.getConstraint(); + + if (constraint) { + lhsType = constraint; + members = lhsType.getAllMembers(declSearchKind, 2 /* externallyVisible */); + } + } else { + if (lhs.kind == 67108864 /* EnumMember */) { + lhsType = this.semanticInfoChain.numberTypeSymbol; + } + + if (lhsType === this.semanticInfoChain.numberTypeSymbol && this.cachedNumberInterfaceType()) { + lhsType = this.cachedNumberInterfaceType(); + } else if (lhsType === this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + lhsType = this.cachedStringInterfaceType(); + } else if (lhsType === this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + lhsType = this.cachedBooleanInterfaceType(); + } + + if (!lhsType.isResolved) { + var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context); + + if (potentiallySpecializedType != lhsType) { + if (!lhs.isType()) { + context.setTypeInContext(lhs, potentiallySpecializedType); + } + + lhsType = potentiallySpecializedType; + } + } + + members = lhsType.getAllMembers(declSearchKind, memberVisibilty); + + if (lhsType.isContainer()) { + var associatedInstance = lhsType.getInstanceSymbol(); + if (associatedInstance) { + var instanceType = associatedInstance.type; + this.resolveDeclaredSymbol(instanceType, context); + var instanceMembers = instanceType.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(instanceMembers); + } + + var exportedContainer = lhsType.getExportAssignedContainerSymbol(); + if (exportedContainer) { + var exportedContainerMembers = exportedContainer.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(exportedContainerMembers); + } + } else if (!lhsType.isConstructor()) { + var associatedContainerSymbol = lhsType.getAssociatedContainerType(); + if (associatedContainerSymbol) { + var containerType = associatedContainerSymbol.type; + this.resolveDeclaredSymbol(containerType, context); + var containerMembers = containerType.getAllMembers(declSearchKind, memberVisibilty); + members = members.concat(containerMembers); + } + } + } + + if ((lhsType.getCallSignatures().length || lhsType.getConstructSignatures().length) && this.cachedFunctionInterfaceType()) { + members = members.concat(this.cachedFunctionInterfaceType().getAllMembers(declSearchKind, 2 /* externallyVisible */)); + } + + return members; + }; + + PullTypeResolver.prototype.isAnyOrEquivalent = function (type) { + return (type === this.semanticInfoChain.anyTypeSymbol) || type.isError(); + }; + + PullTypeResolver.prototype.resolveExternalModuleReference = function (idText, currentFileName) { + var originalIdText = idText; + var symbol = null; + + if (TypeScript.isRelative(originalIdText)) { + var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName)); + symbol = this.semanticInfoChain.findExternalModule(path + idText); + } else { + idText = originalIdText; + + symbol = this.semanticInfoChain.findAmbientExternalModuleInGlobalContext(TypeScript.quoteStr(originalIdText)); + + if (!symbol) { + var path = TypeScript.getRootFilePath(TypeScript.switchToForwardSlashes(currentFileName)); + + while (symbol === null && path != "") { + symbol = this.semanticInfoChain.findExternalModule(path + idText); + if (symbol === null) { + if (path === '/') { + path = ''; + } else { + path = TypeScript.normalizePath(path + ".."); + path = path && path != '/' ? path + '/' : path; + } + } + } + } + } + + return symbol; + }; + + PullTypeResolver.prototype.resolveDeclaredSymbol = function (symbol, context) { + if (!symbol || symbol.isResolved || symbol.isTypeReference()) { + return symbol; + } + + if (!context) { + context = new TypeScript.PullTypeResolutionContext(this); + } + + return this.resolveDeclaredSymbolWorker(symbol, context); + }; + + PullTypeResolver.prototype.resolveDeclaredSymbolWorker = function (symbol, context) { + if (!symbol || symbol.isResolved) { + return symbol; + } + + if (symbol.inResolution) { + if (!symbol.type && !symbol.isType()) { + symbol.type = this.semanticInfoChain.anyTypeSymbol; + } + + return symbol; + } + + var decls = symbol.getDeclarations(); + + for (var i = 0; i < decls.length; i++) { + var decl = decls[i]; + + var ast = this.semanticInfoChain.getASTForDecl(decl); + + if (!ast || (ast.kind() === 139 /* GetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (ast.kind() === 140 /* SetAccessor */ && ast.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) { + return symbol; + } + + if (ast.kind() === 11 /* IdentifierName */ && ast.parent && ast.parent.kind() === 236 /* CatchClause */) { + return symbol; + } + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(ast); + var resolvedSymbol; + if (TypeScript.isAnyNameOfModule(enclosingModule, ast)) { + resolvedSymbol = this.resolveSingleModuleDeclaration(enclosingModule, ast, context); + } else if (ast.kind() === 120 /* SourceUnit */ && decl.kind === 32 /* DynamicModule */) { + resolvedSymbol = this.resolveModuleSymbol(decl.getSymbol(), context, null, null, ast); + } else { + TypeScript.Debug.assert(ast.kind() != 11 /* IdentifierName */ && ast.kind() != 212 /* MemberAccessExpression */); + var resolvedSymbol = this.resolveAST(ast, false, context); + } + + if (decl.kind == 2048 /* Parameter */ && !symbol.isResolved && !symbol.type && resolvedSymbol && symbol.anyDeclHasFlag(8388608 /* PropertyParameter */ | 67108864 /* ConstructorParameter */)) { + symbol.type = resolvedSymbol.type; + symbol.setResolved(); + } + } + + return symbol; + }; + + PullTypeResolver.prototype.resolveOtherDeclarations = function (astName, context) { + var resolvedDecl = this.semanticInfoChain.getDeclForAST(astName); + var symbol = resolvedDecl.getSymbol(); + + var allDecls = symbol.getDeclarations(); + for (var i = 0; i < allDecls.length; i++) { + var currentDecl = allDecls[i]; + var astForCurrentDecl = this.getASTForDecl(currentDecl); + if (astForCurrentDecl != astName) { + var moduleDecl = TypeScript.getEnclosingModuleDeclaration(astForCurrentDecl); + if (TypeScript.isAnyNameOfModule(moduleDecl, astForCurrentDecl)) { + this.resolveSingleModuleDeclaration(moduleDecl, astForCurrentDecl, context); + } else { + this.resolveAST(astForCurrentDecl, false, context); + } + } + } + }; + + PullTypeResolver.prototype.resolveSourceUnit = function (sourceUnit, context) { + var enclosingDecl = this.getEnclosingDeclForAST(sourceUnit); + var moduleSymbol = enclosingDecl.getSymbol(); + this.ensureAllSymbolsAreBound(moduleSymbol); + + this.resolveFirstExportAssignmentStatement(sourceUnit.moduleElements, context); + this.resolveAST(sourceUnit.moduleElements, false, context); + + if (this.canTypeCheckAST(sourceUnit, context)) { + this.typeCheckSourceUnit(sourceUnit, context); + } + + return moduleSymbol; + }; + + PullTypeResolver.prototype.typeCheckSourceUnit = function (sourceUnit, context) { + this.setTypeChecked(sourceUnit, context); + + this.resolveAST(sourceUnit.moduleElements, false, context); + }; + + PullTypeResolver.prototype.resolveEnumDeclaration = function (ast, context) { + var containerDecl = this.semanticInfoChain.getDeclForAST(ast); + var containerSymbol = containerDecl.getSymbol(); + + if (containerSymbol.isResolved || containerSymbol.inResolution) { + return containerSymbol; + } + + containerSymbol.inResolution = true; + + var containerDecls = containerSymbol.getDeclarations(); + + for (var i = 0; i < containerDecls.length; i++) { + var childDecls = containerDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + + containerSymbol.setResolved(); + + this.resolveOtherDeclarations(ast, context); + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckEnumDeclaration(ast, context); + } + + return containerSymbol; + }; + + PullTypeResolver.prototype.typeCheckEnumDeclaration = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.enumElements, false, context); + var containerDecl = this.semanticInfoChain.getDeclForAST(ast); + this.validateVariableDeclarationGroups(containerDecl, context); + + if (!TypeScript.enumIsElided(ast)) { + this.checkNameForCompilerGeneratedDeclarationCollision(ast, true, ast.identifier, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckEnumDeclaration = function (ast, context) { + this.checkThisCaptureVariableCollides(ast, true, context); + }; + + PullTypeResolver.prototype.resolveModuleDeclaration = function (ast, context) { + var result; + + if (ast.stringLiteral) { + result = this.resolveSingleModuleDeclaration(ast, ast.stringLiteral, context); + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + result = this.resolveSingleModuleDeclaration(ast, moduleNames[i], context); + } + } + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckModuleDeclaration(ast, context); + } + + return result; + }; + + PullTypeResolver.prototype.ensureAllSymbolsAreBound = function (containerSymbol) { + if (containerSymbol) { + var containerDecls = containerSymbol.getDeclarations(); + + for (var i = 0; i < containerDecls.length; i++) { + var childDecls = containerDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + } + }; + + PullTypeResolver.prototype.resolveModuleSymbol = function (containerSymbol, context, moduleDeclAST, moduleDeclNameAST, sourceUnitAST) { + if (containerSymbol.isResolved || containerSymbol.inResolution) { + return containerSymbol; + } + + containerSymbol.inResolution = true; + this.ensureAllSymbolsAreBound(containerSymbol); + + var instanceSymbol = containerSymbol.getInstanceSymbol(); + + if (instanceSymbol) { + this.resolveDeclaredSymbol(instanceSymbol, context); + } + + var isLastName = TypeScript.isLastNameOfModule(moduleDeclAST, moduleDeclNameAST); + if (isLastName) { + this.resolveFirstExportAssignmentStatement(moduleDeclAST.moduleElements, context); + } else if (sourceUnitAST) { + this.resolveFirstExportAssignmentStatement(sourceUnitAST.moduleElements, context); + } + + containerSymbol.setResolved(); + + if (moduleDeclNameAST) { + this.resolveOtherDeclarations(moduleDeclNameAST, context); + } + + return containerSymbol; + }; + + PullTypeResolver.prototype.resolveFirstExportAssignmentStatement = function (moduleElements, context) { + for (var i = 0, n = moduleElements.childCount(); i < n; i++) { + var moduleElement = moduleElements.childAt(i); + if (moduleElement.kind() == 134 /* ExportAssignment */) { + this.resolveExportAssignmentStatement(moduleElement, context); + return; + } + } + }; + + PullTypeResolver.prototype.resolveSingleModuleDeclaration = function (ast, astName, context) { + var containerDecl = this.semanticInfoChain.getDeclForAST(astName); + var containerSymbol = containerDecl.getSymbol(); + + return this.resolveModuleSymbol(containerSymbol, context, ast, astName, null); + }; + + PullTypeResolver.prototype.typeCheckModuleDeclaration = function (ast, context) { + if (ast.stringLiteral) { + this.typeCheckSingleModuleDeclaration(ast, ast.stringLiteral, context); + } else { + var moduleNames = TypeScript.getModuleNames(ast.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + this.typeCheckSingleModuleDeclaration(ast, moduleNames[i], context); + } + } + }; + + PullTypeResolver.prototype.typeCheckSingleModuleDeclaration = function (ast, astName, context) { + this.setTypeChecked(ast, context); + + if (TypeScript.isLastNameOfModule(ast, astName)) { + this.resolveAST(ast.moduleElements, false, context); + } + + var containerDecl = this.semanticInfoChain.getDeclForAST(astName); + this.validateVariableDeclarationGroups(containerDecl, context); + + if (ast.stringLiteral) { + if (TypeScript.isRelative(ast.stringLiteral.valueText())) { + this.semanticInfoChain.addDiagnosticFromAST(ast.stringLiteral, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_specify_relative_module_name); + } + } + + if (!TypeScript.moduleIsElided(ast) && !ast.stringLiteral) { + this.checkNameForCompilerGeneratedDeclarationCollision(astName, true, astName, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckModuleDeclaration = function (ast, context) { + this.checkThisCaptureVariableCollides(ast, true, context); + }; + + PullTypeResolver.prototype.isTypeRefWithoutTypeArgs = function (term) { + if (term.kind() == 11 /* IdentifierName */) { + return true; + } else if (term.kind() == 121 /* QualifiedName */) { + var binex = term; + + if (binex.right.kind() == 11 /* IdentifierName */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.createInstantiatedType = function (type, typeArguments) { + if (!type.isGeneric()) { + return type; + } + + var typeParameters = type.getTypeArgumentsOrTypeParameters(); + + var typeParameterArgumentMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterArgumentMap[typeParameters[i].pullSymbolID] = typeArguments[i] || new TypeScript.PullErrorTypeSymbol(this.semanticInfoChain.anyTypeSymbol, typeParameters[i].name); + } + + return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap); + }; + + PullTypeResolver.prototype.resolveReferenceTypeDeclaration = function (classOrInterface, name, heritageClauses, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(typeDecl); + var typeDeclSymbol = typeDecl.getSymbol(); + var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */; + var hasVisited = this.getSymbolForAST(classOrInterface, context) != null; + + if ((typeDeclSymbol.isResolved && hasVisited) || (typeDeclSymbol.inResolution && !context.isInBaseTypeResolution())) { + return typeDeclSymbol; + } + + var wasResolving = typeDeclSymbol.inResolution; + typeDeclSymbol.startResolving(); + + if (!typeDeclSymbol.isResolved) { + var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters(); + for (var i = 0; i < typeDeclTypeParameters.length; i++) { + this.resolveDeclaredSymbol(typeDeclTypeParameters[i], context); + } + } + + var typeRefDecls = typeDeclSymbol.getDeclarations(); + + for (var i = 0; i < typeRefDecls.length; i++) { + var childDecls = typeRefDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + + var wasInBaseTypeResolution = context.startBaseTypeResolution(); + + if (!typeDeclIsClass && !hasVisited) { + typeDeclSymbol.resetKnownBaseTypeCount(); + } + + var extendsClause = TypeScript.getExtendsHeritageClause(heritageClauses); + if (extendsClause) { + for (var i = typeDeclSymbol.getKnownBaseTypeCount(); i < extendsClause.typeNames.nonSeparatorCount(); i = typeDeclSymbol.getKnownBaseTypeCount()) { + typeDeclSymbol.incrementKnownBaseCount(); + var parentType = this.resolveTypeReference(extendsClause.typeNames.nonSeparatorAt(i), context); + + if (typeDeclSymbol.isValidBaseKind(parentType, true)) { + this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null); + + if (!typeDeclSymbol.hasBase(parentType) && !parentType.hasBase(typeDeclSymbol)) { + typeDeclSymbol.addExtendedType(parentType); + + var specializations = typeDeclSymbol.getKnownSpecializations(); + + for (var j = 0; j < specializations.length; j++) { + specializations[j].addExtendedType(parentType); + } + } + } else if (parentType && !this.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), context)) { + this.setSymbolForAST(extendsClause.typeNames.nonSeparatorAt(i), parentType, null); + } + } + } + + var implementsClause = TypeScript.getImplementsHeritageClause(heritageClauses); + if (implementsClause && typeDeclIsClass) { + var extendsCount = extendsClause ? extendsClause.typeNames.nonSeparatorCount() : 0; + for (var i = typeDeclSymbol.getKnownBaseTypeCount(); ((i - extendsCount) >= 0) && ((i - extendsCount) < implementsClause.typeNames.nonSeparatorCount()); i = typeDeclSymbol.getKnownBaseTypeCount()) { + typeDeclSymbol.incrementKnownBaseCount(); + var implementedTypeAST = implementsClause.typeNames.nonSeparatorAt(i - extendsCount); + var implementedType = this.resolveTypeReference(implementedTypeAST, context); + + if (typeDeclSymbol.isValidBaseKind(implementedType, false)) { + this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null); + + if (!typeDeclSymbol.hasBase(implementedType) && !implementedType.hasBase(typeDeclSymbol)) { + typeDeclSymbol.addImplementedType(implementedType); + } + } else if (implementedType && !this.getSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), context)) { + this.setSymbolForAST(implementsClause.typeNames.nonSeparatorAt(i - extendsCount), implementedType, null); + } + } + } + + context.doneBaseTypeResolution(wasInBaseTypeResolution); + + if (wasInBaseTypeResolution) { + typeDeclSymbol.inResolution = false; + + this.typeCheckCallBacks.push(function (context) { + if (classOrInterface.kind() == 131 /* ClassDeclaration */) { + _this.resolveClassDeclaration(classOrInterface, context); + } else { + _this.resolveInterfaceDeclaration(classOrInterface, context); + } + }); + + return typeDeclSymbol; + } + + if (!typeDeclSymbol.isResolved) { + if (!typeDeclIsClass) { + var callSignatures = typeDeclSymbol.getCallSignatures(); + for (var i = 0; i < callSignatures.length; i++) { + this.resolveDeclaredSymbol(callSignatures[i], context); + } + + var constructSignatures = typeDeclSymbol.getConstructSignatures(); + for (var i = 0; i < constructSignatures.length; i++) { + this.resolveDeclaredSymbol(constructSignatures[i], context); + } + + var indexSignatures = typeDeclSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignatures.length; i++) { + this.resolveDeclaredSymbol(indexSignatures[i], context); + } + } + } + + this.setSymbolForAST(name, typeDeclSymbol, context); + this.setSymbolForAST(classOrInterface, typeDeclSymbol, context); + + typeDeclSymbol.setResolved(); + + return typeDeclSymbol; + }; + + PullTypeResolver.prototype.resolveClassDeclaration = function (classDeclAST, context) { + var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST); + var classDeclSymbol = classDecl.getSymbol(); + if (!classDeclSymbol.isResolved) { + this.resolveReferenceTypeDeclaration(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, context); + + var constructorMethod = classDeclSymbol.getConstructorMethod(); + var extendedTypes = classDeclSymbol.getExtendedTypes(); + var parentType = extendedTypes.length ? extendedTypes[0] : null; + + if (constructorMethod) { + var constructorTypeSymbol = constructorMethod.type; + + var constructSignatures = constructorTypeSymbol.getConstructSignatures(); + + if (!constructSignatures.length) { + var constructorSignature; + + var parentConstructor = parentType ? parentType.getConstructorMethod() : null; + + if (parentConstructor) { + this.resolveDeclaredSymbol(parentConstructor, context); + var parentConstructorType = parentConstructor.type; + var parentConstructSignatures = parentConstructorType.getConstructSignatures(); + + var parentConstructSignature; + var parentParameters; + + if (!parentConstructSignatures.length) { + parentConstructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + parentConstructSignature.returnType = parentType; + parentConstructorType.addConstructSignature(parentConstructSignature); + parentConstructSignature.addDeclaration(parentType.getDeclarations()[0]); + + var parentTypeParameters = parentConstructorType.getTypeParameters(); + + for (var i = 0; i < parentTypeParameters.length; i++) { + parentConstructSignature.addTypeParameter(parentTypeParameters[i]); + } + + parentConstructSignatures = [parentConstructSignature]; + } + + for (var i = 0; i < parentConstructSignatures.length; i++) { + parentConstructSignature = parentConstructSignatures[i]; + parentParameters = parentConstructSignature.parameters; + + constructorSignature = parentConstructSignature.isDefinition() ? new TypeScript.PullDefinitionSignatureSymbol(2097152 /* ConstructSignature */) : new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + constructorSignature.returnType = classDeclSymbol; + + for (var j = 0; j < parentParameters.length; j++) { + constructorSignature.addParameter(parentParameters[j], parentParameters[j].isOptional); + } + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var j = 0; j < typeParameters.length; j++) { + constructorSignature.addTypeParameter(typeParameters[j]); + } + + constructorTypeSymbol.addConstructSignature(constructorSignature); + constructorSignature.addDeclaration(classDecl); + } + } else { + constructorSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + constructorSignature.returnType = classDeclSymbol; + constructorTypeSymbol.addConstructSignature(constructorSignature); + constructorSignature.addDeclaration(classDecl); + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var i = 0; i < typeParameters.length; i++) { + constructorSignature.addTypeParameter(typeParameters[i]); + } + } + } + + if (!classDeclSymbol.isResolved) { + return classDeclSymbol; + } + + if (parentType) { + var parentConstructorSymbol = parentType.getConstructorMethod(); + + if (parentConstructorSymbol) { + var parentConstructorTypeSymbol = parentConstructorSymbol.type; + + if (!constructorTypeSymbol.hasBase(parentConstructorTypeSymbol)) { + constructorTypeSymbol.addExtendedType(parentConstructorTypeSymbol); + } + } + } + } + + this.resolveOtherDeclarations(classDeclAST, context); + } + + if (this.canTypeCheckAST(classDeclAST, context)) { + this.typeCheckClassDeclaration(classDeclAST, context); + } + + return classDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckTypeParametersOfTypeDeclaration = function (classOrInterface, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var typeDeclSymbol = typeDecl.getSymbol(); + var typeDeclTypeParameters = typeDeclSymbol.getTypeParameters(); + for (var i = 0; i < typeDeclTypeParameters.length; i++) { + this.checkSymbolPrivacy(typeDeclSymbol, typeDeclTypeParameters[i], function (symbol) { + return _this.typeParameterOfTypeDeclarationPrivacyErrorReporter(classOrInterface, i, typeDeclTypeParameters[i], symbol, context); + }); + } + }; + + PullTypeResolver.prototype.typeCheckClassDeclaration = function (classDeclAST, context) { + this.setTypeChecked(classDeclAST, context); + + var classDecl = this.semanticInfoChain.getDeclForAST(classDeclAST); + var classDeclSymbol = classDecl.getSymbol(); + + this.checkNameForCompilerGeneratedDeclarationCollision(classDeclAST, true, classDeclAST.identifier, context); + this.resolveAST(classDeclAST.classElements, false, context); + + this.typeCheckTypeParametersOfTypeDeclaration(classDeclAST, context); + this.typeCheckBases(classDeclAST, classDeclAST.identifier, classDeclAST.heritageClauses, classDeclSymbol, this.getEnclosingDecl(classDecl), context); + + if (!classDeclSymbol.hasBaseTypeConflict()) { + this.typeCheckMembersAgainstIndexer(classDeclSymbol, classDecl, context); + } + }; + + PullTypeResolver.prototype.postTypeCheckClassDeclaration = function (classDeclAST, context) { + this.checkThisCaptureVariableCollides(classDeclAST, true, context); + }; + + PullTypeResolver.prototype.resolveTypeSymbolSignatures = function (typeSymbol, context) { + var callSignatures = typeSymbol.getCallSignatures(); + for (var i = 0; i < callSignatures.length; i++) { + this.resolveDeclaredSymbol(callSignatures[i], context); + } + + var constructSignatures = typeSymbol.getConstructSignatures(); + for (var i = 0; i < constructSignatures.length; i++) { + this.resolveDeclaredSymbol(constructSignatures[i], context); + } + + var indexSignatures = typeSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignatures.length; i++) { + this.resolveDeclaredSymbol(indexSignatures[i], context); + } + }; + + PullTypeResolver.prototype.resolveInterfaceDeclaration = function (interfaceDeclAST, context) { + this.resolveReferenceTypeDeclaration(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, context); + + var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST); + var interfaceDeclSymbol = interfaceDecl.getSymbol(); + + this.resolveTypeSymbolSignatures(interfaceDeclSymbol, context); + + if (interfaceDeclSymbol.isResolved) { + this.resolveOtherDeclarations(interfaceDeclAST, context); + + if (this.canTypeCheckAST(interfaceDeclAST, context)) { + this.typeCheckInterfaceDeclaration(interfaceDeclAST, context); + } + } + + return interfaceDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckInterfaceDeclaration = function (interfaceDeclAST, context) { + this.setTypeChecked(interfaceDeclAST, context); + + var interfaceDecl = this.semanticInfoChain.getDeclForAST(interfaceDeclAST); + var interfaceDeclSymbol = interfaceDecl.getSymbol(); + + this.resolveAST(interfaceDeclAST.body.typeMembers, false, context); + + this.typeCheckTypeParametersOfTypeDeclaration(interfaceDeclAST, context); + this.typeCheckBases(interfaceDeclAST, interfaceDeclAST.identifier, interfaceDeclAST.heritageClauses, interfaceDeclSymbol, this.getEnclosingDecl(interfaceDecl), context); + + if (!interfaceDeclSymbol.hasBaseTypeConflict()) { + this.typeCheckMembersAgainstIndexer(interfaceDeclSymbol, interfaceDecl, context); + } + }; + + PullTypeResolver.prototype.filterSymbol = function (symbol, kind, enclosingDecl, context) { + if (symbol) { + if (symbol.kind & kind) { + return symbol; + } + + if (symbol.isAlias()) { + this.resolveDeclaredSymbol(symbol, context); + + var alias = symbol; + if (kind & 164 /* SomeContainer */) { + return alias.getExportAssignedContainerSymbol(); + } else if (kind & 58728539 /* SomeType */) { + return alias.getExportAssignedTypeSymbol(); + } else if (kind & 68147712 /* SomeValue */) { + return alias.getExportAssignedValueSymbol(); + } + } + } + return null; + }; + + PullTypeResolver.prototype.getMemberSymbolOfKind = function (symbolName, kind, pullTypeSymbol, enclosingDecl, context) { + var memberSymbol = this.getMemberSymbol(symbolName, kind, pullTypeSymbol); + + return { + symbol: this.filterSymbol(memberSymbol, kind, enclosingDecl, context), + aliasSymbol: memberSymbol && memberSymbol.isAlias() ? memberSymbol : null + }; + }; + + PullTypeResolver.prototype.resolveIdentifierOfInternalModuleReference = function (importDecl, identifier, moduleSymbol, enclosingDecl, context) { + var rhsName = identifier.valueText(); + if (rhsName.length === 0) { + return null; + } + + var moduleTypeSymbol = moduleSymbol.type; + var memberSymbol = this.getMemberSymbolOfKind(rhsName, 164 /* SomeContainer */, moduleTypeSymbol, enclosingDecl, context); + var containerSymbol = memberSymbol.symbol; + var valueSymbol = null; + var typeSymbol = null; + var aliasSymbol = null; + + var acceptableAlias = true; + + if (containerSymbol) { + acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) != 0; + aliasSymbol = memberSymbol.aliasSymbol; + } + + if (!acceptableAlias && containerSymbol && containerSymbol.kind == 128 /* TypeAlias */) { + this.resolveDeclaredSymbol(containerSymbol, context); + var aliasedAssignedValue = containerSymbol.getExportAssignedValueSymbol(); + var aliasedAssignedType = containerSymbol.getExportAssignedTypeSymbol(); + var aliasedAssignedContainer = containerSymbol.getExportAssignedContainerSymbol(); + + if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) { + aliasSymbol = containerSymbol; + valueSymbol = aliasedAssignedValue; + typeSymbol = aliasedAssignedType; + containerSymbol = aliasedAssignedContainer; + acceptableAlias = true; + } + } + + if (!acceptableAlias) { + this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Import_declaration_referencing_identifier_from_internal_module_can_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules); + return null; + } + + if (!valueSymbol) { + if (moduleTypeSymbol.getInstanceSymbol()) { + memberSymbol = this.getMemberSymbolOfKind(rhsName, 68147712 /* SomeValue */, moduleTypeSymbol.getInstanceSymbol().type, enclosingDecl, context); + valueSymbol = memberSymbol.symbol; + if (valueSymbol && memberSymbol.aliasSymbol) { + aliasSymbol = memberSymbol.aliasSymbol; + } + } + } + + if (!typeSymbol) { + memberSymbol = this.getMemberSymbolOfKind(rhsName, 58728539 /* SomeType */, moduleTypeSymbol, enclosingDecl, context); + typeSymbol = memberSymbol.symbol; + if (typeSymbol && memberSymbol.aliasSymbol) { + aliasSymbol = memberSymbol.aliasSymbol; + } + } + + if (!valueSymbol && !typeSymbol && !containerSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(identifier, TypeScript.DiagnosticCode.Could_not_find_symbol_0_in_module_1, [rhsName, moduleSymbol.toString()]); + return null; + } + + if (!typeSymbol && containerSymbol) { + typeSymbol = containerSymbol; + } + + return { + valueSymbol: valueSymbol, + typeSymbol: typeSymbol, + containerSymbol: containerSymbol, + aliasSymbol: aliasSymbol + }; + }; + + PullTypeResolver.prototype.resolveModuleReference = function (importDecl, moduleNameExpr, enclosingDecl, context, declPath) { + TypeScript.Debug.assert(moduleNameExpr.kind() == 121 /* QualifiedName */ || moduleNameExpr.kind() == 11 /* IdentifierName */ || moduleNameExpr.kind() === 14 /* StringLiteral */, "resolving module reference should always be either name or member reference"); + + var moduleSymbol = null; + var moduleName; + + if (moduleNameExpr.kind() == 121 /* QualifiedName */) { + var dottedNameAST = moduleNameExpr; + var moduleContainer = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath); + if (moduleContainer) { + moduleName = dottedNameAST.right.valueText(); + + moduleSymbol = this.getMemberSymbolOfKind(moduleName, 4 /* Container */, moduleContainer.type, enclosingDecl, context).symbol; + if (!moduleSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.Could_not_find_module_0_in_module_1, [moduleName, moduleContainer.toString()]); + } + } + } else { + var valueText = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.valueText() : moduleNameExpr.valueText(); + var text = moduleNameExpr.kind() === 11 /* IdentifierName */ ? moduleNameExpr.text() : moduleNameExpr.text(); + + if (text.length > 0) { + var resolvedModuleNameSymbol = this.getSymbolFromDeclPath(valueText, declPath, 4 /* Container */); + moduleSymbol = this.filterSymbol(resolvedModuleNameSymbol, 4 /* Container */, enclosingDecl, context); + if (moduleSymbol) { + this.semanticInfoChain.setSymbolForAST(moduleNameExpr, moduleSymbol); + if (resolvedModuleNameSymbol.isAlias()) { + this.semanticInfoChain.setAliasSymbolForAST(moduleNameExpr, resolvedModuleNameSymbol); + } + } else { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameExpr, TypeScript.DiagnosticCode.Unable_to_resolve_module_reference_0, [valueText]); + } + } + } + + return moduleSymbol; + }; + + PullTypeResolver.prototype.resolveInternalModuleReference = function (importStatementAST, context) { + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + + var moduleReference = importStatementAST.moduleReference; + + var aliasExpr = moduleReference.kind() === 245 /* ExternalModuleReference */ ? moduleReference.stringLiteral : moduleReference.moduleName; + + var declPath = enclosingDecl.getParentPath(); + var aliasedType = null; + + if (aliasExpr.kind() === 11 /* IdentifierName */ || aliasExpr.kind() === 14 /* StringLiteral */) { + var moduleSymbol = this.resolveModuleReference(importDecl, aliasExpr, enclosingDecl, context, declPath); + if (moduleSymbol) { + aliasedType = moduleSymbol.type; + this.semanticInfoChain.setAliasSymbolForAST(moduleReference, this.semanticInfoChain.getAliasSymbolForAST(aliasExpr)); + if (aliasedType.anyDeclHasFlag(32768 /* InitializedModule */)) { + var moduleName = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.valueText() : aliasExpr.valueText(); + var valueSymbol = this.getSymbolFromDeclPath(moduleName, declPath, 68147712 /* SomeValue */); + var instanceSymbol = aliasedType.getInstanceSymbol(); + + if (valueSymbol && (instanceSymbol != valueSymbol || valueSymbol.type == aliasedType)) { + var text = aliasExpr.kind() === 11 /* IdentifierName */ ? aliasExpr.text() : aliasExpr.text(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(aliasExpr, TypeScript.DiagnosticCode.Internal_module_reference_0_in_import_declaration_does_not_reference_module_instance_for_1, [text, moduleSymbol.type.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + } else { + var importDeclSymbol = importDecl.getSymbol(); + importDeclSymbol.setAssignedValueSymbol(valueSymbol); + } + } + } else { + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } + } else if (aliasExpr.kind() == 121 /* QualifiedName */) { + var importDeclSymbol = importDecl.getSymbol(); + var dottedNameAST = aliasExpr; + var moduleSymbol = this.resolveModuleReference(importDecl, dottedNameAST.left, enclosingDecl, context, declPath); + if (moduleSymbol) { + var identifierResolution = this.resolveIdentifierOfInternalModuleReference(importDecl, dottedNameAST.right, moduleSymbol, enclosingDecl, context); + if (identifierResolution) { + importDeclSymbol.setAssignedValueSymbol(identifierResolution.valueSymbol); + importDeclSymbol.setAssignedTypeSymbol(identifierResolution.typeSymbol); + importDeclSymbol.setAssignedContainerSymbol(identifierResolution.containerSymbol); + this.semanticInfoChain.setAliasSymbolForAST(moduleReference, identifierResolution.aliasSymbol); + if (identifierResolution.valueSymbol) { + importDeclSymbol.setIsUsedAsValue(true); + } + return null; + } + } + + importDeclSymbol.setAssignedTypeSymbol(this.semanticInfoChain.anyTypeSymbol); + } + + return aliasedType; + }; + + PullTypeResolver.prototype.resolveImportDeclaration = function (importStatementAST, context) { + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + var importDeclSymbol = importDecl.getSymbol(); + + var aliasedType = null; + + if (importDeclSymbol.isResolved) { + return importDeclSymbol; + } + + importDeclSymbol.startResolving(); + + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var modPath = importStatementAST.moduleReference.stringLiteral.valueText(); + var declPath = enclosingDecl.getParentPath(); + + aliasedType = this.resolveExternalModuleReference(modPath, importDecl.fileName()); + + if (!aliasedType) { + var path = importStatementAST.moduleReference.stringLiteral.text(); + this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Unable_to_resolve_external_module_0, [path]); + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } + } else { + aliasedType = this.resolveInternalModuleReference(importStatementAST, context); + } + + if (aliasedType) { + if (!aliasedType.isContainer()) { + this.semanticInfoChain.addDiagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Module_cannot_be_aliased_to_a_non_module_type); + aliasedType = this.semanticInfoChain.anyTypeSymbol; + } else if (aliasedType.getExportAssignedValueSymbol()) { + importDeclSymbol.setIsUsedAsValue(true); + } + + if (aliasedType.isContainer()) { + importDeclSymbol.setAssignedContainerSymbol(aliasedType); + } + importDeclSymbol.setAssignedTypeSymbol(aliasedType); + + this.setSymbolForAST(importStatementAST.moduleReference, aliasedType, null); + } + + importDeclSymbol.setResolved(); + + this.resolveDeclaredSymbol(importDeclSymbol.assignedValue(), context); + this.resolveDeclaredSymbol(importDeclSymbol.assignedType(), context); + this.resolveDeclaredSymbol(importDeclSymbol.assignedContainer(), context); + + if (this.canTypeCheckAST(importStatementAST, context)) { + this.typeCheckImportDeclaration(importStatementAST, context); + } + + return importDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckImportDeclaration = function (importStatementAST, context) { + var _this = this; + this.setTypeChecked(importStatementAST, context); + + var importDecl = this.semanticInfoChain.getDeclForAST(importStatementAST); + var enclosingDecl = this.getEnclosingDecl(importDecl); + var importDeclSymbol = importDecl.getSymbol(); + + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + if (this.compilationSettings.noResolve()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_cannot_refer_to_external_module_reference_when_noResolve_option_is_set, null)); + } + + var modPath = importStatementAST.moduleReference.stringLiteral.valueText(); + if (enclosingDecl.kind === 32 /* DynamicModule */) { + var ast = TypeScript.getEnclosingModuleDeclaration(this.getASTForDecl(enclosingDecl)); + if (ast && ast.kind() === 130 /* ModuleDeclaration */) { + if (TypeScript.isRelative(modPath)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(importStatementAST, TypeScript.DiagnosticCode.Import_declaration_in_an_ambient_external_module_declaration_cannot_reference_external_module_through_relative_external_module_name)); + } + } + } + } + + var checkPrivacy; + if (importStatementAST.moduleReference.kind() === 245 /* ExternalModuleReference */) { + var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol(); + var container = containerSymbol ? containerSymbol.getContainer() : null; + if (container && container.kind == 32 /* DynamicModule */) { + checkPrivacy = true; + } + } else { + checkPrivacy = true; + } + + if (checkPrivacy) { + var typeSymbol = importDeclSymbol.getExportAssignedTypeSymbol(); + var containerSymbol = importDeclSymbol.getExportAssignedContainerSymbol(); + var valueSymbol = importDeclSymbol.getExportAssignedValueSymbol(); + + this.checkSymbolPrivacy(importDeclSymbol, containerSymbol, function (symbol) { + var messageCode = TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_container_that_is_or_is_using_inaccessible_module_1; + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + + if (typeSymbol != containerSymbol) { + this.checkSymbolPrivacy(importDeclSymbol, typeSymbol, function (symbol) { + var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_type_that_has_or_is_using_private_type_1; + + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + } + + if (valueSymbol) { + this.checkSymbolPrivacy(importDeclSymbol, valueSymbol.type, function (symbol) { + var messageCode = symbol.isContainer() && !symbol.isEnum() ? TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_is_using_inaccessible_module_1 : TypeScript.DiagnosticCode.Exported_import_declaration_0_is_assigned_value_with_type_that_has_or_is_using_private_type_1; + var messageArguments = [importDeclSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null), symbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null, false, false, true)]; + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(importStatementAST, messageCode, messageArguments)); + }); + } + } + + if (getCompilerReservedName(importStatementAST.identifier)) { + this.postTypeCheckWorkitems.push(importStatementAST); + } + }; + + PullTypeResolver.prototype.postTypeCheckImportDeclaration = function (importStatementAST, context) { + if (TypeScript.importDeclarationIsElided(importStatementAST, this.semanticInfoChain)) { + this.checkNameForCompilerGeneratedDeclarationCollision(importStatementAST, true, importStatementAST.identifier, context, true); + } + }; + + PullTypeResolver.prototype.resolveExportAssignmentStatement = function (exportAssignmentAST, context) { + var id = exportAssignmentAST.identifier.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var valueSymbol = null; + var typeSymbol = null; + var containerSymbol = null; + + var enclosingDecl = this.getEnclosingDeclForAST(exportAssignmentAST); + var parentSymbol = enclosingDecl.getSymbol(); + + if (!parentSymbol.isType() && parentSymbol.isContainer()) { + this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_used_at_the_top_level_of_external_modules); + return this.semanticInfoChain.anyTypeSymbol; + } + + var declPath = enclosingDecl !== null ? [enclosingDecl] : []; + + containerSymbol = this.getSymbolFromDeclPath(id, declPath, 164 /* SomeContainer */); + + var acceptableAlias = true; + + if (containerSymbol) { + acceptableAlias = (containerSymbol.kind & 59753052 /* AcceptableAlias */) != 0; + } + + if (!acceptableAlias && containerSymbol && containerSymbol.kind == 128 /* TypeAlias */) { + this.resolveDeclaredSymbol(containerSymbol, context); + + var aliasSymbol = containerSymbol; + var aliasedAssignedValue = aliasSymbol.getExportAssignedValueSymbol(); + var aliasedAssignedType = aliasSymbol.getExportAssignedTypeSymbol(); + var aliasedAssignedContainer = aliasSymbol.getExportAssignedContainerSymbol(); + + if (aliasedAssignedValue || aliasedAssignedType || aliasedAssignedContainer) { + valueSymbol = aliasedAssignedValue; + typeSymbol = aliasedAssignedType; + containerSymbol = aliasedAssignedContainer; + aliasSymbol.setTypeUsedExternally(true); + acceptableAlias = true; + } + } + + if (!acceptableAlias) { + this.semanticInfoChain.addDiagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Export_assignments_may_only_be_made_with_variables_functions_classes_interfaces_enums_and_internal_modules); + return this.semanticInfoChain.voidTypeSymbol; + } + + if (!valueSymbol) { + valueSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */); + } + if (!typeSymbol) { + typeSymbol = this.getSymbolFromDeclPath(id, declPath, 58728539 /* SomeType */); + } + + if (!valueSymbol && !typeSymbol && !containerSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(exportAssignmentAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [id])); + return this.semanticInfoChain.voidTypeSymbol; + } + + if (valueSymbol) { + parentSymbol.setExportAssignedValueSymbol(valueSymbol); + } + if (typeSymbol) { + parentSymbol.setExportAssignedTypeSymbol(typeSymbol); + } + if (containerSymbol) { + parentSymbol.setExportAssignedContainerSymbol(containerSymbol); + } + + this.resolveDeclaredSymbol(valueSymbol, context); + this.resolveDeclaredSymbol(typeSymbol, context); + this.resolveDeclaredSymbol(containerSymbol, context); + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveAnyFunctionTypeSignature = function (funcDeclAST, typeParameters, parameterList, returnTypeAnnotation, context) { + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + TypeScript.Debug.assert(functionDecl); + + var funcDeclSymbol = functionDecl.getSymbol(); + + var signature = funcDeclSymbol.kind === 33554432 /* ConstructorType */ ? funcDeclSymbol.getConstructSignatures()[0] : funcDeclSymbol.getCallSignatures()[0]; + + if (returnTypeAnnotation) { + signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context); + } + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + if (parameterList) { + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveFunctionTypeSignatureParameter(parameterList.parameters.nonSeparatorAt(i), signature, functionDecl, context); + } + } + + funcDeclSymbol.setResolved(); + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.setTypeChecked(funcDeclAST, context); + this.typeCheckFunctionOverloads(funcDeclAST, context); + } + + return funcDeclSymbol; + }; + + PullTypeResolver.prototype.resolveFunctionTypeSignatureParameter = function (argDeclAST, signature, enclosingDecl, context) { + var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST); + var paramSymbol = paramDecl.getSymbol(); + + if (argDeclAST.typeAnnotation) { + var typeRef = this.resolveTypeReference(TypeScript.getType(argDeclAST), context); + + if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) { + var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeRef = this.getNewErrorTypeSymbol(); + } + + context.setTypeInContext(paramSymbol, typeRef); + } else { + if (paramSymbol.isVarArg && paramSymbol.type) { + if (this.cachedArrayInterfaceType()) { + context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [paramSymbol.type])); + } else { + context.setTypeInContext(paramSymbol, paramSymbol.type); + } + } else { + context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol); + + if (this.compilationSettings.noImplicitAny()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_function_type_implicitly_has_an_any_type, [argDeclAST.identifier.text()])); + } + } + } + + paramSymbol.setResolved(); + }; + + PullTypeResolver.prototype.resolveFunctionExpressionParameter = function (argDeclAST, id, typeExpr, equalsValueClause, contextParam, enclosingDecl, context) { + var paramDecl = this.semanticInfoChain.getDeclForAST(argDeclAST); + var paramSymbol = paramDecl.getSymbol(); + var contextualType = contextParam && contextParam.type; + var isImplicitAny = false; + + if (typeExpr) { + var typeRef = this.resolveTypeReference(typeExpr, context); + + if (paramSymbol.isVarArg && !typeRef.isArrayNamedTypeReference()) { + var diagnostic = context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeRef = this.getNewErrorTypeSymbol(); + } + + contextualType = typeRef || contextualType; + } + if (contextualType) { + context.setTypeInContext(paramSymbol, contextualType); + } else if (paramSymbol.isVarArg && this.cachedArrayInterfaceType()) { + context.setTypeInContext(paramSymbol, this.createInstantiatedType(this.cachedArrayInterfaceType(), [this.semanticInfoChain.anyTypeSymbol])); + isImplicitAny = true; + } + + var canTypeCheckAST = this.canTypeCheckAST(argDeclAST, context); + if (equalsValueClause && (canTypeCheckAST || !contextualType)) { + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + var initExprSymbol = this.resolveAST(equalsValueClause, contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + } + + if (!initExprSymbol || !initExprSymbol.type) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [id.text()])); + + if (!contextualType) { + context.setTypeInContext(paramSymbol, this.getNewErrorTypeSymbol(paramSymbol.name)); + } + } else { + var initTypeSymbol = this.getInstanceTypeForAssignment(argDeclAST, initExprSymbol.type, context); + if (!contextualType) { + context.setTypeInContext(paramSymbol, this.widenType(initTypeSymbol, equalsValueClause, context)); + isImplicitAny = initTypeSymbol !== paramSymbol.type; + } else { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, contextualType, argDeclAST, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(argDeclAST); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), contextualType.toString(enclosingSymbol)])); + } + } + } + } + } + + if (!contextualType && !paramSymbol.isVarArg && !initTypeSymbol) { + context.setTypeInContext(paramSymbol, this.semanticInfoChain.anyTypeSymbol); + isImplicitAny = true; + } + + if (isImplicitAny && this.compilationSettings.noImplicitAny()) { + var functionExpressionName = paramDecl.getParentDecl().getFunctionExpressionName(); + if (functionExpressionName) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [id.text(), functionExpressionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(argDeclAST, TypeScript.DiagnosticCode.Parameter_0_of_lambda_function_implicitly_has_an_any_type, [id.text()])); + } + } + + if (canTypeCheckAST) { + this.checkNameForCompilerGeneratedDeclarationCollision(argDeclAST, true, id, context); + } + + paramSymbol.setResolved(); + }; + + PullTypeResolver.prototype.checkNameForCompilerGeneratedDeclarationCollision = function (astWithName, isDeclaration, name, context, immediateThisCheck) { + var compilerReservedName = getCompilerReservedName(name); + if (compilerReservedName) { + switch (compilerReservedName) { + case 1 /* _this */: + if (immediateThisCheck) { + this.checkThisCaptureVariableCollides(astWithName, isDeclaration, context); + } else { + this.postTypeCheckWorkitems.push(astWithName); + } + return; + + case 2 /* _super */: + this.checkSuperCaptureVariableCollides(astWithName, isDeclaration, context); + return; + + case 3 /* arguments */: + this.checkArgumentsCollides(astWithName, context); + return; + + case 4 /* _i */: + if (isDeclaration) { + this.checkIndexOfRestArgumentInitializationCollides(astWithName, context); + } + return; + + case 5 /* require */: + case 6 /* exports */: + if (isDeclaration) { + this.checkExternalModuleRequireExportsCollides(astWithName, name, context); + } + return; + + default: + TypeScript.Debug.fail("Unknown compiler reserved name: " + name.text()); + } + } + }; + + PullTypeResolver.prototype.hasRestParameterCodeGen = function (someFunctionDecl) { + var enclosingAST = this.getASTForDecl(someFunctionDecl); + var nodeType = enclosingAST.kind(); + + if (nodeType == 129 /* FunctionDeclaration */) { + var functionDeclaration = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.kind == 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && functionDeclaration.block && TypeScript.lastParameterIsRest(functionDeclaration.callSignature.parameterList); + } else if (nodeType === 135 /* MemberFunctionDeclaration */) { + var memberFunction = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.kind == 65536 /* Method */ ? someFunctionDecl.getParentDecl().flags : someFunctionDecl.flags, 8 /* Ambient */) && memberFunction.block && TypeScript.lastParameterIsRest(memberFunction.callSignature.parameterList); + } else if (nodeType == 137 /* ConstructorDeclaration */) { + var constructorDeclaration = enclosingAST; + return !TypeScript.hasFlag(someFunctionDecl.getParentDecl().flags, 8 /* Ambient */) && constructorDeclaration.block && TypeScript.lastParameterIsRest(constructorDeclaration.parameterList); + } else if (nodeType == 218 /* ParenthesizedArrowFunctionExpression */) { + var arrowFunctionExpression = enclosingAST; + return TypeScript.lastParameterIsRest(arrowFunctionExpression.callSignature.parameterList); + } else if (nodeType === 222 /* FunctionExpression */) { + var functionExpression = enclosingAST; + return TypeScript.lastParameterIsRest(functionExpression.callSignature.parameterList); + } + + return false; + }; + + PullTypeResolver.prototype.checkArgumentsCollides = function (ast, context) { + if (ast.kind() == 242 /* Parameter */) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) { + if (this.hasRestParameterCodeGen(enclosingDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters)); + } + } + } + }; + + PullTypeResolver.prototype.checkIndexOfRestArgumentInitializationCollides = function (ast, context) { + if (ast.kind() == 242 /* Parameter */) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + if (TypeScript.hasFlag(enclosingDecl.kind, 1032192 /* SomeFunction */)) { + if (this.hasRestParameterCodeGen(enclosingDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_i_Compiler_uses_i_to_initialize_rest_parameter)); + } + } + } + }; + + PullTypeResolver.prototype.checkExternalModuleRequireExportsCollides = function (ast, name, context) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(name); + if (TypeScript.isAnyNameOfModule(enclosingModule, name)) { + enclosingDecl = this.getEnclosingDeclForAST(enclosingModule); + } + + if (enclosingDecl && enclosingDecl.kind == 32 /* DynamicModule */) { + var decl = this.semanticInfoChain.getDeclForAST(ast); + + if (!TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) { + var nameText = name.valueText(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_an_external_module, [nameText, nameText])); + } + } + }; + + PullTypeResolver.prototype.resolveObjectTypeTypeReference = function (objectType, context) { + var interfaceDecl = this.semanticInfoChain.getDeclForAST(objectType); + TypeScript.Debug.assert(interfaceDecl); + + var interfaceSymbol = interfaceDecl.getSymbol(); + TypeScript.Debug.assert(interfaceSymbol); + + if (objectType.typeMembers) { + var memberDecl = null; + var memberSymbol = null; + var memberType = null; + var typeMembers = objectType.typeMembers; + + for (var i = 0; i < typeMembers.nonSeparatorCount(); i++) { + memberDecl = this.semanticInfoChain.getDeclForAST(typeMembers.nonSeparatorAt(i)); + memberSymbol = (memberDecl.kind & 7340032 /* SomeSignature */) ? memberDecl.getSignatureSymbol() : memberDecl.getSymbol(); + + this.resolveAST(typeMembers.nonSeparatorAt(i), false, context); + + memberType = memberSymbol.type; + + if ((memberType && memberType.isGeneric()) || (memberSymbol.isSignature() && memberSymbol.isGeneric())) { + interfaceSymbol.setHasGenericMember(); + } + } + } + + interfaceSymbol.setResolved(); + + if (this.canTypeCheckAST(objectType, context)) { + this.typeCheckObjectTypeTypeReference(objectType, context); + } + + return interfaceSymbol; + }; + + PullTypeResolver.prototype.typeCheckObjectTypeTypeReference = function (objectType, context) { + this.setTypeChecked(objectType, context); + var objectTypeDecl = this.semanticInfoChain.getDeclForAST(objectType); + var objectTypeSymbol = objectTypeDecl.getSymbol(); + + this.typeCheckMembersAgainstIndexer(objectTypeSymbol, objectTypeDecl, context); + }; + + PullTypeResolver.prototype.resolveTypeAnnotation = function (typeAnnotation, context) { + return this.resolveTypeReference(typeAnnotation.type, context); + }; + + PullTypeResolver.prototype.resolveTypeReference = function (typeRef, context) { + if (typeRef === null) { + return null; + } + + TypeScript.Debug.assert(typeRef.kind() !== 244 /* TypeAnnotation */); + + var aliasType = null; + var type = this.computeTypeReferenceSymbol(typeRef, context); + + if (type.kind == 4 /* Container */) { + var container = type; + var instanceSymbol = container.getInstanceSymbol(); + + if (instanceSymbol && (instanceSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */) || instanceSymbol.kind == 32768 /* ConstructorMethod */)) { + type = instanceSymbol.type.getAssociatedContainerType(); + } + } + + if (type && type.isAlias()) { + aliasType = type; + type = aliasType.getExportAssignedTypeSymbol(); + } + + if (type && !type.isGeneric()) { + if (aliasType) { + this.semanticInfoChain.setAliasSymbolForAST(typeRef, aliasType); + } + } + + if (type && !type.isError()) { + if ((type.kind & 58728539 /* SomeType */) === 0) { + if (type.kind & 164 /* SomeContainer */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_cannot_refer_to_container_0, [aliasType ? aliasType.toString() : type.toString()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeRef, TypeScript.DiagnosticCode.Type_reference_must_refer_to_type)); + } + } + } + + if (this.canTypeCheckAST(typeRef, context)) { + this.setTypeChecked(typeRef, context); + } + + return type; + }; + + PullTypeResolver.prototype.computeTypeReferenceSymbol = function (term, context) { + switch (term.kind()) { + case 60 /* AnyKeyword */: + return this.semanticInfoChain.anyTypeSymbol; + case 61 /* BooleanKeyword */: + return this.semanticInfoChain.booleanTypeSymbol; + case 67 /* NumberKeyword */: + return this.semanticInfoChain.numberTypeSymbol; + case 69 /* StringKeyword */: + return this.semanticInfoChain.stringTypeSymbol; + case 41 /* VoidKeyword */: + return this.semanticInfoChain.voidTypeSymbol; + } + + var typeDeclSymbol = null; + + if (term.kind() === 11 /* IdentifierName */) { + typeDeclSymbol = this.resolveTypeNameExpression(term, context); + } else if (term.kind() === 123 /* FunctionType */) { + var functionType = term; + typeDeclSymbol = this.resolveAnyFunctionTypeSignature(functionType, functionType.typeParameterList, functionType.parameterList, functionType.type, context); + } else if (term.kind() === 125 /* ConstructorType */) { + var constructorType = term; + typeDeclSymbol = this.resolveAnyFunctionTypeSignature(constructorType, constructorType.typeParameterList, constructorType.parameterList, constructorType.type, context); + } else if (term.kind() === 122 /* ObjectType */) { + typeDeclSymbol = this.resolveObjectTypeTypeReference(term, context); + } else if (term.kind() === 126 /* GenericType */) { + typeDeclSymbol = this.resolveGenericTypeReference(term, context); + } else if (term.kind() === 121 /* QualifiedName */) { + typeDeclSymbol = this.resolveQualifiedName(term, context); + } else if (term.kind() === 14 /* StringLiteral */) { + var stringConstantAST = term; + var enclosingDecl = this.getEnclosingDeclForAST(term); + typeDeclSymbol = new TypeScript.PullStringConstantTypeSymbol(stringConstantAST.text()); + var decl = new TypeScript.PullSynthesizedDecl(stringConstantAST.text(), stringConstantAST.text(), typeDeclSymbol.kind, null, enclosingDecl, new TypeScript.TextSpan(stringConstantAST.start(), stringConstantAST.width()), enclosingDecl.semanticInfoChain()); + typeDeclSymbol.addDeclaration(decl); + } else if (term.kind() === 127 /* TypeQuery */) { + var typeQuery = term; + + var typeQueryTerm = typeQuery.name; + + var valueSymbol = this.resolveAST(typeQueryTerm, false, context); + + if (valueSymbol && valueSymbol.isAlias()) { + if (valueSymbol.assignedValue()) { + valueSymbol = valueSymbol.assignedValue(); + } else { + var containerSymbol = valueSymbol.getExportAssignedContainerSymbol(); + valueSymbol = (containerSymbol && containerSymbol.isContainer() && !containerSymbol.isEnum()) ? containerSymbol.getInstanceSymbol() : null; + } + } + + if (valueSymbol) { + typeDeclSymbol = valueSymbol.type; + } else { + typeDeclSymbol = this.getNewErrorTypeSymbol(); + } + } else if (term.kind() === 124 /* ArrayType */) { + var arrayType = term; + var underlying = this.resolveTypeReference(arrayType.type, context); + var arraySymbol = underlying.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [underlying]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + } + + typeDeclSymbol = arraySymbol; + } else { + throw TypeScript.Errors.invalidOperation("unknown type"); + } + + if (!typeDeclSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Unable_to_resolve_type)); + return this.getNewErrorTypeSymbol(); + } + + if (typeDeclSymbol.isError()) { + return typeDeclSymbol; + } + + if (this.genericTypeIsUsedWithoutRequiredTypeArguments(typeDeclSymbol, term, context)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(term, TypeScript.DiagnosticCode.Generic_type_references_must_include_all_type_arguments)); + typeDeclSymbol = this.instantiateTypeToAny(typeDeclSymbol, context); + } + + return typeDeclSymbol; + }; + + PullTypeResolver.prototype.genericTypeIsUsedWithoutRequiredTypeArguments = function (typeSymbol, term, context) { + return typeSymbol.isNamedTypeSymbol() && typeSymbol.isGeneric() && !typeSymbol.isTypeParameter() && (typeSymbol.isResolved || typeSymbol.inResolution) && !typeSymbol.getIsSpecialized() && typeSymbol.getTypeParameters().length && typeSymbol.getTypeArguments() == null && this.isTypeRefWithoutTypeArgs(term); + }; + + PullTypeResolver.prototype.resolveMemberVariableDeclaration = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.getType(varDecl.variableDeclarator), varDecl.variableDeclarator.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolvePropertySignature = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.getType(varDecl), null, context); + }; + + PullTypeResolver.prototype.resolveVariableDeclarator = function (varDecl, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.getType(varDecl), varDecl.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolveParameterList = function (list, context) { + return this.resolveSeparatedList(list.parameters, context); + }; + + PullTypeResolver.prototype.resolveParameter = function (parameter, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.getType(parameter), parameter.equalsValueClause, context); + }; + + PullTypeResolver.prototype.getEnumTypeSymbol = function (enumElement, context) { + var enumDeclaration = enumElement.parent.parent; + var decl = this.semanticInfoChain.getDeclForAST(enumDeclaration); + var symbol = decl.getSymbol(); + this.resolveDeclaredSymbol(symbol, context); + + return symbol; + }; + + PullTypeResolver.prototype.resolveEnumElement = function (enumElement, context) { + return this.resolveVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckEnumElement = function (enumElement, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(enumElement, TypeScript.sentinelEmptyArray, enumElement.propertyName, null, enumElement.equalsValueClause, context); + }; + + PullTypeResolver.prototype.resolveEqualsValueClause = function (clause, isContextuallyTyped, context) { + if (this.canTypeCheckAST(clause, context)) { + this.setTypeChecked(clause, context); + } + + return this.resolveAST(clause.value, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) { + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + + if (enclosingDecl && decl.kind == 2048 /* Parameter */) { + enclosingDecl.ensureSymbolIsBound(); + } + + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + if (declSymbol.isResolved) { + var declType = declSymbol.type; + var valDecl = decl.getValueDecl(); + + if (valDecl) { + var valSymbol = valDecl.getSymbol(); + + if (valSymbol && !valSymbol.isResolved) { + valSymbol.type = declType; + valSymbol.setResolved(); + } + } + } else { + if (declSymbol.inResolution) { + declSymbol.type = this.semanticInfoChain.anyTypeSymbol; + declSymbol.setResolved(); + return declSymbol; + } + + if (!declSymbol.type || !declSymbol.type.isError()) { + declSymbol.startResolving(); + + var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context); + + if (!hasTypeExpr) { + this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol); + } + + if (!(hasTypeExpr || init)) { + var defaultType = this.semanticInfoChain.anyTypeSymbol; + + if (declSymbol.isVarArg) { + defaultType = this.createInstantiatedType(this.cachedArrayInterfaceType(), [defaultType]); + } + + context.setTypeInContext(declSymbol, defaultType); + + if (declParameterSymbol) { + declParameterSymbol.type = defaultType; + } + } + declSymbol.setResolved(); + + if (declParameterSymbol) { + declParameterSymbol.setResolved(); + } + } + } + + if (this.canTypeCheckAST(varDeclOrParameter, context)) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDeclOrParameter, modifiers, name, typeExpr, init, context); + } + + return declSymbol; + }; + + PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclarationTypeExpr = function (varDeclOrParameter, name, typeExpr, context) { + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + if (varDeclOrParameter.kind() === 243 /* EnumElement */) { + var result = this.getEnumTypeSymbol(varDeclOrParameter, context); + declSymbol.type = result; + return result; + } + + if (!typeExpr) { + return null; + } + + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + var typeExprSymbol = this.resolveTypeReference(typeExpr, context); + + if (!typeExprSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()])); + declSymbol.type = this.getNewErrorTypeSymbol(); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol); + } + } else if (typeExprSymbol.isError()) { + context.setTypeInContext(declSymbol, typeExprSymbol); + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, typeExprSymbol); + } + } else { + if (typeExprSymbol == this.semanticInfoChain.anyTypeSymbol) { + decl.setFlag(16777216 /* IsAnnotatedWithAny */); + } + + if (typeExprSymbol.isContainer()) { + var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + + if (exportedTypeSymbol) { + typeExprSymbol = exportedTypeSymbol; + } else { + typeExprSymbol = typeExprSymbol.type; + + if (typeExprSymbol.isAlias()) { + typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + } + + if (typeExprSymbol && typeExprSymbol.isContainer() && !typeExprSymbol.isEnum()) { + var instanceSymbol = typeExprSymbol.getInstanceSymbol(); + + if (!instanceSymbol || !TypeScript.PullHelpers.symbolIsEnum(instanceSymbol)) { + typeExprSymbol = this.getNewErrorTypeSymbol(); + } else { + typeExprSymbol = instanceSymbol.type; + } + } + } + } else if (declSymbol.isVarArg && !(typeExprSymbol.isArrayNamedTypeReference() || typeExprSymbol == this.cachedArrayInterfaceType())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Rest_parameters_must_be_array_types)); + typeExprSymbol = this.getNewErrorTypeSymbol(); + } + + context.setTypeInContext(declSymbol, typeExprSymbol); + + if (declParameterSymbol) { + declParameterSymbol.type = typeExprSymbol; + } + + if (typeExprSymbol.kind == 16777216 /* FunctionType */ && !typeExprSymbol.getFunctionSymbol()) { + typeExprSymbol.setFunctionSymbol(declSymbol); + } + } + + return typeExprSymbol; + }; + + PullTypeResolver.prototype.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr = function (varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol) { + if (!init) { + return null; + } + + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + if (typeExprSymbol) { + context.pushContextualType(typeExprSymbol, context.inProvisionalResolution(), null); + } + + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + var declParameterSymbol = decl.getValueDecl() ? decl.getValueDecl().getSymbol() : null; + + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + var initExprSymbol = this.resolveAST(init, typeExprSymbol != null, context); + + if (typeExprSymbol) { + context.popContextualType(); + } + + if (!initExprSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Unable_to_resolve_type_of_0, [name.text()])); + + if (!hasTypeExpr) { + context.setTypeInContext(declSymbol, this.getNewErrorTypeSymbol()); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, this.semanticInfoChain.anyTypeSymbol); + } + } + } else { + var initTypeSymbol = initExprSymbol.type; + var widenedInitTypeSymbol = this.widenType(initTypeSymbol, init.value, context); + + if (!hasTypeExpr) { + context.setTypeInContext(declSymbol, widenedInitTypeSymbol); + + if (declParameterSymbol) { + context.setTypeInContext(declParameterSymbol, widenedInitTypeSymbol); + } + + if (this.compilationSettings.noImplicitAny()) { + if ((widenedInitTypeSymbol != initTypeSymbol) && (widenedInitTypeSymbol == this.semanticInfoChain.anyTypeSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } + } + } + } + + return widenedInitTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckPropertySignature = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.sentinelEmptyArray, varDecl.propertyName, TypeScript.getType(varDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckMemberVariableDeclaration = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, varDecl.modifiers, varDecl.variableDeclarator.propertyName, TypeScript.getType(varDecl), varDecl.variableDeclarator.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckVariableDeclarator = function (varDecl, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(varDecl, TypeScript.getVariableDeclaratorModifiers(varDecl), varDecl.propertyName, TypeScript.getType(varDecl), varDecl.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckParameter = function (parameter, context) { + this.typeCheckVariableDeclaratorOrParameterOrEnumElement(parameter, parameter.modifiers, parameter.identifier, TypeScript.getType(parameter), parameter.equalsValueClause, context); + }; + + PullTypeResolver.prototype.typeCheckVariableDeclaratorOrParameterOrEnumElement = function (varDeclOrParameter, modifiers, name, typeExpr, init, context) { + var _this = this; + this.setTypeChecked(varDeclOrParameter, context); + + var hasTypeExpr = typeExpr !== null || varDeclOrParameter.kind() === 243 /* EnumElement */; + var enclosingDecl = this.getEnclosingDeclForAST(varDeclOrParameter); + var decl = this.semanticInfoChain.getDeclForAST(varDeclOrParameter); + var declSymbol = decl.getSymbol(); + + var typeExprSymbol = this.resolveAndTypeCheckVariableDeclarationTypeExpr(varDeclOrParameter, name, typeExpr, context); + + var initTypeSymbol = this.resolveAndTypeCheckVariableDeclaratorOrParameterInitExpr(varDeclOrParameter, name, typeExpr, init, context, typeExprSymbol); + + if (hasTypeExpr || init) { + if (typeExprSymbol && typeExprSymbol.isAlias()) { + typeExprSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + } + + if (typeExprSymbol && typeExprSymbol.kind === 32 /* DynamicModule */) { + var exportedTypeSymbol = typeExprSymbol.getExportAssignedTypeSymbol(); + + if (exportedTypeSymbol) { + typeExprSymbol = exportedTypeSymbol; + } else { + var instanceTypeSymbol = typeExprSymbol.getInstanceType(); + + if (!instanceTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [typeExprSymbol.toString()])); + typeExprSymbol = null; + } else { + typeExprSymbol = instanceTypeSymbol; + } + } + } + + initTypeSymbol = this.getInstanceTypeForAssignment(varDeclOrParameter, initTypeSymbol, context); + + if (initTypeSymbol && typeExprSymbol) { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(initTypeSymbol, typeExprSymbol, varDeclOrParameter, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(varDeclOrParameter); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [initTypeSymbol.toString(enclosingSymbol), typeExprSymbol.toString(enclosingSymbol)])); + } + } + } + } else if (varDeclOrParameter.kind() !== 243 /* EnumElement */ && this.compilationSettings.noImplicitAny() && !this.isForInVariableDeclarator(varDeclOrParameter)) { + var wrapperDecl = this.getEnclosingDecl(decl); + wrapperDecl = wrapperDecl ? wrapperDecl : enclosingDecl; + + if ((wrapperDecl.kind === 16384 /* Function */ || wrapperDecl.kind === 32768 /* ConstructorMethod */ || wrapperDecl.kind === 2097152 /* ConstructSignature */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } else if (wrapperDecl.kind === 65536 /* Method */) { + var parentDecl = wrapperDecl.getParentDecl(); + + if (!TypeScript.hasFlag(parentDecl.flags, 8 /* Ambient */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } else if (TypeScript.hasFlag(parentDecl.flags, 8 /* Ambient */) && !TypeScript.hasFlag(wrapperDecl.flags, 2 /* Private */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Parameter_0_of_1_implicitly_has_an_any_type, [name.text(), enclosingDecl.name])); + } + } else if (wrapperDecl.kind === 8388608 /* ObjectType */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Member_0_of_object_type_implicitly_has_an_any_type, [name.text()])); + } else if (wrapperDecl.kind !== 268435456 /* CatchBlock */) { + if (!TypeScript.hasFlag(wrapperDecl.flags, 8 /* Ambient */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } else if (TypeScript.hasFlag(wrapperDecl.flags, 8 /* Ambient */) && !TypeScript.hasModifier(modifiers, 2 /* Private */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Variable_0_implicitly_has_an_any_type, [name.text()])); + } + } + } + + if (init && varDeclOrParameter.kind() === 242 /* Parameter */) { + var containerSignature = enclosingDecl.getSignatureSymbol(); + if (containerSignature && !containerSignature.isDefinition()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(varDeclOrParameter, TypeScript.DiagnosticCode.Default_arguments_are_not_allowed_in_an_overload_parameter)); + } + } + if (declSymbol.kind != 2048 /* Parameter */ && (declSymbol.kind != 4096 /* Property */ || declSymbol.getContainer().isNamedTypeSymbol())) { + this.checkSymbolPrivacy(declSymbol, declSymbol.type, function (symbol) { + return _this.variablePrivacyErrorReporter(varDeclOrParameter, declSymbol, symbol, context); + }); + } + + if ((declSymbol.kind != 4096 /* Property */ && declSymbol.kind != 67108864 /* EnumMember */) || declSymbol.anyDeclHasFlag(8388608 /* PropertyParameter */)) { + this.checkNameForCompilerGeneratedDeclarationCollision(varDeclOrParameter, true, name, context); + } + }; + + PullTypeResolver.prototype.isForInVariableDeclarator = function (ast) { + return ast.kind() === 225 /* VariableDeclarator */ && ast.parent && ast.parent.parent && ast.parent.parent.parent && ast.parent.kind() === 2 /* SeparatedList */ && ast.parent.parent.kind() === 224 /* VariableDeclaration */ && ast.parent.parent.parent.kind() === 155 /* ForInStatement */ && ast.parent.parent.parent.variableDeclaration === ast.parent.parent; + }; + + PullTypeResolver.prototype.checkSuperCaptureVariableCollides = function (superAST, isDeclaration, context) { + var enclosingDecl = this.getEnclosingDeclForAST(superAST); + var declPath = enclosingDecl.getParentPath(); + + var classSymbol = this.getContextualClassSymbolForEnclosingDecl(superAST, enclosingDecl); + + if (classSymbol && !classSymbol.anyDeclHasFlag(8 /* Ambient */)) { + if (superAST.kind() == 242 /* Parameter */) { + var enclosingAST = this.getASTForDecl(enclosingDecl); + if (enclosingAST.kind() !== 218 /* ParenthesizedArrowFunctionExpression */ && enclosingAST.kind() !== 219 /* SimpleArrowFunctionExpression */) { + var block = enclosingDecl.kind == 65536 /* Method */ ? enclosingAST.block : enclosingAST.block; + if (!block) { + return; + } + } + } + + this.resolveDeclaredSymbol(classSymbol, context); + + var parents = classSymbol.getExtendedTypes(); + if (parents.length) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(superAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference : TypeScript.DiagnosticCode.Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference)); + } + } + }; + + PullTypeResolver.prototype.checkThisCaptureVariableCollides = function (_thisAST, isDeclaration, context) { + if (isDeclaration) { + var decl = this.semanticInfoChain.getDeclForAST(_thisAST); + if (TypeScript.hasFlag(decl.flags, 8 /* Ambient */)) { + return; + } + } + + var enclosingDecl = this.getEnclosingDeclForAST(_thisAST); + + var enclosingModule = TypeScript.getEnclosingModuleDeclaration(_thisAST); + if (TypeScript.isAnyNameOfModule(enclosingModule, _thisAST)) { + enclosingDecl = this.getEnclosingDeclForAST(enclosingModule); + } + + var declPath = enclosingDecl.getParentPath(); + + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) { + continue; + } + + if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) { + if (TypeScript.hasFlag(decl.flags, 262144 /* MustCaptureThis */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(_thisAST, isDeclaration ? TypeScript.DiagnosticCode.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference : TypeScript.DiagnosticCode.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference)); + } + break; + } + } + }; + + PullTypeResolver.prototype.postTypeCheckVariableDeclaratorOrParameter = function (varDeclOrParameter, context) { + this.checkThisCaptureVariableCollides(varDeclOrParameter, true, context); + }; + + PullTypeResolver.prototype.resolveTypeParameterDeclaration = function (typeParameterAST, context) { + var typeParameterDecl = this.semanticInfoChain.getDeclForAST(typeParameterAST); + var typeParameterSymbol = typeParameterDecl.getSymbol(); + + if (typeParameterSymbol.isResolved || typeParameterSymbol.inResolution) { + if (typeParameterSymbol.isResolved && this.canTypeCheckAST(typeParameterAST, context)) { + this.typeCheckTypeParameterDeclaration(typeParameterAST, context); + } + return typeParameterSymbol; + } + + typeParameterSymbol.startResolving(); + + if (typeParameterAST.constraint) { + var constraintTypeSymbol = this.resolveTypeReference(typeParameterAST.constraint.type, context); + + if (constraintTypeSymbol) { + typeParameterSymbol.setConstraint(constraintTypeSymbol); + } + } + + typeParameterSymbol.setResolved(); + + if (this.canTypeCheckAST(typeParameterAST, context)) { + this.setTypeChecked(typeParameterAST, context); + } + + return typeParameterSymbol; + }; + + PullTypeResolver.prototype.typeCheckTypeParameterDeclaration = function (typeParameterAST, context) { + this.setTypeChecked(typeParameterAST, context); + + this.resolveAST(typeParameterAST.constraint, false, context); + }; + + PullTypeResolver.prototype.resolveConstraint = function (constraint, context) { + if (this.canTypeCheckAST(constraint, context)) { + this.setTypeChecked(constraint, context); + } + + return this.resolveTypeReference(constraint.type, context); + }; + + PullTypeResolver.prototype.resolveFunctionBodyReturnTypes = function (funcDeclAST, block, bodyExpression, signature, useContextualType, enclosingDecl, context) { + var _this = this; + var returnStatementsExpressions = []; + + var enclosingDeclStack = [enclosingDecl]; + + var preFindReturnExpressionTypes = function (ast, walker) { + var go = true; + + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + go = false; + break; + + case 150 /* ReturnStatement */: + var returnStatement = ast; + enclosingDecl.setFlag(4194304 /* HasReturnStatement */); + returnStatementsExpressions.push({ expression: returnStatement.expression, enclosingDecl: enclosingDeclStack[enclosingDeclStack.length - 1] }); + go = false; + break; + + case 236 /* CatchClause */: + case 163 /* WithStatement */: + enclosingDeclStack[enclosingDeclStack.length] = _this.semanticInfoChain.getDeclForAST(ast); + break; + + default: + break; + } + + walker.options.goChildren = go; + + return ast; + }; + + var postFindReturnExpressionEnclosingDecls = function (ast, walker) { + switch (ast.kind()) { + case 236 /* CatchClause */: + case 163 /* WithStatement */: + enclosingDeclStack.length--; + break; + default: + break; + } + + walker.options.goChildren = true; + + return ast; + }; + + if (block) { + TypeScript.getAstWalkerFactory().walk(block, preFindReturnExpressionTypes, postFindReturnExpressionEnclosingDecls); + } else { + returnStatementsExpressions.push({ expression: bodyExpression, enclosingDecl: enclosingDecl }); + enclosingDecl.setFlag(4194304 /* HasReturnStatement */); + } + + if (!returnStatementsExpressions.length) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + } else { + var returnExpressionSymbols = []; + var returnExpressions = []; + + for (var i = 0; i < returnStatementsExpressions.length; i++) { + var returnExpression = returnStatementsExpressions[i].expression; + if (returnExpression) { + var returnType = this.resolveAST(returnExpression, useContextualType, context).type; + + if (returnType.isError()) { + signature.returnType = returnType; + return; + } else { + if (returnExpression.parent.kind() === 150 /* ReturnStatement */) { + this.setSymbolForAST(returnExpression.parent, returnType, context); + } + } + + returnExpressionSymbols.push(returnType); + returnExpressions.push(returnExpression); + } + } + + if (!returnExpressionSymbols.length) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + } else { + var collection = { + getLength: function () { + return returnExpressionSymbols.length; + }, + getTypeAtIndex: function (index) { + return returnExpressionSymbols[index].type; + } + }; + + var bestCommonReturnType = this.findBestCommonType(collection, context, new TypeComparisonInfo()); + var returnType = bestCommonReturnType; + var returnExpression = returnExpressions[returnExpressionSymbols.indexOf(returnType)]; + + if (useContextualType && returnType == this.semanticInfoChain.anyTypeSymbol) { + var contextualType = context.getContextualType(); + + if (contextualType) { + returnType = contextualType; + } + } + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var functionSymbol = functionDecl.getSymbol(); + + if (returnType) { + var previousReturnType = returnType; + var newReturnType = this.widenType(returnType, returnExpression, context); + signature.returnType = newReturnType; + + if (!TypeScript.ArrayUtilities.contains(returnExpressionSymbols, bestCommonReturnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Could_not_find_the_best_common_type_of_types_of_all_return_statement_expressions)); + } + + if (this.compilationSettings.noImplicitAny()) { + if (previousReturnType !== newReturnType && newReturnType === this.semanticInfoChain.anyTypeSymbol) { + var functionName = enclosingDecl.name; + if (functionName == "") { + functionName = enclosingDecl.getFunctionExpressionName(); + } + + if (functionName != "") { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } + } + + if (!functionSymbol.type && functionSymbol.isAccessor()) { + functionSymbol.type = signature.returnType; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckConstructorDeclaration = function (funcDeclAST, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + if (funcDeclAST.parameterList) { + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveAST(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), false, context); + } + } + + this.resolveAST(funcDeclAST.block, false, context); + + if (funcDecl.getSignatureSymbol() && funcDecl.getSignatureSymbol().isDefinition() && this.enclosingClassIsDerived(funcDecl.getParentDecl())) { + if (!this.constructorHasSuperCall(funcDeclAST)) { + context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), 11, TypeScript.DiagnosticCode.Constructors_for_derived_classes_must_contain_a_super_call)); + } else if (this.superCallMustBeFirstStatementInConstructor(funcDecl)) { + var firstStatement = this.getFirstStatementOfBlockOrNull(funcDeclAST.block); + if (!firstStatement || !this.isSuperInvocationExpressionStatement(firstStatement)) { + context.postDiagnostic(new TypeScript.Diagnostic(funcDeclAST.fileName(), this.semanticInfoChain.lineMap(funcDeclAST.fileName()), funcDeclAST.start(), 11, TypeScript.DiagnosticCode.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties)); + } + } + } + + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context); + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.constructorHasSuperCall = function (constructorDecl) { + var _this = this; + if (constructorDecl.block) { + var foundSuperCall = false; + var pre = function (ast, walker) { + if (_this.isSuperInvocationExpression(ast)) { + foundSuperCall = true; + walker.options.stopWalking = true; + } + }; + + TypeScript.getAstWalkerFactory().walk(constructorDecl.block, pre); + return foundSuperCall; + } + + return false; + }; + + PullTypeResolver.prototype.typeCheckFunctionExpression = function (funcDecl, context) { + this.typeCheckAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.getType(funcDecl), funcDecl.block, null, context); + }; + + PullTypeResolver.prototype.typeCheckCallSignature = function (funcDecl, context) { + this.typeCheckFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckConstructSignature = function (funcDecl, context) { + this.typeCheckFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.typeCheckFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameters, returnTypeAnnotation, block, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + this.resolveAST(parameters, false, context); + + this.resolveAST(block, false, context); + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, isStatic, typeParameters, TypeScript.Parameters.fromParameterList(parameters), returnTypeAnnotation, block, context); + + var signature = funcDecl.getSignatureSymbol(); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + if (funcDeclAST.kind() !== 143 /* ConstructSignature */ && block && returnTypeAnnotation != null && !hasReturn) { + var isVoidOrAny = this.isAnyOrEquivalent(signature.returnType) || signature.returnType === this.semanticInfoChain.voidTypeSymbol; + + if (!isVoidOrAny && !(block.statements.childCount() > 0 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + var funcName = funcDecl.getDisplayName(); + funcName = funcName ? funcName : "expression"; + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_0_declared_a_non_void_return_type_but_has_no_return_expression, [funcName])); + } + } + + if (funcDecl.kind === 16384 /* Function */) { + this.checkNameForCompilerGeneratedDeclarationCollision(funcDeclAST, true, name, context); + } + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.typeCheckIndexSignature = function (funcDeclAST, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + this.resolveAST(funcDeclAST.parameter, false, context); + + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + this.validateVariableDeclarationGroups(funcDecl, context); + + this.checkFunctionTypePrivacy(funcDeclAST, false, null, TypeScript.Parameters.fromParameter(funcDeclAST.parameter), TypeScript.getType(funcDeclAST), null, context); + + var signature = funcDecl.getSignatureSymbol(); + + this.typeCheckCallBacks.push(function (context) { + var parentSymbol = funcDecl.getSignatureSymbol().getContainer(); + var allIndexSignatures = _this.getBothKindsOfIndexSignatures(parentSymbol, context); + var stringIndexSignature = allIndexSignatures.stringSignature; + var numberIndexSignature = allIndexSignatures.numericSignature; + var isNumericIndexer = numberIndexSignature === signature; + + if (numberIndexSignature && stringIndexSignature && (isNumericIndexer || stringIndexSignature.getDeclarations()[0].getParentDecl() !== numberIndexSignature.getDeclarations()[0].getParentDecl())) { + var comparisonInfo = new TypeComparisonInfo(); + + if (!_this.sourceIsSubtypeOfTarget(numberIndexSignature.returnType, stringIndexSignature.returnType, funcDeclAST, context, comparisonInfo)) { + var enclosingSymbol = _this.getEnclosingSymbolForAST(funcDeclAST); + if (comparisonInfo.message) { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1_NL_2, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Numeric_indexer_type_0_must_be_a_subtype_of_string_indexer_type_1, [numberIndexSignature.returnType.toString(enclosingSymbol), stringIndexSignature.returnType.toString(enclosingSymbol)])); + } + } + } + + var allMembers = parentSymbol.type.getAllMembers(536869887 /* All */, 0 /* all */); + for (var i = 0; i < allMembers.length; i++) { + var member = allMembers[i]; + var name = member.name; + if (name || (member.kind === 4096 /* Property */ && name === "")) { + if (!allMembers[i].isResolved) { + _this.resolveDeclaredSymbol(allMembers[i], context); + } + + if (parentSymbol !== allMembers[i].getContainer()) { + var isMemberNumeric = TypeScript.PullHelpers.isNameNumeric(name); + var indexerKindMatchesMemberNameKind = isNumericIndexer === isMemberNumeric; + var onlyStringIndexerIsPresent = !numberIndexSignature; + + if (indexerKindMatchesMemberNameKind || onlyStringIndexerIsPresent) { + var comparisonInfo = new TypeComparisonInfo(); + if (!_this.sourceIsSubtypeOfTarget(allMembers[i].type, signature.returnType, funcDeclAST, context, comparisonInfo, false)) { + _this.reportErrorThatMemberIsNotSubtypeOfIndexer(allMembers[i], signature, funcDeclAST, context, comparisonInfo); + } + } + } + } + } + }); + }; + + PullTypeResolver.prototype.postTypeCheckFunctionDeclaration = function (funcDeclAST, context) { + this.checkThisCaptureVariableCollides(funcDeclAST, true, context); + }; + + PullTypeResolver.prototype.resolveReturnTypeAnnotationOfFunctionDeclaration = function (funcDeclAST, returnTypeAnnotation, context) { + var returnTypeSymbol = null; + + if (returnTypeAnnotation) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + } else { + var isConstructor = funcDeclAST.kind() === 137 /* ConstructorDeclaration */ || funcDeclAST.kind() === 143 /* ConstructSignature */; + if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void)); + } + } + } + + return returnTypeSymbol; + }; + + PullTypeResolver.prototype.resolveMemberFunctionDeclaration = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + }; + + PullTypeResolver.prototype.resolveCallSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.typeParameterList, funcDecl.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveConstructSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, null, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveMethodSignature = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, false, funcDecl.propertyName, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), null, context); + }; + + PullTypeResolver.prototype.resolveAnyFunctionDeclaration = function (funcDecl, context) { + return this.resolveFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + }; + + PullTypeResolver.prototype.resolveFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), TypeScript.getType(funcDecl), funcDecl.block, null, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveSimpleArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, null, TypeScript.Parameters.fromIdentifier(funcDecl.identifier), null, funcDecl.block, funcDecl.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveParenthesizedArrowFunctionExpression = function (funcDecl, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcDecl, funcDecl.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), TypeScript.getType(funcDecl), funcDecl.block, funcDecl.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.getEnclosingClassDeclaration = function (ast) { + while (ast) { + if (ast.kind() === 131 /* ClassDeclaration */) { + return ast; + } + + ast = ast.parent; + } + + return null; + }; + + PullTypeResolver.prototype.resolveConstructorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckConstructorDeclaration(funcDeclAST, context); + } + return funcSymbol; + } + + if (!signature.inResolution) { + var classAST = this.getEnclosingClassDeclaration(funcDeclAST); + + if (classAST) { + var classDecl = this.semanticInfoChain.getDeclForAST(classAST); + var classSymbol = classDecl.getSymbol(); + + if (!classSymbol.isResolved && !classSymbol.inResolution) { + this.resolveDeclaredSymbol(classSymbol, context); + } + } + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (funcDeclAST.parameterList) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context); + } + + context.inTypeCheck = prevInTypeCheck; + } + + if (signature.isGeneric()) { + if (funcSymbol) { + funcSymbol.type.setHasGenericSignature(); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckConstructorDeclaration(funcDeclAST, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveIndexMemberDeclaration = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + } + + return this.resolveIndexSignature(ast.indexSignature, context); + }; + + PullTypeResolver.prototype.resolveIndexSignature = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckIndexSignature(funcDeclAST, context); + } + return funcSymbol; + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + if (funcDeclAST.typeAnnotation) { + var returnTypeSymbol = this.resolveTypeReference(TypeScript.getType(funcDeclAST), context); + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(TypeScript.getType(funcDeclAST), TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + } + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (funcDeclAST.parameter) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + this.resolveParameter(funcDeclAST.parameter, context); + context.inTypeCheck = prevInTypeCheck; + } + + if (funcDeclAST.typeAnnotation) { + returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + var parentDeclFlags = 0 /* None */; + if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) { + var parentDecl = funcDecl.getParentDecl(); + parentDeclFlags = parentDecl.flags; + } + + if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) { + var funcDeclASTName = name; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, ["Indexer"])); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckIndexSignature(funcDeclAST, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveFunctionDeclaration = function (funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcSymbol = funcDecl.getSymbol(); + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + var isConstructor = funcDeclAST.kind() === 143 /* ConstructSignature */; + + if (signature) { + if (signature.isResolved) { + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context); + } + return funcSymbol; + } + + if (isConstructor && !signature.inResolution) { + var classAST = this.getEnclosingClassDeclaration(funcDeclAST); + + if (classAST) { + var classDecl = this.semanticInfoChain.getDeclForAST(classAST); + var classSymbol = classDecl.getSymbol(); + + if (!classSymbol.isResolved && !classSymbol.inResolution) { + this.resolveDeclaredSymbol(classSymbol, context); + } + } + } + + var functionTypeSymbol = funcSymbol && funcSymbol.type; + + if (signature.inResolution) { + if (returnTypeAnnotation) { + var returnTypeSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + if (!returnTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Cannot_resolve_return_type_reference)); + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + + if (isConstructor && returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructors_cannot_have_a_return_type_of_void)); + } + } + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + } + + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + return funcSymbol; + } + + if (funcSymbol) { + funcSymbol.startResolving(); + } + signature.startResolving(); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + if (parameterList) { + var prevInTypeCheck = context.inTypeCheck; + + context.inTypeCheck = false; + + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context); + } + + context.inTypeCheck = prevInTypeCheck; + } + + if (returnTypeAnnotation) { + returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else if (funcDecl.kind !== 2097152 /* ConstructSignature */) { + if (TypeScript.hasFlag(funcDecl.flags, 2048 /* Signature */)) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + var parentDeclFlags = 0 /* None */; + if (TypeScript.hasFlag(funcDecl.kind, 65536 /* Method */) || TypeScript.hasFlag(funcDecl.kind, 32768 /* ConstructorMethod */)) { + var parentDecl = funcDecl.getParentDecl(); + parentDeclFlags = parentDecl.flags; + } + + if (this.compilationSettings.noImplicitAny() && (!TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) || (TypeScript.hasFlag(parentDeclFlags, 8 /* Ambient */) && !TypeScript.hasFlag(funcDecl.flags, 2 /* Private */)))) { + var funcDeclASTName = name; + if (funcDeclASTName) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [funcDeclASTName.text()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Lambda_Function_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } else { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context); + } + } else if (funcDecl.kind === 2097152 /* ConstructSignature */) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (this.compilationSettings.noImplicitAny()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Constructor_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + + if (!hadError) { + if (funcSymbol) { + funcSymbol.setUnresolved(); + if (funcSymbol.type === this.semanticInfoChain.anyTypeSymbol) { + funcSymbol.type = functionTypeSymbol; + } + } + signature.setResolved(); + } + } + + if (funcSymbol) { + this.resolveOtherDeclarations(funcDeclAST, context); + } + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckFunctionDeclaration(funcDeclAST, isStatic, name, typeParameters, parameterList, returnTypeAnnotation, block, context); + } + + return funcSymbol; + }; + + PullTypeResolver.prototype.resolveGetterReturnTypeAnnotation = function (getterFunctionDeclarationAst, enclosingDecl, context) { + if (getterFunctionDeclarationAst && getterFunctionDeclarationAst.typeAnnotation) { + return this.resolveTypeReference(TypeScript.getType(getterFunctionDeclarationAst), context); + } + + return null; + }; + + PullTypeResolver.prototype.resolveSetterArgumentTypeAnnotation = function (setterFunctionDeclarationAst, enclosingDecl, context) { + if (setterFunctionDeclarationAst && setterFunctionDeclarationAst.parameterList && setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorCount() > 0) { + var parameter = setterFunctionDeclarationAst.parameterList.parameters.nonSeparatorAt(0); + return this.resolveTypeReference(TypeScript.getType(parameter), context); + } + + return null; + }; + + PullTypeResolver.prototype.resolveAccessorDeclaration = function (funcDeclAst, context) { + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst); + var accessorSymbol = functionDeclaration.getSymbol(); + + if (accessorSymbol.inResolution) { + accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol; + accessorSymbol.setResolved(); + + return accessorSymbol; + } + + if (accessorSymbol.isResolved) { + if (!accessorSymbol.type) { + accessorSymbol.type = this.semanticInfoChain.anyTypeSymbol; + } + } else { + var getterSymbol = accessorSymbol.getGetter(); + var getterFunctionDeclarationAst = getterSymbol ? getterSymbol.getDeclarations()[0].ast() : null; + var hasGetter = getterSymbol !== null; + + var setterSymbol = accessorSymbol.getSetter(); + var setterFunctionDeclarationAst = setterSymbol ? setterSymbol.getDeclarations()[0].ast() : null; + var hasSetter = setterSymbol !== null; + + var getterAnnotatedType = this.resolveGetterReturnTypeAnnotation(getterFunctionDeclarationAst, functionDeclaration, context); + var getterHasTypeAnnotation = getterAnnotatedType !== null; + + var setterAnnotatedType = this.resolveSetterArgumentTypeAnnotation(setterFunctionDeclarationAst, functionDeclaration, context); + var setterHasTypeAnnotation = setterAnnotatedType !== null; + + accessorSymbol.startResolving(); + + if (hasGetter) { + getterSymbol = this.resolveGetAccessorDeclaration(getterFunctionDeclarationAst, getterFunctionDeclarationAst.parameterList, TypeScript.getType(getterFunctionDeclarationAst), getterFunctionDeclarationAst.block, setterAnnotatedType, context); + } + + if (hasSetter) { + setterSymbol = this.resolveSetAccessorDeclaration(setterFunctionDeclarationAst, setterFunctionDeclarationAst.parameterList, context); + } + + if (hasGetter && hasSetter) { + var setterSig = setterSymbol.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + var setterHasParameters = setterParameters.length > 0; + var getterSig = getterSymbol.type.getCallSignatures()[0]; + + var setterSuppliedTypeSymbol = setterHasParameters ? setterParameters[0].type : null; + var getterSuppliedTypeSymbol = getterSig.returnType; + + if (setterHasTypeAnnotation && !getterHasTypeAnnotation) { + getterSuppliedTypeSymbol = setterSuppliedTypeSymbol; + getterSig.returnType = setterSuppliedTypeSymbol; + } else if ((getterHasTypeAnnotation && !setterHasTypeAnnotation) || (!getterHasTypeAnnotation && !setterHasTypeAnnotation)) { + setterSuppliedTypeSymbol = getterSuppliedTypeSymbol; + + if (setterHasParameters) { + setterParameters[0].type = getterSuppliedTypeSymbol; + } + } + + if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol)) { + accessorSymbol.type = this.getNewErrorTypeSymbol(); + } else { + accessorSymbol.type = getterSuppliedTypeSymbol; + } + } else if (hasSetter) { + var setterSig = setterSymbol.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + var setterHasParameters = setterParameters.length > 0; + + accessorSymbol.type = setterHasParameters ? setterParameters[0].type : this.semanticInfoChain.anyTypeSymbol; + } else { + var getterSig = getterSymbol.type.getCallSignatures()[0]; + accessorSymbol.type = getterSig.returnType; + } + + accessorSymbol.setResolved(); + } + + if (this.canTypeCheckAST(funcDeclAst, context)) { + this.typeCheckAccessorDeclaration(funcDeclAst, context); + } + + return accessorSymbol; + }; + + PullTypeResolver.prototype.typeCheckAccessorDeclaration = function (funcDeclAst, context) { + this.setTypeChecked(funcDeclAst, context); + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDeclAst); + var accessorSymbol = functionDeclaration.getSymbol(); + var getterSymbol = accessorSymbol.getGetter(); + var setterSymbol = accessorSymbol.getSetter(); + + var isGetter = funcDeclAst.kind() == 139 /* GetAccessor */; + if (isGetter) { + var getterFunctionDeclarationAst = funcDeclAst; + context.pushContextualType(getterSymbol.type, context.inProvisionalResolution(), null); + this.typeCheckGetAccessorDeclaration(getterFunctionDeclarationAst, context); + context.popContextualType(); + } else { + var setterFunctionDeclarationAst = funcDeclAst; + this.typeCheckSetAccessorDeclaration(setterFunctionDeclarationAst, context); + } + }; + + PullTypeResolver.prototype.resolveGetAccessorDeclaration = function (funcDeclAST, parameters, returnTypeAnnotation, block, setterAnnotatedType, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + var getterSymbol = accessorSymbol.getGetter(); + var getterTypeSymbol = getterSymbol.type; + + var signature = getterTypeSymbol.getCallSignatures()[0]; + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + return getterSymbol; + } + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + signature.setResolved(); + + return getterSymbol; + } + + signature.startResolving(); + + if (returnTypeAnnotation) { + var returnTypeSymbol = this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, returnTypeAnnotation, context); + + if (!returnTypeSymbol) { + signature.returnType = this.getNewErrorTypeSymbol(); + + hadError = true; + } else { + signature.returnType = returnTypeSymbol; + } + } else { + if (!setterAnnotatedType) { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, null, signature, false, funcDecl, context); + } else { + signature.returnType = setterAnnotatedType; + } + } + + if (!hadError) { + signature.setResolved(); + } + } + + return getterSymbol; + }; + + PullTypeResolver.prototype.checkIfGetterAndSetterTypeMatch = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + var getter = accessorSymbol.getGetter(); + var setter = accessorSymbol.getSetter(); + + if (getter && setter) { + var getterAST = getter.getDeclarations()[0].ast(); + var setterAST = setter.getDeclarations()[0].ast(); + + if (getterAST.typeAnnotation && PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterAST)) { + var setterSig = setter.type.getCallSignatures()[0]; + var setterParameters = setterSig.parameters; + + var getter = accessorSymbol.getGetter(); + var getterSig = getter.type.getCallSignatures()[0]; + + var setterSuppliedTypeSymbol = setterParameters[0].type; + var getterSuppliedTypeSymbol = getterSig.returnType; + + if (!this.typesAreIdentical(setterSuppliedTypeSymbol, getterSuppliedTypeSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.get_and_set_accessor_must_have_the_same_type)); + } + } + } + }; + + PullTypeResolver.prototype.typeCheckGetAccessorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + this.resolveReturnTypeAnnotationOfFunctionDeclaration(funcDeclAST, TypeScript.getType(funcDeclAST), context); + + this.resolveAST(funcDeclAST.block, false, context); + + this.validateVariableDeclarationGroups(funcDecl, context); + + var enclosingDecl = this.getEnclosingDecl(funcDecl); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + var funcNameAST = funcDeclAST.propertyName; + + if (!hasReturn && !(funcDeclAST.block.statements.childCount() > 0 && funcDeclAST.block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getters_must_return_a_value)); + } + + var setter = accessorSymbol.getSetter(); + if (setter) { + var setterDecl = setter.getDeclarations()[0]; + var setterIsPrivate = TypeScript.hasFlag(setterDecl.flags, 2 /* Private */); + var getterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */); + + if (getterIsPrivate != setterIsPrivate) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility)); + } + + this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context); + } + + this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), TypeScript.getType(funcDeclAST), funcDeclAST.block, context); + }; + + PullTypeResolver.hasSetAccessorParameterTypeAnnotation = function (setAccessor) { + return setAccessor.parameterList && setAccessor.parameterList.parameters.nonSeparatorCount() > 0 && setAccessor.parameterList.parameters.nonSeparatorAt(0).typeAnnotation != null; + }; + + PullTypeResolver.prototype.resolveSetAccessorDeclaration = function (funcDeclAST, parameterList, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + var setterSymbol = accessorSymbol.getSetter(); + var setterTypeSymbol = setterSymbol.type; + + var signature = funcDecl.getSignatureSymbol(); + + var hadError = false; + + if (signature) { + if (signature.isResolved) { + return setterSymbol; + } + + if (signature.inResolution) { + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + signature.setResolved(); + return setterSymbol; + } + + signature.startResolving(); + + if (parameterList) { + for (var i = 0; i < parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(parameterList.parameters.nonSeparatorAt(i), context); + } + } + + signature.returnType = this.semanticInfoChain.voidTypeSymbol; + + if (signature.hasAGenericParameter) { + setterTypeSymbol.setHasGenericSignature(); + } + + if (!hadError) { + signature.setResolved(); + } + } + + return setterSymbol; + }; + + PullTypeResolver.prototype.typeCheckSetAccessorDeclaration = function (funcDeclAST, context) { + var funcDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var accessorSymbol = funcDecl.getSymbol(); + + if (funcDeclAST.parameterList) { + for (var i = 0; i < funcDeclAST.parameterList.parameters.nonSeparatorCount(); i++) { + this.resolveParameter(funcDeclAST.parameterList.parameters.nonSeparatorAt(i), context); + } + } + + this.resolveAST(funcDeclAST.block, false, context); + + this.validateVariableDeclarationGroups(funcDecl, context); + + var hasReturn = (funcDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + var getter = accessorSymbol.getGetter(); + + var funcNameAST = funcDeclAST.propertyName; + + if (getter) { + var getterDecl = getter.getDeclarations()[0]; + var getterIsPrivate = TypeScript.hasFlag(getterDecl.flags, 2 /* Private */); + var setterIsPrivate = TypeScript.hasModifier(funcDeclAST.modifiers, 2 /* Private */); + + if (getterIsPrivate != setterIsPrivate) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcNameAST, TypeScript.DiagnosticCode.Getter_and_setter_accessors_do_not_agree_in_visibility)); + } + + this.checkIfGetterAndSetterTypeMatch(funcDeclAST, context); + } else { + if (this.compilationSettings.noImplicitAny()) { + var setterFunctionDeclarationAst = funcDeclAST; + if (!PullTypeResolver.hasSetAccessorParameterTypeAnnotation(setterFunctionDeclarationAst) && accessorSymbol.type == this.semanticInfoChain.anyTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_get_accessor_and_parameter_type_annotation_on_set_accessor_implicitly_has_an_any_type, [setterFunctionDeclarationAst.propertyName.text()])); + } + } + } + + this.checkFunctionTypePrivacy(funcDeclAST, TypeScript.hasModifier(funcDeclAST.modifiers, 16 /* Static */), null, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), null, funcDeclAST.block, context); + }; + + PullTypeResolver.prototype.resolveList = function (list, context) { + if (this.canTypeCheckAST(list, context)) { + this.setTypeChecked(list, context); + + for (var i = 0, n = list.childCount(); i < n; i++) { + this.resolveAST(list.childAt(i), false, context); + } + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveSeparatedList = function (list, context) { + if (this.canTypeCheckAST(list, context)) { + this.setTypeChecked(list, context); + + for (var i = 0, n = list.nonSeparatorCount(); i < n; i++) { + this.resolveAST(list.nonSeparatorAt(i), false, context); + } + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVoidExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.undefinedTypeSymbol; + }; + + PullTypeResolver.prototype.resolveLogicalOperation = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckLogicalOperation(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckLogicalOperation = function (binex, context) { + this.setTypeChecked(binex, context); + + var leftType = this.resolveAST(binex.left, false, context).type; + var rightType = this.resolveAST(binex.right, false, context).type; + + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsAssignableToTarget(leftType, rightType, binex, context, comparisonInfo) && !this.sourceIsAssignableToTarget(rightType, leftType, binex, context, comparisonInfo)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(binex); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binex, TypeScript.DiagnosticCode.Operator_0_cannot_be_applied_to_types_1_and_2, [ + TypeScript.SyntaxFacts.getText(TypeScript.SyntaxFacts.getOperatorTokenFromBinaryExpression(binex.kind())), + leftType.toString(enclosingSymbol), rightType.toString(enclosingSymbol)])); + } + }; + + PullTypeResolver.prototype.resolveLogicalNotExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.operand, false, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.resolveUnaryArithmeticOperation = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckUnaryArithmeticOperation(ast, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.resolvePostfixUnaryExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckPostfixUnaryExpression(ast, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.isAnyOrNumberOrEnum = function (type) { + return this.isAnyOrEquivalent(type) || type === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(type); + }; + + PullTypeResolver.prototype.typeCheckUnaryArithmeticOperation = function (unaryExpression, context) { + this.setTypeChecked(unaryExpression, context); + + var nodeType = unaryExpression.kind(); + var expression = this.resolveAST(unaryExpression.operand, false, context); + + if (nodeType == 164 /* PlusExpression */ || nodeType == 165 /* NegateExpression */ || nodeType == 166 /* BitwiseNotExpression */) { + return; + } + + TypeScript.Debug.assert(nodeType === 168 /* PreIncrementExpression */ || nodeType === 169 /* PreDecrementExpression */); + + var operandType = expression.type; + if (!this.isAnyOrNumberOrEnum(operandType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!this.isReference(unaryExpression.operand, expression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer)); + } + }; + + PullTypeResolver.prototype.typeCheckPostfixUnaryExpression = function (unaryExpression, context) { + this.setTypeChecked(unaryExpression, context); + + var nodeType = unaryExpression.kind(); + var expression = this.resolveAST(unaryExpression.operand, false, context); + + TypeScript.Debug.assert(nodeType === 210 /* PostIncrementExpression */ || nodeType === 211 /* PostDecrementExpression */); + + var operandType = expression.type; + if (!this.isAnyOrNumberOrEnum(operandType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_type_of_a_unary_arithmetic_operation_operand_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!this.isReference(unaryExpression.operand, expression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(unaryExpression.operand, TypeScript.DiagnosticCode.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer)); + } + }; + + PullTypeResolver.prototype.resolveBinaryArithmeticExpression = function (binaryExpression, context) { + if (this.canTypeCheckAST(binaryExpression, context)) { + this.typeCheckBinaryArithmeticExpression(binaryExpression, context); + } + + return this.semanticInfoChain.numberTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckBinaryArithmeticExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsSymbol = this.resolveAST(binaryExpression.left, false, context); + + var lhsType = lhsSymbol.type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) { + lhsType = rhsType; + } + + if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) { + rhsType = lhsType; + } + + var lhsIsFit = this.isAnyOrNumberOrEnum(lhsType); + var rhsIsFit = this.isAnyOrNumberOrEnum(rhsType); + + if (!rhsIsFit) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type)); + } + + if (!lhsIsFit) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type)); + } + + if (lhsIsFit && rhsIsFit) { + switch (binaryExpression.kind()) { + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + if (!this.isReference(binaryExpression.left, lhsSymbol)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } + + this.checkAssignability(binaryExpression.left, rhsType, lhsType, context); + } + } + }; + + PullTypeResolver.prototype.resolveTypeOfExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.stringTypeSymbol; + }; + + PullTypeResolver.prototype.resolveThrowStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveDeleteExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.resolveInstanceOfExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckInstanceOfExpression(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckInstanceOfExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsType = this.resolveAST(binaryExpression.left, false, context).type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + var enclosingSymbol = this.getEnclosingSymbolForAST(binaryExpression); + var isValidLHS = this.isAnyOrEquivalent(lhsType) || lhsType.isObject() || lhsType.isTypeParameter(); + var isValidRHS = this.isAnyOrEquivalent(rhsType) || this.typeIsSubtypeOfFunction(rhsType, binaryExpression, context); + + if (!isValidLHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.right, TypeScript.DiagnosticCode.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_a_subtype_of_the_Function_interface_type)); + } + }; + + PullTypeResolver.prototype.resolveCommaExpression = function (commaExpression, context) { + if (this.canTypeCheckAST(commaExpression, context)) { + this.setTypeChecked(commaExpression, context); + + this.resolveAST(commaExpression.left, false, context); + } + + var rhsType = this.resolveAST(commaExpression.right, false, context).type; + + return this.resolveAST(commaExpression.right, false, context).type; + }; + + PullTypeResolver.prototype.resolveInExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckInExpression(ast, context); + } + + return this.semanticInfoChain.booleanTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckInExpression = function (binaryExpression, context) { + this.setTypeChecked(binaryExpression, context); + + var lhsType = this.resolveAST(binaryExpression.left, false, context).type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + var isValidLHS = this.isAnyOrEquivalent(lhsType.type) || lhsType.type === this.semanticInfoChain.stringTypeSymbol || lhsType.type === this.semanticInfoChain.numberTypeSymbol; + + var isValidRHS = this.isAnyOrEquivalent(rhsType) || rhsType.isObject() || rhsType.isTypeParameter(); + + if (!isValidLHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + }; + + PullTypeResolver.prototype.resolveForStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.variableDeclaration, false, context); + this.resolveAST(ast.initializer, false, context); + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.incrementor, false, context); + this.resolveAST(ast.statement, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveForInStatement = function (forInStatement, context) { + if (this.canTypeCheckAST(forInStatement, context)) { + this.typeCheckForInStatement(forInStatement, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckForInStatement = function (forInStatement, context) { + this.setTypeChecked(forInStatement, context); + + var rhsType = this.resolveAST(forInStatement.expression, false, context).type; + var lval = forInStatement.variableDeclaration || forInStatement.left; + + var varSym = this.resolveAST(lval, false, context); + + if (forInStatement.variableDeclaration) { + var declaration = forInStatement.variableDeclaration; + var varDecl = declaration.declarators.nonSeparatorAt(0); + + if (varDecl.typeAnnotation) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lval, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_cannot_use_a_type_annotation)); + } + + var varSym = this.getSymbolForAST(varDecl, context); + } + + var isStringOrNumber = varSym.type === this.semanticInfoChain.stringTypeSymbol || this.isAnyOrEquivalent(varSym.type); + + var isValidRHS = rhsType && (this.isAnyOrEquivalent(rhsType) || !rhsType.isPrimitive()); + + if (!isStringOrNumber) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lval, TypeScript.DiagnosticCode.Variable_declarations_of_a_for_statement_must_be_of_types_string_or_any)); + } + + if (!isValidRHS) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(forInStatement.expression, TypeScript.DiagnosticCode.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter)); + } + + this.resolveAST(forInStatement.statement, false, context); + }; + + PullTypeResolver.prototype.resolveWhileStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckWhileStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckWhileStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveDoStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckDoStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckDoStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveIfStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckIfStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckIfStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.condition, false, context); + this.resolveAST(ast.statement, false, context); + this.resolveAST(ast.elseClause, false, context); + }; + + PullTypeResolver.prototype.resolveElseClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckElseClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckElseClause = function (ast, context) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.resolveBlock = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.statements, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVariableStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.declaration, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveVariableDeclarationList = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.declarators, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveWithStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckWithStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckWithStatement = function (ast, context) { + this.setTypeChecked(ast, context); + var withStatement = ast; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(withStatement.condition, TypeScript.DiagnosticCode.All_symbols_within_a_with_block_will_be_resolved_to_any)); + }; + + PullTypeResolver.prototype.resolveTryStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckTryStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckTryStatement = function (ast, context) { + this.setTypeChecked(ast, context); + var tryStatement = ast; + + this.resolveAST(tryStatement.block, false, context); + this.resolveAST(tryStatement.catchClause, false, context); + this.resolveAST(tryStatement.finallyClause, false, context); + }; + + PullTypeResolver.prototype.resolveCatchClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckCatchClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckCatchClause = function (ast, context) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.block, false, context); + + var catchDecl = this.semanticInfoChain.getDeclForAST(ast); + this.validateVariableDeclarationGroups(catchDecl, context); + }; + + PullTypeResolver.prototype.resolveFinallyClause = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckFinallyClause(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckFinallyClause = function (ast, context) { + this.setTypeChecked(ast, context); + this.resolveAST(ast.block, false, context); + }; + + PullTypeResolver.prototype.getEnclosingFunctionDeclaration = function (ast) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + + while (enclosingDecl) { + if (enclosingDecl.kind & 1032192 /* SomeFunction */) { + return enclosingDecl; + } + + enclosingDecl = enclosingDecl.getParentDecl(); + } + + return null; + }; + + PullTypeResolver.prototype.resolveReturnExpression = function (expression, enclosingFunction, context) { + if (enclosingFunction) { + enclosingFunction.setFlag(4194304 /* HasReturnStatement */); + } + + var isContextuallyTyped = false; + + if (enclosingFunction) { + var enclosingDeclAST = this.getASTForDecl(enclosingFunction); + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation) { + var returnTypeAnnotationSymbol = this.resolveTypeReference(typeAnnotation, context); + if (returnTypeAnnotationSymbol) { + isContextuallyTyped = true; + context.pushContextualType(returnTypeAnnotationSymbol, context.inProvisionalResolution(), null); + } + } else { + var currentContextualType = context.getContextualType(); + if (currentContextualType && currentContextualType.isFunction()) { + var currentContextTypeDecls = currentContextualType.getDeclarations(); + var currentContextualTypeSignatureSymbol = currentContextTypeDecls && currentContextTypeDecls.length > 0 ? currentContextTypeDecls[0].getSignatureSymbol() : currentContextualType.getCallSignatures()[0]; + + var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType; + if (currentContextualTypeReturnTypeSymbol) { + isContextuallyTyped = true; + context.pushContextualType(currentContextualTypeReturnTypeSymbol, context.inProvisionalResolution(), null); + } + } + } + } + + var result = this.resolveAST(expression, isContextuallyTyped, context).type; + if (isContextuallyTyped) { + context.popContextualType(); + } + + return result; + }; + + PullTypeResolver.prototype.typeCheckReturnExpression = function (expression, expressionType, enclosingFunction, context) { + if (enclosingFunction && enclosingFunction.kind === 32768 /* ConstructorMethod */) { + var classDecl = enclosingFunction.getParentDecl(); + if (classDecl) { + var classSymbol = classDecl.getSymbol(); + this.resolveDeclaredSymbol(classSymbol, context); + + var comparisonInfo = new TypeComparisonInfo(); + var isAssignable = this.sourceIsAssignableToTarget(expressionType, classSymbol.type, expression, context, comparisonInfo); + if (!isAssignable) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class)); + } + } + } + + if (enclosingFunction && enclosingFunction.kind === 524288 /* SetAccessor */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Setters_cannot_return_a_value)); + } + + if (enclosingFunction) { + var enclosingDeclAST = this.getASTForDecl(enclosingFunction); + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation || enclosingFunction.kind === 262144 /* GetAccessor */) { + var signatureSymbol = enclosingFunction.getSignatureSymbol(); + var sigReturnType = signatureSymbol.returnType; + + if (expressionType && sigReturnType) { + var comparisonInfo = new TypeComparisonInfo(); + var upperBound = null; + + if (expressionType.isTypeParameter()) { + upperBound = expressionType.getConstraint(); + + if (upperBound) { + expressionType = upperBound; + } + } + + if (sigReturnType.isTypeParameter()) { + upperBound = sigReturnType.getConstraint(); + + if (upperBound) { + sigReturnType = upperBound; + } + } + + this.resolveDeclaredSymbol(expressionType, context); + this.resolveDeclaredSymbol(sigReturnType, context); + + var isAssignable = this.sourceIsAssignableToTarget(expressionType, sigReturnType, expression, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(expression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [expressionType.toString(enclosingSymbol), sigReturnType.toString(enclosingSymbol)])); + } + } + } + } + } + }; + + PullTypeResolver.prototype.resolveReturnStatement = function (returnAST, context) { + var enclosingFunction = this.getEnclosingFunctionDeclaration(returnAST); + if (enclosingFunction) { + enclosingFunction.setFlag(4194304 /* HasReturnStatement */); + } + + var returnType = this.getSymbolForAST(returnAST, context); + var canTypeCheckAST = this.canTypeCheckAST(returnAST, context); + if (!returnType || canTypeCheckAST) { + var returnExpr = returnAST.expression; + + var resolvedReturnType = returnExpr === null ? this.semanticInfoChain.voidTypeSymbol : this.resolveReturnExpression(returnExpr, enclosingFunction, context); + + if (!returnType) { + returnType = resolvedReturnType; + this.setSymbolForAST(returnAST, resolvedReturnType, context); + } + + if (returnExpr && canTypeCheckAST) { + this.setTypeChecked(returnExpr, context); + this.typeCheckReturnExpression(returnExpr, resolvedReturnType, enclosingFunction, context); + } + } + + return returnType; + }; + + PullTypeResolver.prototype.resolveSwitchStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckSwitchStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckSwitchStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + var expressionType = this.resolveAST(ast.expression, false, context).type; + + for (var i = 0, n = ast.switchClauses.childCount(); i < n; i++) { + var switchClause = ast.switchClauses.childAt(i); + if (switchClause.kind() === 233 /* CaseSwitchClause */) { + var caseSwitchClause = switchClause; + + var caseClauseExpressionType = this.resolveAST(caseSwitchClause.expression, false, context).type; + this.resolveAST(caseSwitchClause.statements, false, context); + + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsAssignableToTarget(expressionType, caseClauseExpressionType, caseSwitchClause.expression, context, comparisonInfo) && !this.sourceIsAssignableToTarget(caseClauseExpressionType, expressionType, caseSwitchClause.expression, context, comparisonInfo)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(caseSwitchClause.expression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(caseSwitchClause.expression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [caseClauseExpressionType.toString(enclosingSymbol), expressionType.toString(enclosingSymbol)])); + } + } + } else { + var defaultSwitchClause = switchClause; + this.resolveAST(defaultSwitchClause.statements, false, context); + } + } + }; + + PullTypeResolver.prototype.resolveLabeledStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckLabeledStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckLabeledStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + var labelIdentifier = ast.identifier.valueText(); + + var breakableLabels = this.getEnclosingLabels(ast, true, false); + + if (TypeScript.ArrayUtilities.contains(breakableLabels, labelIdentifier)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast.identifier, TypeScript.DiagnosticCode.Duplicate_identifier_0, [labelIdentifier])); + } + + this.resolveAST(ast.statement, false, context); + }; + + PullTypeResolver.prototype.labelIsOnContinuableConstruct = function (statement) { + switch (statement.kind()) { + case 160 /* LabeledStatement */: + return this.labelIsOnContinuableConstruct(statement.statement); + + case 158 /* WhileStatement */: + case 154 /* ForStatement */: + case 155 /* ForInStatement */: + case 161 /* DoStatement */: + return true; + + default: + return false; + } + }; + + PullTypeResolver.prototype.resolveContinueStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckContinueStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.isIterationStatement = function (ast) { + switch (ast.kind()) { + case 154 /* ForStatement */: + case 155 /* ForInStatement */: + case 158 /* WhileStatement */: + case 161 /* DoStatement */: + return true; + } + + return false; + }; + + PullTypeResolver.prototype.isAnyFunctionExpressionOrDeclaration = function (ast) { + switch (ast.kind()) { + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + case 129 /* FunctionDeclaration */: + case 135 /* MemberFunctionDeclaration */: + case 241 /* FunctionPropertyAssignment */: + case 137 /* ConstructorDeclaration */: + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + return true; + } + + return false; + }; + + PullTypeResolver.prototype.inSwitchStatement = function (ast) { + while (ast) { + if (ast.kind() === 151 /* SwitchStatement */) { + return true; + } + + if (this.isAnyFunctionExpressionOrDeclaration(ast)) { + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inIterationStatement = function (ast) { + while (ast) { + if (this.isIterationStatement(ast)) { + return true; + } + + if (this.isAnyFunctionExpressionOrDeclaration(ast)) { + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.getEnclosingLabels = function (ast, breakable, crossFunctions) { + var result = []; + + ast = ast.parent; + while (ast) { + if (ast.kind() === 160 /* LabeledStatement */) { + var labeledStatement = ast; + if (breakable) { + result.push(labeledStatement.identifier.valueText()); + } else { + if (this.labelIsOnContinuableConstruct(labeledStatement.statement)) { + result.push(labeledStatement.identifier.valueText()); + } + } + } + + if (!crossFunctions && this.isAnyFunctionExpressionOrDeclaration(ast)) { + break; + } + + ast = ast.parent; + } + + return result; + }; + + PullTypeResolver.prototype.typeCheckContinueStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + if (!this.inIterationStatement(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.continue_statement_can_only_be_used_within_an_enclosing_iteration_statement)); + } else if (ast.identifier) { + var continuableLabels = this.getEnclosingLabels(ast, false, false); + + if (!TypeScript.ArrayUtilities.contains(continuableLabels, ast.identifier.valueText())) { + var continuableLabels = this.getEnclosingLabels(ast, false, true); + + if (TypeScript.ArrayUtilities.contains(continuableLabels, ast.identifier.valueText())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found)); + } + } + } + }; + + PullTypeResolver.prototype.resolveBreakStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckBreakStatement(ast, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckBreakStatement = function (ast, context) { + this.setTypeChecked(ast, context); + + if (ast.identifier) { + var breakableLabels = this.getEnclosingLabels(ast, true, false); + + if (!TypeScript.ArrayUtilities.contains(breakableLabels, ast.identifier.valueText())) { + var breakableLabels = this.getEnclosingLabels(ast, true, true); + if (TypeScript.ArrayUtilities.contains(breakableLabels, ast.identifier.valueText())) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_cannot_cross_function_boundary)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Jump_target_not_found)); + } + } + } else if (!this.inIterationStatement(ast) && !this.inSwitchStatement(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement)); + } + }; + + PullTypeResolver.prototype.resolveAST = function (ast, isContextuallyTyped, context) { + if (!ast) { + return; + } + + var symbol = this.getSymbolForAST(ast, context); + if (symbol && symbol.isResolved) { + this.typeCheckAST(ast, isContextuallyTyped, context); + return symbol; + } + + var nodeType = ast.kind(); + + switch (nodeType) { + case 124 /* ArrayType */: + case 126 /* GenericType */: + case 122 /* ObjectType */: + case 127 /* TypeQuery */: + case 125 /* ConstructorType */: + case 123 /* FunctionType */: + return this.resolveTypeReference(ast, context); + + case 1 /* List */: + return this.resolveList(ast, context); + + case 2 /* SeparatedList */: + return this.resolveSeparatedList(ast, context); + + case 120 /* SourceUnit */: + return this.resolveSourceUnit(ast, context); + + case 132 /* EnumDeclaration */: + return this.resolveEnumDeclaration(ast, context); + + case 130 /* ModuleDeclaration */: + return this.resolveModuleDeclaration(ast, context); + + case 128 /* InterfaceDeclaration */: + return this.resolveInterfaceDeclaration(ast, context); + + case 131 /* ClassDeclaration */: + return this.resolveClassDeclaration(ast, context); + + case 224 /* VariableDeclaration */: + return this.resolveVariableDeclarationList(ast, context); + + case 136 /* MemberVariableDeclaration */: + return this.resolveMemberVariableDeclaration(ast, context); + + case 225 /* VariableDeclarator */: + return this.resolveVariableDeclarator(ast, context); + + case 141 /* PropertySignature */: + return this.resolvePropertySignature(ast, context); + + case 227 /* ParameterList */: + return this.resolveParameterList(ast, context); + + case 242 /* Parameter */: + return this.resolveParameter(ast, context); + + case 243 /* EnumElement */: + return this.resolveEnumElement(ast, context); + + case 232 /* EqualsValueClause */: + return this.resolveEqualsValueClause(ast, isContextuallyTyped, context); + + case 238 /* TypeParameter */: + return this.resolveTypeParameterDeclaration(ast, context); + + case 239 /* Constraint */: + return this.resolveConstraint(ast, context); + + case 133 /* ImportDeclaration */: + return this.resolveImportDeclaration(ast, context); + + case 215 /* ObjectLiteralExpression */: + return this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context); + + case 240 /* SimplePropertyAssignment */: + return this.resolveSimplePropertyAssignment(ast, isContextuallyTyped, context); + + case 241 /* FunctionPropertyAssignment */: + return this.resolveFunctionPropertyAssignment(ast, isContextuallyTyped, context); + + case 11 /* IdentifierName */: + if (isTypesOnlyLocation(ast)) { + return this.resolveTypeNameExpression(ast, context); + } else { + return this.resolveNameExpression(ast, context); + } + + case 212 /* MemberAccessExpression */: + return this.resolveMemberAccessExpression(ast, context); + + case 121 /* QualifiedName */: + return this.resolveQualifiedName(ast, context); + + case 137 /* ConstructorDeclaration */: + return this.resolveConstructorDeclaration(ast, context); + + case 139 /* GetAccessor */: + case 140 /* SetAccessor */: + return this.resolveAccessorDeclaration(ast, context); + + case 138 /* IndexMemberDeclaration */: + return this.resolveIndexMemberDeclaration(ast, context); + + case 144 /* IndexSignature */: + return this.resolveIndexSignature(ast, context); + + case 135 /* MemberFunctionDeclaration */: + return this.resolveMemberFunctionDeclaration(ast, context); + + case 142 /* CallSignature */: + return this.resolveCallSignature(ast, context); + + case 143 /* ConstructSignature */: + return this.resolveConstructSignature(ast, context); + + case 145 /* MethodSignature */: + return this.resolveMethodSignature(ast, context); + + case 129 /* FunctionDeclaration */: + return this.resolveAnyFunctionDeclaration(ast, context); + + case 222 /* FunctionExpression */: + return this.resolveFunctionExpression(ast, isContextuallyTyped, context); + + case 219 /* SimpleArrowFunctionExpression */: + return this.resolveSimpleArrowFunctionExpression(ast, isContextuallyTyped, context); + + case 218 /* ParenthesizedArrowFunctionExpression */: + return this.resolveParenthesizedArrowFunctionExpression(ast, isContextuallyTyped, context); + + case 214 /* ArrayLiteralExpression */: + return this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context); + + case 35 /* ThisKeyword */: + return this.resolveThisExpression(ast, context); + + case 50 /* SuperKeyword */: + return this.resolveSuperExpression(ast, context); + + case 213 /* InvocationExpression */: + return this.resolveInvocationExpression(ast, context); + + case 216 /* ObjectCreationExpression */: + return this.resolveObjectCreationExpression(ast, context); + + case 220 /* CastExpression */: + return this.resolveCastExpression(ast, context); + + case 244 /* TypeAnnotation */: + return this.resolveTypeAnnotation(ast, context); + + case 134 /* ExportAssignment */: + return this.resolveExportAssignmentStatement(ast, context); + + case 13 /* NumericLiteral */: + return this.semanticInfoChain.numberTypeSymbol; + + case 14 /* StringLiteral */: + return this.semanticInfoChain.stringTypeSymbol; + + case 32 /* NullKeyword */: + return this.semanticInfoChain.nullTypeSymbol; + + case 37 /* TrueKeyword */: + case 24 /* FalseKeyword */: + return this.semanticInfoChain.booleanTypeSymbol; + + case 172 /* VoidExpression */: + return this.resolveVoidExpression(ast, context); + + case 174 /* AssignmentExpression */: + return this.resolveAssignmentExpression(ast, context); + + case 167 /* LogicalNotExpression */: + return this.resolveLogicalNotExpression(ast, context); + + case 193 /* NotEqualsWithTypeConversionExpression */: + case 192 /* EqualsWithTypeConversionExpression */: + case 194 /* EqualsExpression */: + case 195 /* NotEqualsExpression */: + case 196 /* LessThanExpression */: + case 198 /* LessThanOrEqualExpression */: + case 199 /* GreaterThanOrEqualExpression */: + case 197 /* GreaterThanExpression */: + return this.resolveLogicalOperation(ast, context); + + case 208 /* AddExpression */: + case 175 /* AddAssignmentExpression */: + return this.resolveBinaryAdditionOperation(ast, context); + + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + case 166 /* BitwiseNotExpression */: + case 168 /* PreIncrementExpression */: + case 169 /* PreDecrementExpression */: + return this.resolveUnaryArithmeticOperation(ast, context); + + case 210 /* PostIncrementExpression */: + case 211 /* PostDecrementExpression */: + return this.resolvePostfixUnaryExpression(ast, context); + + case 209 /* SubtractExpression */: + case 205 /* MultiplyExpression */: + case 206 /* DivideExpression */: + case 207 /* ModuloExpression */: + case 189 /* BitwiseOrExpression */: + case 191 /* BitwiseAndExpression */: + case 202 /* LeftShiftExpression */: + case 203 /* SignedRightShiftExpression */: + case 204 /* UnsignedRightShiftExpression */: + case 190 /* BitwiseExclusiveOrExpression */: + case 181 /* ExclusiveOrAssignmentExpression */: + case 183 /* LeftShiftAssignmentExpression */: + case 184 /* SignedRightShiftAssignmentExpression */: + case 185 /* UnsignedRightShiftAssignmentExpression */: + case 176 /* SubtractAssignmentExpression */: + case 177 /* MultiplyAssignmentExpression */: + case 178 /* DivideAssignmentExpression */: + case 179 /* ModuloAssignmentExpression */: + case 182 /* OrAssignmentExpression */: + case 180 /* AndAssignmentExpression */: + return this.resolveBinaryArithmeticExpression(ast, context); + + case 221 /* ElementAccessExpression */: + return this.resolveElementAccessExpression(ast, context); + + case 187 /* LogicalOrExpression */: + return this.resolveLogicalOrExpression(ast, isContextuallyTyped, context); + + case 188 /* LogicalAndExpression */: + return this.resolveLogicalAndExpression(ast, context); + + case 171 /* TypeOfExpression */: + return this.resolveTypeOfExpression(ast, context); + + case 157 /* ThrowStatement */: + return this.resolveThrowStatement(ast, context); + + case 170 /* DeleteExpression */: + return this.resolveDeleteExpression(ast, context); + + case 186 /* ConditionalExpression */: + return this.resolveConditionalExpression(ast, isContextuallyTyped, context); + + case 12 /* RegularExpressionLiteral */: + return this.resolveRegularExpressionLiteral(); + + case 217 /* ParenthesizedExpression */: + return this.resolveParenthesizedExpression(ast, context); + + case 149 /* ExpressionStatement */: + return this.resolveExpressionStatement(ast, context); + + case 200 /* InstanceOfExpression */: + return this.resolveInstanceOfExpression(ast, context); + + case 173 /* CommaExpression */: + return this.resolveCommaExpression(ast, context); + + case 201 /* InExpression */: + return this.resolveInExpression(ast, context); + + case 154 /* ForStatement */: + return this.resolveForStatement(ast, context); + + case 155 /* ForInStatement */: + return this.resolveForInStatement(ast, context); + + case 158 /* WhileStatement */: + return this.resolveWhileStatement(ast, context); + + case 161 /* DoStatement */: + return this.resolveDoStatement(ast, context); + + case 147 /* IfStatement */: + return this.resolveIfStatement(ast, context); + + case 235 /* ElseClause */: + return this.resolveElseClause(ast, context); + + case 146 /* Block */: + return this.resolveBlock(ast, context); + + case 148 /* VariableStatement */: + return this.resolveVariableStatement(ast, context); + + case 163 /* WithStatement */: + return this.resolveWithStatement(ast, context); + + case 159 /* TryStatement */: + return this.resolveTryStatement(ast, context); + + case 236 /* CatchClause */: + return this.resolveCatchClause(ast, context); + + case 237 /* FinallyClause */: + return this.resolveFinallyClause(ast, context); + + case 150 /* ReturnStatement */: + return this.resolveReturnStatement(ast, context); + + case 151 /* SwitchStatement */: + return this.resolveSwitchStatement(ast, context); + + case 153 /* ContinueStatement */: + return this.resolveContinueStatement(ast, context); + + case 152 /* BreakStatement */: + return this.resolveBreakStatement(ast, context); + + case 160 /* LabeledStatement */: + return this.resolveLabeledStatement(ast, context); + } + + return this.semanticInfoChain.anyTypeSymbol; + }; + + PullTypeResolver.prototype.typeCheckAST = function (ast, isContextuallyTyped, context) { + if (!this.canTypeCheckAST(ast, context)) { + return; + } + + var nodeType = ast.kind(); + switch (nodeType) { + case 120 /* SourceUnit */: + this.typeCheckSourceUnit(ast, context); + return; + + case 132 /* EnumDeclaration */: + this.typeCheckEnumDeclaration(ast, context); + return; + + case 130 /* ModuleDeclaration */: + this.typeCheckModuleDeclaration(ast, context); + return; + + case 128 /* InterfaceDeclaration */: + this.typeCheckInterfaceDeclaration(ast, context); + return; + + case 131 /* ClassDeclaration */: + this.typeCheckClassDeclaration(ast, context); + return; + + case 243 /* EnumElement */: + this.typeCheckEnumElement(ast, context); + return; + + case 136 /* MemberVariableDeclaration */: + this.typeCheckMemberVariableDeclaration(ast, context); + return; + + case 225 /* VariableDeclarator */: + this.typeCheckVariableDeclarator(ast, context); + return; + + case 141 /* PropertySignature */: + this.typeCheckPropertySignature(ast, context); + return; + + case 242 /* Parameter */: + this.typeCheckParameter(ast, context); + return; + + case 133 /* ImportDeclaration */: + this.typeCheckImportDeclaration(ast, context); + return; + + case 215 /* ObjectLiteralExpression */: + this.resolveObjectLiteralExpression(ast, isContextuallyTyped, context); + return; + + case 241 /* FunctionPropertyAssignment */: + this.typeCheckFunctionPropertyAssignment(ast, isContextuallyTyped, context); + return; + + case 11 /* IdentifierName */: + if (isTypesOnlyLocation(ast)) { + this.resolveTypeNameExpression(ast, context); + } else { + this.resolveNameExpression(ast, context); + } + return; + + case 212 /* MemberAccessExpression */: + this.resolveMemberAccessExpression(ast, context); + return; + + case 121 /* QualifiedName */: + this.resolveQualifiedName(ast, context); + return; + + case 222 /* FunctionExpression */: + this.typeCheckFunctionExpression(ast, context); + break; + + case 144 /* IndexSignature */: + this.typeCheckIndexSignature(ast, context); + break; + + case 142 /* CallSignature */: + this.typeCheckCallSignature(ast, context); + break; + + case 143 /* ConstructSignature */: + this.typeCheckConstructSignature(ast, context); + break; + + case 129 /* FunctionDeclaration */: { + var funcDecl = ast; + this.typeCheckFunctionDeclaration(funcDecl, TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */), funcDecl.identifier, funcDecl.callSignature.typeParameterList, funcDecl.callSignature.parameterList, TypeScript.getType(funcDecl), funcDecl.block, context); + return; + } + + case 219 /* SimpleArrowFunctionExpression */: + this.typeCheckSimpleArrowFunctionExpression(ast, context); + return; + + case 218 /* ParenthesizedArrowFunctionExpression */: + this.typeCheckParenthesizedArrowFunctionExpression(ast, context); + return; + + case 214 /* ArrayLiteralExpression */: + this.resolveArrayLiteralExpression(ast, isContextuallyTyped, context); + return; + + case 213 /* InvocationExpression */: + this.typeCheckInvocationExpression(ast, context); + return; + + case 216 /* ObjectCreationExpression */: + this.typeCheckObjectCreationExpression(ast, context); + return; + + case 150 /* ReturnStatement */: + this.resolveReturnStatement(ast, context); + return; + + default: + TypeScript.Debug.assert(false, "Failure nodeType: " + TypeScript.SyntaxKind[ast.kind()] + ". Implement typeCheck when symbol is set for the ast as part of resolution."); + } + }; + + PullTypeResolver.prototype.processPostTypeCheckWorkItems = function (context) { + while (this.postTypeCheckWorkitems.length) { + var ast = this.postTypeCheckWorkitems.pop(); + this.postTypeCheck(ast, context); + } + }; + + PullTypeResolver.prototype.postTypeCheck = function (ast, context) { + var nodeType = ast.kind(); + + switch (nodeType) { + case 242 /* Parameter */: + case 225 /* VariableDeclarator */: + this.postTypeCheckVariableDeclaratorOrParameter(ast, context); + return; + + case 131 /* ClassDeclaration */: + this.postTypeCheckClassDeclaration(ast, context); + return; + + case 129 /* FunctionDeclaration */: + this.postTypeCheckFunctionDeclaration(ast, context); + return; + + case 130 /* ModuleDeclaration */: + this.postTypeCheckModuleDeclaration(ast, context); + return; + + case 132 /* EnumDeclaration */: + this.postTypeCheckEnumDeclaration(ast, context); + return; + + case 133 /* ImportDeclaration */: + this.postTypeCheckImportDeclaration(ast, context); + return; + + case 11 /* IdentifierName */: + this.postTypeCheckNameExpression(ast, context); + return; + + default: + TypeScript.Debug.assert(false, "Implement postTypeCheck clause to handle the postTypeCheck work, nodeType: " + TypeScript.SyntaxKind[ast.kind()]); + } + }; + + PullTypeResolver.prototype.resolveRegularExpressionLiteral = function () { + if (this.cachedRegExpInterfaceType()) { + return this.cachedRegExpInterfaceType(); + } else { + return this.semanticInfoChain.anyTypeSymbol; + } + }; + + PullTypeResolver.prototype.postTypeCheckNameExpression = function (nameAST, context) { + this.checkThisCaptureVariableCollides(nameAST, false, context); + }; + + PullTypeResolver.prototype.typeCheckNameExpression = function (nameAST, context) { + this.setTypeChecked(nameAST, context); + this.checkNameForCompilerGeneratedDeclarationCollision(nameAST, false, nameAST, context); + }; + + PullTypeResolver.prototype.resolveNameExpression = function (nameAST, context) { + var nameSymbol = this.getSymbolForAST(nameAST, context); + var foundCached = nameSymbol != null; + + if (!foundCached || this.canTypeCheckAST(nameAST, context)) { + if (this.canTypeCheckAST(nameAST, context)) { + this.typeCheckNameExpression(nameAST, context); + } + nameSymbol = this.computeNameExpression(nameAST, context, true); + } + + this.resolveDeclaredSymbol(nameSymbol, context); + + if (nameSymbol && (nameSymbol.type != this.semanticInfoChain.anyTypeSymbol || nameSymbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) { + this.setSymbolForAST(nameAST, nameSymbol, context); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.isSomeFunctionScope = function (declPath) { + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + if (decl.kind & 1032192 /* SomeFunction */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.computeNameExpression = function (nameAST, context, reportDiagnostics) { + var id = nameAST.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var nameSymbol = null; + var enclosingDecl = this.getEnclosingDeclForAST(nameAST); + + if (TypeScript.isDeclarationASTOrDeclarationNameAST(nameAST)) { + nameSymbol = this.semanticInfoChain.getDeclForAST(nameAST.parent).getSymbol(); + } + + var declPath = enclosingDecl.getParentPath(); + + if (!nameSymbol) { + var nameSymbol = this.getSymbolFromDeclPath(id, declPath, 68147712 /* SomeValue */); + } + + if (!nameSymbol && id === "arguments" && this.isSomeFunctionScope(declPath)) { + nameSymbol = this.cachedFunctionArgumentsSymbol(); + + this.resolveDeclaredSymbol(this.cachedIArgumentsInterfaceType(), context); + } + + if (!nameSymbol) { + nameSymbol = this.getSymbolFromDeclPath(id, declPath, 128 /* TypeAlias */); + + if (nameSymbol && !nameSymbol.isAlias()) { + nameSymbol = null; + } + } + + if (!nameSymbol) { + if (!reportDiagnostics) { + return null; + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + } + + var nameDeclaration = nameSymbol.getDeclarations()[0]; + var nameParentDecl = nameDeclaration.getParentDecl(); + if (nameParentDecl && (nameParentDecl.kind & 1032192 /* SomeFunction */) && (nameParentDecl.flags & 33554432 /* HasDefaultArgs */)) { + var enclosingFunctionAST = this.semanticInfoChain.getASTForDecl(nameParentDecl); + var currentParameterIndex = this.getCurrentParameterIndexForFunction(nameAST, enclosingFunctionAST); + + var parameterList = TypeScript.getParameterList(enclosingFunctionAST); + + if (currentParameterIndex >= 0) { + var foundMatchingParameter = false; + if (parameterList) { + for (var i = 0; i <= currentParameterIndex; i++) { + var candidateParameter = parameterList.parameters.nonSeparatorAt(i); + if (candidateParameter && candidateParameter.identifier.valueText() === id) { + foundMatchingParameter = true; + } + } + } + + if (!foundMatchingParameter) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it, [parameterList.parameters.nonSeparatorAt(currentParameterIndex).identifier.text(), nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + } + } + + var aliasSymbol = null; + + if (nameSymbol.isType() && nameSymbol.isAlias()) { + aliasSymbol = nameSymbol; + if (!this.inTypeQuery(nameAST)) { + aliasSymbol.setIsUsedAsValue(true); + } + + this.resolveDeclaredSymbol(nameSymbol, context); + + this.resolveDeclaredSymbol(aliasSymbol.assignedValue(), context); + this.resolveDeclaredSymbol(aliasSymbol.assignedContainer(), context); + + var exportAssignmentSymbol = nameSymbol.getExportAssignedValueSymbol(); + + if (exportAssignmentSymbol) { + nameSymbol = exportAssignmentSymbol; + } else { + aliasSymbol = null; + } + } + + if (aliasSymbol) { + this.semanticInfoChain.setAliasSymbolForAST(nameAST, aliasSymbol); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.getCurrentParameterIndexForFunction = function (parameter, funcDecl) { + var parameterList = TypeScript.getParameterList(funcDecl); + if (parameterList) { + while (parameter && parameter.parent) { + if (parameter.parent.parent === parameterList) { + return parameterList.parameters.nonSeparatorIndexOf(parameter); + } + + parameter = parameter.parent; + } + } + + return -1; + }; + + PullTypeResolver.prototype.resolveMemberAccessExpression = function (dottedNameAST, context) { + return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.expression, dottedNameAST.name, context); + }; + + PullTypeResolver.prototype.resolveDottedNameExpression = function (dottedNameAST, expression, name, context) { + var symbol = this.getSymbolForAST(dottedNameAST, context); + var foundCached = symbol != null; + + if (!foundCached || this.canTypeCheckAST(dottedNameAST, context)) { + var canTypeCheckDottedNameAST = this.canTypeCheckAST(dottedNameAST, context); + if (canTypeCheckDottedNameAST) { + this.setTypeChecked(dottedNameAST, context); + } + + symbol = this.computeDottedNameExpression(expression, name, context, canTypeCheckDottedNameAST); + } + + this.resolveDeclaredSymbol(symbol, context); + + if (symbol && (symbol.type != this.semanticInfoChain.anyTypeSymbol || symbol.anyDeclHasFlag(16777216 /* IsAnnotatedWithAny */ | 1 /* Exported */))) { + this.setSymbolForAST(dottedNameAST, symbol, context); + this.setSymbolForAST(name, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.computeDottedNameExpression = function (expression, name, context, checkSuperPrivateAndStaticAccess) { + var rhsName = name.valueText(); + if (rhsName.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var lhs = this.resolveAST(expression, false, context); + var lhsType = lhs.type; + + if (lhs.isAlias()) { + if (!this.inTypeQuery(expression)) { + lhs.setIsUsedAsValue(true); + } + lhsType = lhs.getExportAssignedTypeSymbol(); + } + + if (this.isAnyOrEquivalent(lhsType)) { + return lhsType; + } + + if (lhsType.isAlias()) { + lhsType = lhsType.getExportAssignedTypeSymbol(); + } + + if (!lhsType) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Could_not_find_enclosing_symbol_for_dotted_name_0, [name.text()])); + return this.getNewErrorTypeSymbol(); + } + + if (!lhsType.isResolved) { + var potentiallySpecializedType = this.resolveDeclaredSymbol(lhsType, context); + + if (potentiallySpecializedType != lhsType) { + if (!lhs.isType()) { + context.setTypeInContext(lhs, potentiallySpecializedType); + } + + lhsType = potentiallySpecializedType; + } + } + + if (lhsType.isContainer() && !lhsType.isAlias() && !lhsType.isEnum()) { + var instanceSymbol = lhsType.getInstanceSymbol(); + + if (instanceSymbol) { + lhsType = instanceSymbol.type; + } + } + + if (lhsType.isTypeParameter()) { + lhsType = this.substituteUpperBoundForType(lhsType); + } + + if ((lhsType === this.semanticInfoChain.numberTypeSymbol || lhsType.isEnum()) && this.cachedNumberInterfaceType()) { + lhsType = this.cachedNumberInterfaceType(); + } else if (lhsType === this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + lhsType = this.cachedStringInterfaceType(); + } else if (lhsType === this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + lhsType = this.cachedBooleanInterfaceType(); + } + + var nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, lhsType); + + if (!nameSymbol) { + if ((lhsType.getCallSignatures().length || lhsType.getConstructSignatures().length) && this.cachedFunctionInterfaceType()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, this.cachedFunctionInterfaceType()); + } else if (lhsType.kind === 32 /* DynamicModule */) { + var container = lhsType; + var associatedInstance = container.getInstanceSymbol(); + + if (associatedInstance) { + var instanceType = associatedInstance.type; + + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, instanceType); + } + } else { + var associatedType = lhsType.getAssociatedContainerType(); + + if (associatedType && !associatedType.isClass()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, associatedType); + } + } + + if (!nameSymbol && !lhsType.isPrimitive() && this.cachedObjectInterfaceType()) { + nameSymbol = this.getMemberSymbol(rhsName, 68147712 /* SomeValue */, this.cachedObjectInterfaceType()); + } + + if (!nameSymbol) { + var enclosingDecl = this.getEnclosingDeclForAST(expression); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [name.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + return this.getNewErrorTypeSymbol(rhsName); + } + } + + if (checkSuperPrivateAndStaticAccess) { + this.checkForSuperMemberAccess(expression, name, nameSymbol, context) || this.checkForPrivateMemberAccess(name, lhsType, nameSymbol, context); + } + + return nameSymbol; + }; + + PullTypeResolver.prototype.resolveTypeNameExpression = function (nameAST, context) { + var typeNameSymbol = this.getSymbolForAST(nameAST, context); + + if (!typeNameSymbol || !typeNameSymbol.isType() || this.canTypeCheckAST(nameAST, context)) { + if (this.canTypeCheckAST(nameAST, context)) { + this.setTypeChecked(nameAST, context); + } + typeNameSymbol = this.computeTypeNameExpression(nameAST, context); + this.setSymbolForAST(nameAST, typeNameSymbol, context); + } + + this.resolveDeclaredSymbol(typeNameSymbol, context); + + return typeNameSymbol; + }; + + PullTypeResolver.prototype.computeTypeNameExpression = function (nameAST, context) { + var id = nameAST.valueText(); + if (id.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var enclosingDecl = this.getEnclosingDeclForAST(nameAST); + + var declPath = enclosingDecl.getParentPath(); + + var onLeftOfDot = this.isLeftSideOfQualifiedName(nameAST); + + var kindToCheckFirst = onLeftOfDot ? 164 /* SomeContainer */ : 58728539 /* SomeType */; + var kindToCheckSecond = onLeftOfDot ? 58728539 /* SomeType */ : 164 /* SomeContainer */; + + var typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckFirst); + + if (!typeNameSymbol) { + typeNameSymbol = this.getSymbolFromDeclPath(id, declPath, kindToCheckSecond); + } + + if (!typeNameSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Could_not_find_symbol_0, [nameAST.text()])); + return this.getNewErrorTypeSymbol(id); + } + + var typeNameSymbolAlias = null; + if (typeNameSymbol.isAlias()) { + typeNameSymbolAlias = typeNameSymbol; + this.resolveDeclaredSymbol(typeNameSymbol, context); + + var aliasedType = typeNameSymbolAlias.getExportAssignedTypeSymbol(); + + this.resolveDeclaredSymbol(aliasedType, context); + } + + if (typeNameSymbol.isTypeParameter()) { + if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */) && (enclosingDecl.flags & 16 /* Static */)) { + var parentDecl = typeNameSymbol.getDeclarations()[0].getParentDecl(); + + if (parentDecl.kind == 8 /* Class */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(nameAST, TypeScript.DiagnosticCode.Static_methods_cannot_reference_class_type_parameters)); + return this.getNewErrorTypeSymbol(); + } + } + } + + if (!typeNameSymbol.isGeneric() && (typeNameSymbol.isClass() || typeNameSymbol.isInterface())) { + typeNameSymbol = TypeScript.PullTypeReferenceSymbol.createTypeReference(typeNameSymbol); + } + + return typeNameSymbol; + }; + + PullTypeResolver.prototype.isLeftSideOfQualifiedName = function (ast) { + return ast && ast.parent && ast.parent.kind() === 121 /* QualifiedName */ && ast.parent.left === ast; + }; + + PullTypeResolver.prototype.resolveGenericTypeReference = function (genericTypeAST, context) { + var genericTypeSymbol = this.resolveAST(genericTypeAST.name, false, context).type; + + if (genericTypeSymbol.isError()) { + return genericTypeSymbol; + } + + if (!genericTypeSymbol.inResolution && !genericTypeSymbol.isResolved) { + this.resolveDeclaredSymbol(genericTypeSymbol, context); + } + + if (genericTypeSymbol.isAlias()) { + genericTypeSymbol = genericTypeSymbol.getExportAssignedTypeSymbol(); + } + + var typeArgs = []; + + if (genericTypeAST.typeArgumentList && genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < genericTypeAST.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(genericTypeAST.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + + if (typeArgs[i].isError()) { + typeArgs[i] = this.semanticInfoChain.anyTypeSymbol; + } + } + } + + var typeParameters = genericTypeSymbol.getTypeParameters(); + + if (typeArgs.length && typeArgs.length != typeParameters.length) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Generic_type_0_requires_1_type_argument_s, [genericTypeSymbol.toString(), genericTypeSymbol.getTypeParameters().length])); + return this.getNewErrorTypeSymbol(); + } + + if (!genericTypeSymbol.isResolved) { + var typeDecls = genericTypeSymbol.getDeclarations(); + var childDecls = null; + + for (var i = 0; i < typeDecls.length; i++) { + childDecls = typeDecls[i].getChildDecls(); + + for (var j = 0; j < childDecls.length; j++) { + childDecls[j].ensureSymbolIsBound(); + } + } + } + + var specializedSymbol = this.createInstantiatedType(genericTypeSymbol, typeArgs); + + var typeConstraint = null; + var upperBound = null; + + typeParameters = specializedSymbol.getTypeParameters(); + + var typeConstraintSubstitutionMap = []; + var typeArg = null; + + var instantiatedSubstitutionMap = specializedSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < typeParameters.length; i++) { + typeConstraintSubstitutionMap[typeParameters[i].pullSymbolID] = typeParameters[i]; + } + + for (var id in instantiatedSubstitutionMap) { + typeConstraintSubstitutionMap[id] = instantiatedSubstitutionMap[id]; + } + + for (var iArg = 0; (iArg < typeArgs.length) && (iArg < typeParameters.length); iArg++) { + typeArg = typeArgs[iArg]; + typeConstraint = typeParameters[iArg].getConstraint(); + + typeConstraintSubstitutionMap[typeParameters[iArg].pullSymbolID] = typeArg; + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var j = 0; j < typeParameters.length && j < typeArgs.length; j++) { + if (typeParameters[j] == typeConstraint) { + typeConstraint = typeArgs[j]; + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeConstraintSubstitutionMap); + } + + if (typeArg.isTypeParameter()) { + upperBound = typeArg.getConstraint(); + + if (upperBound) { + typeArg = upperBound; + } + } + + if (typeArg.inResolution || (typeArg.isTypeReference() && typeArg.referencedTypeSymbol.inResolution)) { + return specializedSymbol; + } + if (!this.sourceIsAssignableToTarget(typeArg, typeConstraint, genericTypeAST, context)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(genericTypeAST); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(genericTypeAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [typeArg.toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[iArg].toString(enclosingSymbol, true)])); + } + } + } + + return specializedSymbol; + }; + + PullTypeResolver.prototype.resolveQualifiedName = function (dottedNameAST, context) { + if (this.inTypeQuery(dottedNameAST)) { + return this.resolveDottedNameExpression(dottedNameAST, dottedNameAST.left, dottedNameAST.right, context).type; + } + + var symbol = this.getSymbolForAST(dottedNameAST, context); + if (!symbol || this.canTypeCheckAST(dottedNameAST, context)) { + var canTypeCheck = this.canTypeCheckAST(dottedNameAST, context); + if (canTypeCheck) { + this.setTypeChecked(dottedNameAST, context); + } + + symbol = this.computeQualifiedName(dottedNameAST, context); + this.setSymbolForAST(dottedNameAST, symbol, context); + } + + this.resolveDeclaredSymbol(symbol, context); + + return symbol; + }; + + PullTypeResolver.prototype.computeQualifiedName = function (dottedNameAST, context) { + var rhsName = dottedNameAST.right.valueText(); + if (rhsName.length === 0) { + return this.semanticInfoChain.anyTypeSymbol; + } + + var enclosingDecl = this.getEnclosingDeclForAST(dottedNameAST); + var lhs = this.resolveAST(dottedNameAST.left, false, context); + + var lhsType = lhs.isAlias() ? lhs.getExportAssignedContainerSymbol() : lhs.type; + + if (this.inClassExtendsHeritageClause(dottedNameAST) && !this.inTypeArgumentList(dottedNameAST)) { + if (lhs.isAlias()) { + lhs.setIsUsedAsValue(true); + } + } + + if (!lhsType) { + return this.getNewErrorTypeSymbol(); + } + + if (this.isAnyOrEquivalent(lhsType)) { + return lhsType; + } + + var onLeftOfDot = this.isLeftSideOfQualifiedName(dottedNameAST); + var isNameOfModule = dottedNameAST.parent.kind() === 130 /* ModuleDeclaration */ && dottedNameAST.parent.name === dottedNameAST; + var memberKind = (onLeftOfDot || isNameOfModule) ? 164 /* SomeContainer */ : 58728539 /* SomeType */; + + var childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, lhsType); + + if (!childTypeSymbol && lhsType.isContainer()) { + var exportedContainer = lhsType.getExportAssignedContainerSymbol(); + + if (exportedContainer) { + childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, exportedContainer); + } + } + + if (!childTypeSymbol && enclosingDecl) { + var parentDecl = enclosingDecl; + + while (parentDecl) { + if (parentDecl.kind & 164 /* SomeContainer */) { + break; + } + + parentDecl = parentDecl.getParentDecl(); + } + + if (parentDecl) { + var enclosingSymbolType = parentDecl.getSymbol().type; + + if (enclosingSymbolType === lhsType) { + childTypeSymbol = this.getMemberSymbol(rhsName, memberKind, lhsType); + } + } + } + + if (!childTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(dottedNameAST.right, TypeScript.DiagnosticCode.The_property_0_does_not_exist_on_value_of_type_1, [dottedNameAST.right.text(), lhsType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + return this.getNewErrorTypeSymbol(rhsName); + } + + return childTypeSymbol; + }; + + PullTypeResolver.prototype.shouldContextuallyTypeAnyFunctionExpression = function (functionExpressionAST, typeParameters, parameters, returnTypeAnnotation, context) { + if (typeParameters && typeParameters.typeParameters.nonSeparatorCount() > 0) { + return false; + } + + if (returnTypeAnnotation) { + return false; + } + + if (parameters) { + for (var i = 0, n = parameters.length; i < n; i++) { + if (parameters.typeAt(i)) { + return false; + } + } + } + + var contextualFunctionTypeSymbol = context.getContextualType(); + + if (contextualFunctionTypeSymbol) { + this.resolveDeclaredSymbol(contextualFunctionTypeSymbol, context); + var callSignatures = contextualFunctionTypeSymbol.getCallSignatures(); + var exactlyOneCallSignature = callSignatures && callSignatures.length == 1; + if (!exactlyOneCallSignature) { + return false; + } + + var callSignatureIsGeneric = callSignatures[0].typeParameters && callSignatures[0].typeParameters.length > 0; + return !callSignatureIsGeneric; + } + + return false; + }; + + PullTypeResolver.prototype.resolveAnyFunctionExpression = function (funcDeclAST, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, isContextuallyTyped, context) { + var funcDeclSymbol = null; + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + TypeScript.Debug.assert(functionDecl); + + if (functionDecl && functionDecl.hasSymbol()) { + funcDeclSymbol = functionDecl.getSymbol(); + if (funcDeclSymbol.isResolved || funcDeclSymbol.inResolution) { + return funcDeclSymbol; + } + } + + funcDeclSymbol = functionDecl.getSymbol(); + TypeScript.Debug.assert(funcDeclSymbol); + + var funcDeclType = funcDeclSymbol.type; + var signature = funcDeclType.getCallSignatures()[0]; + funcDeclSymbol.startResolving(); + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + var assigningFunctionSignature = null; + if (isContextuallyTyped && this.shouldContextuallyTypeAnyFunctionExpression(funcDeclAST, typeParameters, parameters, returnTypeAnnotation, context)) { + assigningFunctionSignature = context.getContextualType().getCallSignatures()[0]; + } + + if (parameters) { + var contextParams = []; + + if (assigningFunctionSignature) { + contextParams = assigningFunctionSignature.parameters; + } + + var contextualParametersCount = contextParams.length; + for (var i = 0, n = parameters.length; i < n; i++) { + var actualParameterIsVarArgParameter = (i === (n - 1)) && parameters.lastParameterIsRest(); + var correspondingContextualParameter = null; + var contextualParameterType = null; + + if (i < contextualParametersCount) { + correspondingContextualParameter = contextParams[i]; + } else if (contextualParametersCount && contextParams[contextualParametersCount - 1].isVarArg) { + correspondingContextualParameter = contextParams[contextualParametersCount - 1]; + } + + if (correspondingContextualParameter) { + if (correspondingContextualParameter.isVarArg === actualParameterIsVarArgParameter) { + contextualParameterType = correspondingContextualParameter.type; + } else if (correspondingContextualParameter.isVarArg) { + contextualParameterType = correspondingContextualParameter.type.getElementType(); + } + } + + this.resolveFunctionExpressionParameter(parameters.astAt(i), parameters.identifierAt(i), parameters.typeAt(i), parameters.initializerAt(i), contextualParameterType, functionDecl, context); + } + } + + if (returnTypeAnnotation) { + signature.returnType = this.resolveTypeReference(returnTypeAnnotation, context); + } else { + if (assigningFunctionSignature) { + var returnType = assigningFunctionSignature.returnType; + + if (returnType) { + context.pushContextualType(returnType, context.inProvisionalResolution(), null); + + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, true, functionDecl, context); + context.popContextualType(); + } else { + signature.returnType = this.semanticInfoChain.anyTypeSymbol; + + if (this.compilationSettings.noImplicitAny()) { + var functionExpressionName = functionDecl.getFunctionExpressionName(); + + if (functionExpressionName != "") { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode._0_which_lacks_return_type_annotation_implicitly_has_an_any_return_type, [functionExpressionName])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_any_return_type)); + } + } + } + } else { + this.resolveFunctionBodyReturnTypes(funcDeclAST, block, bodyExpression, signature, false, functionDecl, context); + } + } + + context.setTypeInContext(funcDeclSymbol, funcDeclType); + funcDeclSymbol.setResolved(); + + if (this.canTypeCheckAST(funcDeclAST, context)) { + this.typeCheckAnyFunctionExpression(funcDeclAST, typeParameters, returnTypeAnnotation, block, bodyExpression, context); + } + + return funcDeclSymbol; + }; + + PullTypeResolver.prototype.typeCheckSimpleArrowFunctionExpression = function (arrowFunction, context) { + return this.typeCheckAnyFunctionExpression(arrowFunction, null, null, arrowFunction.block, arrowFunction.expression, context); + }; + + PullTypeResolver.prototype.typeCheckParenthesizedArrowFunctionExpression = function (arrowFunction, context) { + return this.typeCheckAnyFunctionExpression(arrowFunction, arrowFunction.callSignature.typeParameterList, TypeScript.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, context); + }; + + PullTypeResolver.prototype.typeCheckAnyFunctionExpression = function (funcDeclAST, typeParameters, returnTypeAnnotation, block, bodyExpression, context) { + var _this = this; + this.setTypeChecked(funcDeclAST, context); + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + + var funcDeclSymbol = functionDecl.getSymbol(); + var funcDeclType = funcDeclSymbol.type; + var signature = funcDeclType.getCallSignatures()[0]; + var returnTypeSymbol = signature.returnType; + + if (typeParameters) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + this.resolveTypeParameterDeclaration(typeParameters.typeParameters.nonSeparatorAt(i), context); + } + } + + context.pushContextualType(null, context.inProvisionalResolution(), null); + if (block) { + this.resolveAST(block, false, context); + } else { + var bodyExpressionType = this.resolveReturnExpression(bodyExpression, functionDecl, context); + this.typeCheckReturnExpression(bodyExpression, bodyExpressionType, functionDecl, context); + } + context.popContextualType(); + + var hasReturn = (functionDecl.flags & (2048 /* Signature */ | 4194304 /* HasReturnStatement */)) != 0; + + if (block && returnTypeAnnotation != null && !hasReturn) { + var isVoidOrAny = this.isAnyOrEquivalent(returnTypeSymbol) || returnTypeSymbol === this.semanticInfoChain.voidTypeSymbol; + + if (!isVoidOrAny && !(block.statements.childCount() > 0 && block.statements.childAt(0).kind() === 157 /* ThrowStatement */)) { + var funcName = functionDecl.getDisplayName(); + funcName = funcName ? "'" + funcName + "'" : "expression"; + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, TypeScript.DiagnosticCode.Function_0_declared_a_non_void_return_type_but_has_no_return_expression, [funcName])); + } + } + + this.validateVariableDeclarationGroups(functionDecl, context); + + this.typeCheckCallBacks.push(function (context) { + _this.typeCheckFunctionOverloads(funcDeclAST, context); + }); + }; + + PullTypeResolver.prototype.resolveThisExpression = function (thisExpression, context) { + var enclosingDecl = this.getEnclosingDeclForAST(thisExpression); + var thisTypeSymbol = this.getContextualClassSymbolForEnclosingDecl(thisExpression, enclosingDecl) || this.semanticInfoChain.anyTypeSymbol; + + if (this.canTypeCheckAST(thisExpression, context)) { + this.typeCheckThisExpression(thisExpression, context, enclosingDecl); + } + + return thisTypeSymbol; + }; + + PullTypeResolver.prototype.inTypeArgumentList = function (ast) { + var previous = null; + var current = ast; + + while (current) { + switch (current.kind()) { + case 126 /* GenericType */: + var genericType = current; + if (genericType.typeArgumentList === previous) { + return true; + } + break; + + case 226 /* ArgumentList */: + var argumentList = current; + return argumentList.typeArgumentList === previous; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inClassExtendsHeritageClause = function (ast) { + while (ast) { + switch (ast.kind()) { + case 230 /* ExtendsHeritageClause */: + var heritageClause = ast; + + return heritageClause.parent.parent.kind() === 131 /* ClassDeclaration */; + + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inTypeQuery = function (ast) { + while (ast) { + switch (ast.kind()) { + case 127 /* TypeQuery */: + return true; + case 129 /* FunctionDeclaration */: + case 213 /* InvocationExpression */: + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inArgumentListOfSuperInvocation = function (ast) { + var previous = null; + var current = ast; + while (current) { + switch (current.kind()) { + case 213 /* InvocationExpression */: + var invocationExpression = current; + if (previous === invocationExpression.argumentList && invocationExpression.expression.kind() === 50 /* SuperKeyword */) { + return true; + } + break; + + case 137 /* ConstructorDeclaration */: + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.inConstructorParameterList = function (ast) { + var previous = null; + var current = ast; + while (current) { + switch (current.kind()) { + case 137 /* ConstructorDeclaration */: + var constructorDecl = current; + return previous === constructorDecl.parameterList; + + case 131 /* ClassDeclaration */: + case 130 /* ModuleDeclaration */: + return false; + } + + previous = current; + current = current.parent; + } + + return false; + }; + + PullTypeResolver.prototype.isFunctionOrNonArrowFunctionExpression = function (decl) { + if (decl.kind === 16384 /* Function */) { + return true; + } else if (decl.kind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(decl.flags, 8192 /* ArrowFunction */)) { + return true; + } + + return false; + }; + + PullTypeResolver.prototype.typeCheckThisExpression = function (thisExpression, context, enclosingDecl) { + this.checkForThisCaptureInArrowFunction(thisExpression); + + if (this.inConstructorParameterList(thisExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_constructor_arguments)); + return; + } + + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + return; + } else if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) { + if (currentDecl.getParentDecl() === null) { + return; + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_within_module_bodies)); + return; + } + } else if (currentDecl.kind === 32768 /* ConstructorMethod */) { + if (this.inArgumentListOfSuperInvocation(thisExpression) && this.superCallMustBeFirstStatementInConstructor(currentDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_current_location)); + } + + return; + } else if (currentDecl.kind === 8 /* Class */) { + if (this.inStaticMemberVariableDeclaration(thisExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(thisExpression, TypeScript.DiagnosticCode.this_cannot_be_referenced_in_static_initializers_in_a_class_body)); + } + + return; + } + } + }; + + PullTypeResolver.prototype.getContextualClassSymbolForEnclosingDecl = function (ast, enclosingDecl) { + var declPath = enclosingDecl.getParentPath(); + + if (declPath.length) { + var isStaticContext = false; + + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + var declFlags = decl.flags; + + if (declFlags & 16 /* Static */) { + isStaticContext = true; + } else if (declKind === 131072 /* FunctionExpression */ && !TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) { + return null; + } else if (declKind === 16384 /* Function */) { + return null; + } else if (declKind === 8 /* Class */) { + if (this.inStaticMemberVariableDeclaration(ast)) { + return this.getNewErrorTypeSymbol(); + } else { + var classSymbol = decl.getSymbol(); + if (isStaticContext) { + var constructorSymbol = classSymbol.getConstructorMethod(); + return constructorSymbol.type; + } else { + return classSymbol; + } + } + } + } + } + + return null; + }; + + PullTypeResolver.prototype.inStaticMemberVariableDeclaration = function (ast) { + while (ast) { + if (ast.kind() === 136 /* MemberVariableDeclaration */ && TypeScript.hasModifier(ast.modifiers, 16 /* Static */)) { + return true; + } + + ast = ast.parent; + } + + return false; + }; + + PullTypeResolver.prototype.resolveSuperExpression = function (ast, context) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + var superType = this.semanticInfoChain.anyTypeSymbol; + + var classSymbol = this.getContextualClassSymbolForEnclosingDecl(ast, enclosingDecl); + + if (classSymbol) { + this.resolveDeclaredSymbol(classSymbol, context); + + var parents = classSymbol.getExtendedTypes(); + + if (parents.length) { + superType = parents[0]; + } + } + + if (this.canTypeCheckAST(ast, context)) { + this.typeCheckSuperExpression(ast, context, enclosingDecl); + } + + return superType; + }; + + PullTypeResolver.prototype.typeCheckSuperExpression = function (ast, context, enclosingDecl) { + this.setTypeChecked(ast, context); + + this.checkForThisCaptureInArrowFunction(ast); + + var isSuperCall = ast.parent.kind() === 213 /* InvocationExpression */; + var isSuperPropertyAccess = ast.parent.kind() === 212 /* MemberAccessExpression */; + TypeScript.Debug.assert(isSuperCall || isSuperPropertyAccess); + + if (isSuperPropertyAccess) { + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + break; + } else if (currentDecl.kind === 8 /* Class */) { + if (!this.enclosingClassIsDerived(currentDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes)); + return; + } else if (this.inConstructorParameterList(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments)); + return; + } else if (this.inStaticMemberVariableDeclaration(ast)) { + break; + } + + return; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class)); + return; + } else { + for (var currentDecl = enclosingDecl; currentDecl !== null; currentDecl = currentDecl.getParentDecl()) { + if (this.isFunctionOrNonArrowFunctionExpression(currentDecl)) { + break; + } else if (currentDecl.kind === 32768 /* ConstructorMethod */) { + var classDecl = currentDecl.getParentDecl(); + + if (!this.enclosingClassIsDerived(classDecl)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_non_derived_classes)); + return; + } else if (this.inConstructorParameterList(ast)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.super_cannot_be_referenced_in_constructor_arguments)); + return; + } + + return; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Super_calls_are_not_permitted_outside_constructors_or_in_local_functions_inside_constructors)); + } + }; + + PullTypeResolver.prototype.resolveSimplePropertyAssignment = function (propertyAssignment, isContextuallyTyped, context) { + return this.resolveAST(propertyAssignment.expression, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.resolveFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) { + return this.resolveAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(funcProp.callSignature.parameterList), TypeScript.getType(funcProp), funcProp.block, null, isContextuallyTyped, context); + }; + + PullTypeResolver.prototype.typeCheckFunctionPropertyAssignment = function (funcProp, isContextuallyTyped, context) { + this.typeCheckAnyFunctionExpression(funcProp, funcProp.callSignature.typeParameterList, TypeScript.getType(funcProp), funcProp.block, null, context); + }; + + PullTypeResolver.prototype.resolveObjectLiteralExpression = function (expressionAST, isContextuallyTyped, context, additionalResults) { + var symbol = this.getSymbolForAST(expressionAST, context); + + if (!symbol || additionalResults || this.canTypeCheckAST(expressionAST, context)) { + if (this.canTypeCheckAST(expressionAST, context)) { + this.setTypeChecked(expressionAST, context); + } + symbol = this.computeObjectLiteralExpression(expressionAST, isContextuallyTyped, context, additionalResults); + this.setSymbolForAST(expressionAST, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.bindObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralMembers, isUsingExistingSymbol, pullTypeContext) { + var boundMemberSymbols = []; + var memberSymbol; + for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) { + var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i); + + var id = this.getPropertyAssignmentName(propertyAssignment); + var assignmentText = getPropertyAssignmentNameTextFromIdentifier(id); + + var isAccessor = propertyAssignment.kind() === 139 /* GetAccessor */ || propertyAssignment.kind() === 140 /* SetAccessor */; + var decl = this.semanticInfoChain.getDeclForAST(propertyAssignment); + TypeScript.Debug.assert(decl); + + if (propertyAssignment.kind() == 240 /* SimplePropertyAssignment */) { + if (!isUsingExistingSymbol) { + memberSymbol = new TypeScript.PullSymbol(assignmentText.memberName, 4096 /* Property */); + memberSymbol.addDeclaration(decl); + decl.setSymbol(memberSymbol); + } else { + memberSymbol = decl.getSymbol(); + } + } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) { + memberSymbol = decl.getSymbol(); + } else { + TypeScript.Debug.assert(isAccessor); + memberSymbol = decl.getSymbol(); + } + + if (!isUsingExistingSymbol && !isAccessor) { + if (objectLiteralTypeSymbol.findMember(memberSymbol.name, true)) { + pullTypeContext.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(propertyAssignment, TypeScript.DiagnosticCode.Duplicate_identifier_0, [assignmentText.actualText])); + } + + objectLiteralTypeSymbol.addMember(memberSymbol); + } + + boundMemberSymbols.push(memberSymbol); + } + + return boundMemberSymbols; + }; + + PullTypeResolver.prototype.resolveObjectLiteralMembers = function (objectLiteralDeclaration, objectLiteralTypeSymbol, objectLiteralContextualType, objectLiteralMembers, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, pullTypeContext, additionalResults) { + for (var i = 0, len = objectLiteralMembers.nonSeparatorCount(); i < len; i++) { + var propertyAssignment = objectLiteralMembers.nonSeparatorAt(i); + + var acceptedContextualType = false; + var assigningSymbol = null; + + var id = this.getPropertyAssignmentName(propertyAssignment); + var memberSymbol = boundMemberSymbols[i]; + + if (objectLiteralContextualType) { + assigningSymbol = this.getMemberSymbol(memberSymbol.name, 68147712 /* SomeValue */, objectLiteralContextualType); + + if (!assigningSymbol) { + if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) { + assigningSymbol = numericIndexerSignature; + } else if (stringIndexerSignature) { + assigningSymbol = stringIndexerSignature; + } + } + + if (assigningSymbol) { + this.resolveDeclaredSymbol(assigningSymbol, pullTypeContext); + + var contextualMemberType = assigningSymbol.kind === 4194304 /* IndexSignature */ ? assigningSymbol.returnType : assigningSymbol.type; + pullTypeContext.pushContextualType(contextualMemberType, pullTypeContext.inProvisionalResolution(), null); + + acceptedContextualType = true; + + if (additionalResults) { + additionalResults.membersContextTypeSymbols[i] = contextualMemberType; + } + } + } + + var propertySymbol = this.resolveAST(propertyAssignment, contextualMemberType != null, pullTypeContext); + var memberExpr = this.widenType(propertySymbol.type, propertyAssignment, pullTypeContext); + + if (memberExpr.type) { + if (memberExpr.type.isGeneric()) { + objectLiteralTypeSymbol.setHasGenericMember(); + } + + if (stringIndexerSignature) { + allMemberTypes.push(memberExpr.type); + } + if (numericIndexerSignature && TypeScript.PullHelpers.isNameNumeric(memberSymbol.name)) { + allNumericMemberTypes.push(memberExpr.type); + } + } + + if (acceptedContextualType) { + pullTypeContext.popContextualType(); + } + + var isAccessor = propertyAssignment.kind() === 140 /* SetAccessor */ || propertyAssignment.kind() === 139 /* GetAccessor */; + if (!isUsingExistingSymbol) { + if (isAccessor) { + this.setSymbolForAST(id, memberExpr, pullTypeContext); + } else { + pullTypeContext.setTypeInContext(memberSymbol, memberExpr.type); + memberSymbol.setResolved(); + + this.setSymbolForAST(id, memberSymbol, pullTypeContext); + } + } + } + }; + + PullTypeResolver.prototype.computeObjectLiteralExpression = function (objectLitAST, isContextuallyTyped, context, additionalResults) { + var objectLitDecl = this.semanticInfoChain.getDeclForAST(objectLitAST); + TypeScript.Debug.assert(objectLitDecl); + + var typeSymbol = this.getSymbolForAST(objectLitAST, context); + var isUsingExistingSymbol = !!typeSymbol; + + if (!typeSymbol) { + typeSymbol = new TypeScript.PullTypeSymbol("", 16 /* Interface */); + typeSymbol.addDeclaration(objectLitDecl); + this.setSymbolForAST(objectLitAST, typeSymbol, context); + objectLitDecl.setSymbol(typeSymbol); + } + + var propertyAssignments = objectLitAST.propertyAssignments; + var contextualType = null; + + if (isContextuallyTyped) { + contextualType = context.getContextualType(); + this.resolveDeclaredSymbol(contextualType, context); + } + + var stringIndexerSignature = null; + var numericIndexerSignature = null; + var allMemberTypes = null; + var allNumericMemberTypes = null; + + if (contextualType) { + var indexSignatures = this.getBothKindsOfIndexSignatures(contextualType, context); + + stringIndexerSignature = indexSignatures.stringSignature; + numericIndexerSignature = indexSignatures.numericSignature; + + if (stringIndexerSignature) { + allMemberTypes = [stringIndexerSignature.returnType]; + } + + if (numericIndexerSignature) { + allNumericMemberTypes = [numericIndexerSignature.returnType]; + } + } + + if (propertyAssignments) { + if (additionalResults) { + additionalResults.membersContextTypeSymbols = []; + } + + var boundMemberSymbols = this.bindObjectLiteralMembers(objectLitDecl, typeSymbol, propertyAssignments, isUsingExistingSymbol, context); + + this.resolveObjectLiteralMembers(objectLitDecl, typeSymbol, contextualType, propertyAssignments, stringIndexerSignature, numericIndexerSignature, allMemberTypes, allNumericMemberTypes, boundMemberSymbols, isUsingExistingSymbol, context, additionalResults); + + if (!isUsingExistingSymbol) { + this.stampObjectLiteralWithIndexSignature(typeSymbol, allMemberTypes, stringIndexerSignature, context); + this.stampObjectLiteralWithIndexSignature(typeSymbol, allNumericMemberTypes, numericIndexerSignature, context); + } + } + + typeSymbol.setResolved(); + return typeSymbol; + }; + + PullTypeResolver.prototype.getPropertyAssignmentName = function (propertyAssignment) { + if (propertyAssignment.kind() === 240 /* SimplePropertyAssignment */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 241 /* FunctionPropertyAssignment */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 139 /* GetAccessor */) { + return propertyAssignment.propertyName; + } else if (propertyAssignment.kind() === 140 /* SetAccessor */) { + return propertyAssignment.propertyName; + } else { + TypeScript.Debug.assert(false); + } + }; + + PullTypeResolver.prototype.stampObjectLiteralWithIndexSignature = function (objectLiteralSymbol, indexerTypeCandidates, contextualIndexSignature, context) { + if (contextualIndexSignature) { + var typeCollection = { + getLength: function () { + return indexerTypeCandidates.length; + }, + getTypeAtIndex: function (index) { + return indexerTypeCandidates[index]; + } + }; + var decl = objectLiteralSymbol.getDeclarations()[0]; + var indexerReturnType = this.widenType(this.findBestCommonType(typeCollection, context)); + if (indexerReturnType == contextualIndexSignature.returnType) { + objectLiteralSymbol.addIndexSignature(contextualIndexSignature); + } else { + this.semanticInfoChain.addSyntheticIndexSignature(decl, objectLiteralSymbol, this.getASTForDecl(decl), contextualIndexSignature.parameters[0].name, contextualIndexSignature.parameters[0].type, indexerReturnType); + } + } + }; + + PullTypeResolver.prototype.resolveArrayLiteralExpression = function (arrayLit, isContextuallyTyped, context) { + var symbol = this.getSymbolForAST(arrayLit, context); + if (!symbol || this.canTypeCheckAST(arrayLit, context)) { + if (this.canTypeCheckAST(arrayLit, context)) { + this.setTypeChecked(arrayLit, context); + } + symbol = this.computeArrayLiteralExpressionSymbol(arrayLit, isContextuallyTyped, context); + this.setSymbolForAST(arrayLit, symbol, context); + } + + return symbol; + }; + + PullTypeResolver.prototype.computeArrayLiteralExpressionSymbol = function (arrayLit, isContextuallyTyped, context) { + var elements = arrayLit.expressions; + var elementType = null; + var elementTypes = []; + var comparisonInfo = new TypeComparisonInfo(); + var contextualElementType = null; + comparisonInfo.onlyCaptureFirstError = true; + + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + + this.resolveDeclaredSymbol(contextualType, context); + + if (contextualType) { + var indexSignatures = this.getBothKindsOfIndexSignatures(contextualType, context); + if (indexSignatures.numericSignature) { + contextualElementType = indexSignatures.numericSignature.returnType; + } + } + } + + if (elements) { + if (contextualElementType) { + context.pushContextualType(contextualElementType, context.inProvisionalResolution(), null); + } + + for (var i = 0, n = elements.nonSeparatorCount(); i < n; i++) { + elementTypes.push(this.resolveAST(elements.nonSeparatorAt(i), contextualElementType !== null, context).type); + } + + if (contextualElementType) { + context.popContextualType(); + } + } + + if (elementTypes.length) { + elementType = elementTypes[0]; + } + var collection; + if (contextualElementType) { + if (!elementType) { + elementType = contextualElementType; + } + + collection = { + getLength: function () { + return elements.nonSeparatorCount() + 1; + }, + getTypeAtIndex: function (index) { + return index === 0 ? contextualElementType : elementTypes[index - 1]; + } + }; + } else { + collection = { + getLength: function () { + return elements.nonSeparatorCount(); + }, + getTypeAtIndex: function (index) { + return elementTypes[index]; + } + }; + } + + elementType = elementType ? this.findBestCommonType(collection, context, comparisonInfo) : elementType; + + if (!elementType) { + elementType = this.semanticInfoChain.undefinedTypeSymbol; + } + + var arraySymbol = elementType.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + + elementType.setArrayType(arraySymbol); + } + + return arraySymbol; + }; + + PullTypeResolver.prototype.resolveElementAccessExpression = function (callEx, context) { + var symbolAndDiagnostic = this.computeElementAccessExpressionSymbolAndDiagnostic(callEx, context); + + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckElementAccessExpression(callEx, context, symbolAndDiagnostic); + } + + return symbolAndDiagnostic.symbol; + }; + + PullTypeResolver.prototype.typeCheckElementAccessExpression = function (callEx, context, symbolAndDiagnostic) { + this.setTypeChecked(callEx, context); + context.postDiagnostic(symbolAndDiagnostic.diagnostic); + }; + + PullTypeResolver.prototype.computeElementAccessExpressionSymbolAndDiagnostic = function (callEx, context) { + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var indexType = this.resolveAST(callEx.argumentExpression, false, context).type; + + var targetTypeSymbol = targetSymbol.type; + + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + return { symbol: targetTypeSymbol }; + } + + var elementType = targetTypeSymbol.getElementType(); + + var isNumberIndex = indexType === this.semanticInfoChain.numberTypeSymbol || TypeScript.PullHelpers.symbolIsEnum(indexType); + + if (elementType && isNumberIndex) { + return { symbol: elementType }; + } + + if (callEx.argumentExpression.kind() === 14 /* StringLiteral */ || callEx.argumentExpression.kind() === 13 /* NumericLiteral */) { + var memberName = callEx.argumentExpression.kind() === 14 /* StringLiteral */ ? TypeScript.stripStartAndEndQuotes(callEx.argumentExpression.text()) : callEx.argumentExpression.valueText(); + + var member = this.getMemberSymbol(memberName, 68147712 /* SomeValue */, targetTypeSymbol); + + if (member) { + this.resolveDeclaredSymbol(member, context); + + return { symbol: member.type }; + } + } + + if (targetTypeSymbol == this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + targetTypeSymbol = this.cachedStringInterfaceType(); + } + + var signatures = this.getBothKindsOfIndexSignatures(targetTypeSymbol, context); + + var stringSignature = signatures.stringSignature; + var numberSignature = signatures.numericSignature; + + if (numberSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol)) { + return { symbol: numberSignature.returnType || this.semanticInfoChain.anyTypeSymbol }; + } else if (stringSignature && (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol)) { + return { symbol: stringSignature.returnType || this.semanticInfoChain.anyTypeSymbol }; + } else if (isNumberIndex || indexType === this.semanticInfoChain.anyTypeSymbol || indexType === this.semanticInfoChain.stringTypeSymbol) { + return { symbol: this.semanticInfoChain.anyTypeSymbol }; + } else { + return { + symbol: this.getNewErrorTypeSymbol(), + diagnostic: this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Value_of_type_0_is_not_indexable_by_type_1, [targetTypeSymbol.toString(), indexType.toString()]) + }; + } + }; + + PullTypeResolver.prototype.getBothKindsOfIndexSignatures = function (enclosingType, context) { + var signatures = enclosingType.getIndexSignatures(); + + var stringSignature = null; + var numberSignature = null; + var signature = null; + var paramSymbols; + var paramType; + + for (var i = 0; i < signatures.length; i++) { + if (stringSignature && numberSignature) { + break; + } + + signature = signatures[i]; + if (!signature.isResolved) { + this.resolveDeclaredSymbol(signature, context); + } + + paramSymbols = signature.parameters; + + if (paramSymbols.length) { + paramType = paramSymbols[0].type; + + if (!stringSignature && paramType === this.semanticInfoChain.stringTypeSymbol) { + stringSignature = signature; + continue; + } else if (!numberSignature && paramType === this.semanticInfoChain.numberTypeSymbol) { + numberSignature = signature; + continue; + } + } + } + + return { + numericSignature: numberSignature, + stringSignature: stringSignature + }; + }; + + PullTypeResolver.prototype.resolveBinaryAdditionOperation = function (binaryExpression, context) { + var lhsExpression = this.resolveAST(binaryExpression.left, false, context); + var lhsType = lhsExpression.type; + var rhsType = this.resolveAST(binaryExpression.right, false, context).type; + + if (TypeScript.PullHelpers.symbolIsEnum(lhsType)) { + lhsType = this.semanticInfoChain.numberTypeSymbol; + } else if (lhsType === this.semanticInfoChain.nullTypeSymbol || lhsType === this.semanticInfoChain.undefinedTypeSymbol) { + if (rhsType != this.semanticInfoChain.nullTypeSymbol && rhsType != this.semanticInfoChain.undefinedTypeSymbol) { + lhsType = rhsType; + } else { + lhsType = this.semanticInfoChain.anyTypeSymbol; + } + } + + if (TypeScript.PullHelpers.symbolIsEnum(rhsType)) { + rhsType = this.semanticInfoChain.numberTypeSymbol; + } else if (rhsType === this.semanticInfoChain.nullTypeSymbol || rhsType === this.semanticInfoChain.undefinedTypeSymbol) { + if (lhsType != this.semanticInfoChain.nullTypeSymbol && lhsType != this.semanticInfoChain.undefinedTypeSymbol) { + rhsType = lhsType; + } else { + rhsType = this.semanticInfoChain.anyTypeSymbol; + } + } + + var exprType = null; + + if (lhsType === this.semanticInfoChain.stringTypeSymbol || rhsType === this.semanticInfoChain.stringTypeSymbol) { + exprType = this.semanticInfoChain.stringTypeSymbol; + } else if (this.isAnyOrEquivalent(lhsType) || this.isAnyOrEquivalent(rhsType)) { + exprType = this.semanticInfoChain.anyTypeSymbol; + } else if (rhsType === this.semanticInfoChain.numberTypeSymbol && lhsType === this.semanticInfoChain.numberTypeSymbol) { + exprType = this.semanticInfoChain.numberTypeSymbol; + } + + if (this.canTypeCheckAST(binaryExpression, context)) { + this.setTypeChecked(binaryExpression, context); + + if (exprType) { + if (binaryExpression.kind() === 175 /* AddAssignmentExpression */) { + if (!this.isReference(binaryExpression.left, lhsExpression)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } + + this.checkAssignability(binaryExpression.left, exprType, lhsType, context); + } + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_expression_types_not_known_to_support_the_addition_operator)); + } + } + + if (!exprType) { + exprType = this.semanticInfoChain.anyTypeSymbol; + } + + return exprType; + }; + + PullTypeResolver.prototype.bestCommonTypeOfTwoTypes = function (type1, type2, context) { + return this.findBestCommonType({ + getLength: function () { + return 2; + }, + getTypeAtIndex: function (index) { + switch (index) { + case 0: + return type1; + case 1: + return type2; + } + } + }, context); + }; + + PullTypeResolver.prototype.bestCommonTypeOfThreeTypes = function (type1, type2, type3, context) { + return this.findBestCommonType({ + getLength: function () { + return 3; + }, + getTypeAtIndex: function (index) { + switch (index) { + case 0: + return type1; + case 1: + return type2; + case 2: + return type3; + } + } + }, context); + }; + + PullTypeResolver.prototype.resolveLogicalOrExpression = function (binex, isContextuallyTyped, context) { + if (this.canTypeCheckAST(binex, context)) { + this.setTypeChecked(binex, context); + } + + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + var leftType = this.resolveAST(binex.left, isContextuallyTyped, context).type; + var rightType = this.resolveAST(binex.right, isContextuallyTyped, context).type; + + return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context); + } else { + var leftType = this.resolveAST(binex.left, false, context).type; + + context.pushContextualType(leftType, context.inProvisionalResolution(), null); + var rightType = this.resolveAST(binex.right, true, context).type; + context.popContextualType(); + + return this.bestCommonTypeOfTwoTypes(leftType, rightType, context); + } + }; + + PullTypeResolver.prototype.resolveLogicalAndExpression = function (binex, context) { + if (this.canTypeCheckAST(binex, context)) { + this.setTypeChecked(binex, context); + + this.resolveAST(binex.left, false, context); + } + + return this.resolveAST(binex.right, false, context).type; + }; + + PullTypeResolver.prototype.computeTypeOfConditionalExpression = function (leftType, rightType, isContextuallyTyped, context) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + return this.bestCommonTypeOfThreeTypes(contextualType, leftType, rightType, context); + } else { + return this.bestCommonTypeOfTwoTypes(leftType, rightType, context); + } + }; + + PullTypeResolver.prototype.resolveConditionalExpression = function (trinex, isContextuallyTyped, context) { + var leftType = this.resolveAST(trinex.whenTrue, isContextuallyTyped, context).type; + var rightType = this.resolveAST(trinex.whenFalse, isContextuallyTyped, context).type; + + var expressionType = this.computeTypeOfConditionalExpression(leftType, rightType, isContextuallyTyped, context); + + var conditionalTypesAreValid = this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context); + + if (this.canTypeCheckAST(trinex, context)) { + this.setTypeChecked(trinex, context); + this.resolveAST(trinex.condition, false, context); + + if (!this.conditionExpressionTypesAreValid(leftType, rightType, expressionType, isContextuallyTyped, context)) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_2_or_3, [expressionType.toString(), leftType.toString(), rightType.toString(), contextualType.toString()])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(trinex, TypeScript.DiagnosticCode.Type_of_conditional_0_must_be_identical_to_1_or_2, [expressionType.toString(), leftType.toString(), rightType.toString()])); + } + } + } + + if (!conditionalTypesAreValid) { + return this.getNewErrorTypeSymbol(); + } + + return expressionType; + }; + + PullTypeResolver.prototype.conditionExpressionTypesAreValid = function (leftType, rightType, expressionType, isContextuallyTyped, context) { + if (isContextuallyTyped) { + var contextualType = context.getContextualType(); + if (this.typesAreIdentical(expressionType, leftType) || this.typesAreIdentical(expressionType, rightType) || this.typesAreIdentical(expressionType, contextualType)) { + return true; + } + } else { + if (this.typesAreIdentical(expressionType, leftType) || this.typesAreIdentical(expressionType, rightType)) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.resolveParenthesizedExpression = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + } + + return this.resolveAST(ast.expression, false, context); + }; + + PullTypeResolver.prototype.resolveExpressionStatement = function (ast, context) { + if (this.canTypeCheckAST(ast, context)) { + this.setTypeChecked(ast, context); + + this.resolveAST(ast.expression, false, context); + } + + return this.semanticInfoChain.voidTypeSymbol; + }; + + PullTypeResolver.prototype.resolveInvocationExpression = function (callEx, context, additionalResults) { + var symbol = this.getSymbolForAST(callEx, context); + + if (!symbol || !symbol.isResolved) { + if (!additionalResults) { + additionalResults = new PullAdditionalCallResolutionData(); + } + symbol = this.computeInvocationExpressionSymbol(callEx, context, additionalResults); + if (this.canTypeCheckAST(callEx, context)) { + this.setTypeChecked(callEx, context); + } + if (symbol != this.semanticInfoChain.anyTypeSymbol) { + this.setSymbolForAST(callEx, symbol, context); + } + this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults); + } else { + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckInvocationExpression(callEx, context); + } + + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (additionalResults && (callResolutionData != additionalResults)) { + additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols; + additionalResults.candidateSignature = callResolutionData.candidateSignature; + additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures; + additionalResults.targetSymbol = callResolutionData.targetSymbol; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.typeCheckInvocationExpression = function (callEx, context) { + this.setTypeChecked(callEx, context); + var targetSymbol = this.resolveAST(callEx.expression, false, context); + + if (callEx.argumentList.arguments) { + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + + var len = callEx.argumentList.arguments.nonSeparatorCount(); + for (var i = 0; i < len; i++) { + var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null; + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) { + context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]); + } + }; + + PullTypeResolver.prototype.computeInvocationExpressionSymbol = function (callEx, context, additionalResults) { + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var targetAST = this.getCallTargetErrorSpanAST(callEx); + + var targetTypeSymbol = targetSymbol.type; + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + this.resolveAST(callEx.argumentList.arguments, false, context); + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + if (targetTypeSymbol === this.semanticInfoChain.anyTypeSymbol) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Untyped_function_calls_may_not_accept_type_arguments), additionalResults, context); + return this.getNewErrorTypeSymbol(); + } + } + + return this.semanticInfoChain.anyTypeSymbol; + } + + var isSuperCall = false; + + if (callEx.expression.kind() === 50 /* SuperKeyword */) { + isSuperCall = true; + + if (targetTypeSymbol.isClass()) { + targetSymbol = targetTypeSymbol.getConstructorMethod(); + this.resolveDeclaredSymbol(targetSymbol, context); + targetTypeSymbol = targetSymbol.type; + } else { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Calls_to_super_are_only_valid_inside_a_class), additionalResults, context); + this.resolveAST(callEx.argumentList.arguments, false, context); + + return this.getNewErrorTypeSymbol(); + } + } + + var signatures = isSuperCall ? targetTypeSymbol.getConstructSignatures() : targetTypeSymbol.getCallSignatures(); + + if (!signatures.length && (targetTypeSymbol.kind == 33554432 /* ConstructorType */)) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, [targetTypeSymbol.toString()]), additionalResults, context); + } + + var typeArgs = null; + var typeReplacementMap = null; + var couldNotFindGenericOverload = false; + var couldNotAssignToConstraint; + var constraintDiagnostic = null; + var typeArgumentCountDiagnostic = null; + var diagnostics = []; + + if (callEx.argumentList.typeArgumentList) { + typeArgs = []; + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + } + } + } else if (isSuperCall && targetTypeSymbol.isGeneric()) { + typeArgs = targetTypeSymbol.getTypeArguments(); + } + + var triedToInferTypeArgs = false; + + var resolvedSignatures = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters; + var typeConstraint = null; + var beforeResolutionSignatures = signatures; + var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < signatures.length; i++) { + typeParameters = signatures[i].getTypeParameters(); + couldNotAssignToConstraint = false; + + if (signatures[i].isGeneric() && typeParameters.length) { + if (typeArgs) { + if (typeArgs.length == typeParameters.length) { + inferredTypeArgs = typeArgs; + } else { + typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, typeArgs.length]); + continue; + } + } else if (!typeArgs && callEx.argumentList.arguments && callEx.argumentList.arguments.nonSeparatorCount()) { + inferredTypeArgs = this.inferArgumentTypesForSignature(signatures[i], new TypeScript.ArgumentInferenceContext(this, callEx.argumentList.arguments), new TypeComparisonInfo(), context); + triedToInferTypeArgs = true; + } else { + inferredTypeArgs = []; + } + + if (inferredTypeArgs) { + typeReplacementMap = []; + + if (inferredTypeArgs.length) { + if (inferredTypeArgs.length != typeParameters.length) { + continue; + } + + if (targetTypeReplacementMap) { + for (var symbolID in targetTypeReplacementMap) { + if (targetTypeReplacementMap.hasOwnProperty(symbolID)) { + typeReplacementMap[symbolID] = targetTypeReplacementMap[symbolID]; + } + } + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = inferredTypeArgs[j]; + } + for (var j = 0; j < typeParameters.length; j++) { + typeConstraint = typeParameters[j].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var k = 0; k < typeParameters.length && k < inferredTypeArgs.length; k++) { + if (typeParameters[k] == typeConstraint) { + typeConstraint = inferredTypeArgs[k]; + } else { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[j], typeConstraint, targetAST, context, null, true)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST); + constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]); + couldNotAssignToConstraint = true; + } + + if (couldNotAssignToConstraint) { + break; + } + } + } + } else { + if (triedToInferTypeArgs) { + continue; + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = this.semanticInfoChain.emptyTypeSymbol; + } + } + + if (couldNotAssignToConstraint) { + continue; + } + + specializedSignature = this.instantiateSignature(signatures[i], typeReplacementMap, true); + + if (specializedSignature) { + resolvedSignatures[resolvedSignatures.length] = specializedSignature; + } + } + } else { + if (!(callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) { + resolvedSignatures[resolvedSignatures.length] = signatures[i]; + } + } + } + + if (signatures.length && !resolvedSignatures.length) { + couldNotFindGenericOverload = true; + } + + signatures = resolvedSignatures; + + var errorCondition = null; + if (!signatures.length) { + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = beforeResolutionSignatures; + additionalResults.candidateSignature = beforeResolutionSignatures && beforeResolutionSignatures.length ? beforeResolutionSignatures[0] : null; + + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + this.resolveAST(callEx.argumentList.arguments, false, context); + + if (!couldNotFindGenericOverload) { + if (this.cachedFunctionInterfaceType() && this.sourceIsSubtypeOfTarget(targetTypeSymbol, this.cachedFunctionInterfaceType(), targetAST, context)) { + if (callEx.argumentList.typeArgumentList) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context); + } + return this.semanticInfoChain.anyTypeSymbol; + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature), additionalResults, context); + } else if (constraintDiagnostic) { + this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context); + } else if (typeArgumentCountDiagnostic) { + this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context); + } else { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context); + } + + return this.getNewErrorTypeSymbol(); + } + + var signature = this.resolveOverloads(callEx, signatures, callEx.argumentList.typeArgumentList != null, context, diagnostics); + var useBeforeResolutionSignatures = signature == null; + + if (!signature) { + for (var i = 0; i < diagnostics.length; i++) { + this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_call_expression), additionalResults, context); + + errorCondition = this.getNewErrorTypeSymbol(); + + if (!signatures.length) { + return errorCondition; + } + + signature = signatures[0]; + } + + if (!signature.isGeneric() && callEx.argumentList.typeArgumentList) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Non_generic_functions_may_not_accept_type_arguments), additionalResults, context); + } else if (signature.isGeneric() && callEx.argumentList.typeArgumentList && signature.getTypeParameters() && (callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount() != signature.getTypeParameters().length)) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [signature.getTypeParameters().length, callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()]), additionalResults, context); + } + + var returnType = isSuperCall ? this.semanticInfoChain.voidTypeSymbol : signature.returnType; + + var actualParametersContextTypeSymbols = []; + if (callEx.argumentList.arguments) { + var len = callEx.argumentList.arguments.nonSeparatorCount(); + var params = signature.parameters; + var contextualType = null; + var signatureDecl = signature.getDeclarations()[0]; + + for (var i = 0; i < len; i++) { + if (params.length) { + if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) { + this.resolveDeclaredSymbol(params[i], context); + contextualType = params[i].type; + } else if (signature.hasVarArgs) { + contextualType = params[params.length - 1].type; + if (contextualType.isArrayNamedTypeReference()) { + contextualType = contextualType.getElementType(); + } + } + } + + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + actualParametersContextTypeSymbols[i] = contextualType; + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + additionalResults.targetSymbol = targetSymbol; + if (useBeforeResolutionSignatures && beforeResolutionSignatures) { + additionalResults.resolvedSignatures = beforeResolutionSignatures; + additionalResults.candidateSignature = beforeResolutionSignatures[0]; + } else { + additionalResults.resolvedSignatures = signatures; + additionalResults.candidateSignature = signature; + } + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + if (errorCondition) { + return errorCondition; + } + + if (!returnType) { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + + return returnType; + }; + + PullTypeResolver.prototype.resolveObjectCreationExpression = function (callEx, context, additionalResults) { + var symbol = this.getSymbolForAST(callEx, context); + + if (!symbol || !symbol.isResolved) { + if (!additionalResults) { + additionalResults = new PullAdditionalCallResolutionData(); + } + symbol = this.computeObjectCreationExpressionSymbol(callEx, context, additionalResults); + if (this.canTypeCheckAST(callEx, context)) { + this.setTypeChecked(callEx, context); + } + this.setSymbolForAST(callEx, symbol, context); + this.semanticInfoChain.setCallResolutionDataForAST(callEx, additionalResults); + } else { + if (this.canTypeCheckAST(callEx, context)) { + this.typeCheckObjectCreationExpression(callEx, context); + } + + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (additionalResults && (callResolutionData != additionalResults)) { + additionalResults.actualParametersContextTypeSymbols = callResolutionData.actualParametersContextTypeSymbols; + additionalResults.candidateSignature = callResolutionData.candidateSignature; + additionalResults.resolvedSignatures = callResolutionData.resolvedSignatures; + additionalResults.targetSymbol = callResolutionData.targetSymbol; + } + } + + return symbol; + }; + + PullTypeResolver.prototype.typeCheckObjectCreationExpression = function (callEx, context) { + this.setTypeChecked(callEx, context); + this.resolveAST(callEx.expression, false, context); + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + if (callEx.argumentList) { + var callResolutionData = this.semanticInfoChain.getCallResolutionDataForAST(callEx); + var len = callEx.argumentList.arguments.nonSeparatorCount(); + + for (var i = 0; i < len; i++) { + var contextualType = callResolutionData.actualParametersContextTypeSymbols ? callResolutionData.actualParametersContextTypeSymbols[i] : null; + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + for (var i = 0; i < callResolutionData.diagnosticsFromOverloadResolution.length; i++) { + context.postDiagnostic(callResolutionData.diagnosticsFromOverloadResolution[i]); + } + }; + + PullTypeResolver.prototype.postOverloadResolutionDiagnostics = function (diagnostic, additionalResults, context) { + if (!context.inProvisionalResolution()) { + additionalResults.diagnosticsFromOverloadResolution.push(diagnostic); + } + context.postDiagnostic(diagnostic); + }; + + PullTypeResolver.prototype.computeObjectCreationExpressionSymbol = function (callEx, context, additionalResults) { + var returnType = null; + + var targetSymbol = this.resolveAST(callEx.expression, false, context); + var targetTypeSymbol = targetSymbol.isType() ? targetSymbol : targetSymbol.type; + + var targetAST = this.getCallTargetErrorSpanAST(callEx); + + var constructSignatures = targetTypeSymbol.getConstructSignatures(); + + var typeArgs = null; + var typeReplacementMap = null; + var usedCallSignaturesInstead = false; + var couldNotAssignToConstraint; + var constraintDiagnostic = null; + var typeArgumentCountDiagnostic = null; + var diagnostics = []; + + if (this.isAnyOrEquivalent(targetTypeSymbol)) { + if (callEx.argumentList) { + this.resolveAST(callEx.argumentList.arguments, false, context); + } + + return targetTypeSymbol; + } + + if (!constructSignatures.length) { + constructSignatures = targetTypeSymbol.getCallSignatures(); + usedCallSignaturesInstead = true; + + if (this.compilationSettings.noImplicitAny()) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(callEx, TypeScript.DiagnosticCode.new_expression_which_lacks_a_constructor_signature_implicitly_has_an_any_type), additionalResults, context); + } + } + + if (constructSignatures.length) { + if (callEx.argumentList && callEx.argumentList.typeArgumentList) { + typeArgs = []; + + if (callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount()) { + for (var i = 0; i < callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount(); i++) { + typeArgs[i] = this.resolveTypeReference(callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorAt(i), context); + } + } + } + + if (targetTypeSymbol.isGeneric()) { + var resolvedSignatures = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters; + var typeConstraint = null; + var triedToInferTypeArgs; + var targetTypeReplacementMap = targetTypeSymbol.getTypeParameterArgumentMap(); + + for (var i = 0; i < constructSignatures.length; i++) { + couldNotAssignToConstraint = false; + + if (constructSignatures[i].isGeneric()) { + typeParameters = constructSignatures[i].getTypeParameters(); + + if (typeArgs) { + if (typeArgs.length == typeParameters.length) { + inferredTypeArgs = typeArgs; + } else { + typeArgumentCountDiagnostic = typeArgumentCountDiagnostic || this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Signature_expected_0_type_arguments_got_1_instead, [typeParameters.length, typeArgs.length]); + continue; + } + } else if (!typeArgs && callEx.argumentList && callEx.argumentList.arguments && callEx.argumentList.arguments.nonSeparatorCount()) { + inferredTypeArgs = this.inferArgumentTypesForSignature(constructSignatures[i], new TypeScript.ArgumentInferenceContext(this, callEx.argumentList.arguments), new TypeComparisonInfo(), context); + triedToInferTypeArgs = true; + } else { + inferredTypeArgs = []; + } + + if (inferredTypeArgs) { + typeReplacementMap = []; + + if (inferredTypeArgs.length) { + if (inferredTypeArgs.length < typeParameters.length) { + continue; + } + + if (targetTypeReplacementMap) { + for (var symbolID in targetTypeReplacementMap) { + if (targetTypeReplacementMap.hasOwnProperty(symbolID)) { + typeReplacementMap[symbolID] = targetTypeReplacementMap[symbolID]; + } + } + } + + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = inferredTypeArgs[j]; + } + for (var j = 0; j < typeParameters.length; j++) { + typeConstraint = typeParameters[j].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var k = 0; k < typeParameters.length && k < inferredTypeArgs.length; k++) { + if (typeParameters[k] == typeConstraint) { + typeConstraint = inferredTypeArgs[k]; + } else { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = this.instantiateType(typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[j], typeConstraint, targetAST, context, null, true)) { + var enclosingSymbol = this.getEnclosingSymbolForAST(targetAST); + constraintDiagnostic = this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Type_0_does_not_satisfy_the_constraint_1_for_type_parameter_2, [inferredTypeArgs[j].toString(enclosingSymbol, true), typeConstraint.toString(enclosingSymbol, true), typeParameters[j].toString(enclosingSymbol, true)]); + couldNotAssignToConstraint = true; + } + + if (couldNotAssignToConstraint) { + break; + } + } + } + } else { + if (triedToInferTypeArgs) { + continue; + } else { + for (var j = 0; j < typeParameters.length; j++) { + typeReplacementMap[typeParameters[j].pullSymbolID] = this.semanticInfoChain.emptyTypeSymbol; + } + } + } + + if (couldNotAssignToConstraint) { + continue; + } + + specializedSignature = this.instantiateSignature(constructSignatures[i], typeReplacementMap, true); + + if (specializedSignature) { + resolvedSignatures[resolvedSignatures.length] = specializedSignature; + } + } + } else { + if (!(callEx.argumentList && callEx.argumentList.typeArgumentList && callEx.argumentList.typeArgumentList.typeArguments.nonSeparatorCount())) { + resolvedSignatures[resolvedSignatures.length] = constructSignatures[i]; + } + } + } + + constructSignatures = resolvedSignatures; + } + + var signature = this.resolveOverloads(callEx, constructSignatures, callEx.argumentList && callEx.argumentList.typeArgumentList != null, context, diagnostics); + + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = constructSignatures; + additionalResults.candidateSignature = signature; + additionalResults.actualParametersContextTypeSymbols = []; + + if (!constructSignatures.length) { + if (constraintDiagnostic) { + this.postOverloadResolutionDiagnostics(constraintDiagnostic, additionalResults, context); + } else if (typeArgumentCountDiagnostic) { + this.postOverloadResolutionDiagnostics(typeArgumentCountDiagnostic, additionalResults, context); + } + + return this.getNewErrorTypeSymbol(); + } + + var errorCondition = null; + + if (!signature) { + for (var i = 0; i < diagnostics.length; i++) { + this.postOverloadResolutionDiagnostics(diagnostics[i], additionalResults, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Could_not_select_overload_for_new_expression), additionalResults, context); + + errorCondition = this.getNewErrorTypeSymbol(); + + if (!constructSignatures.length) { + return errorCondition; + } + + signature = constructSignatures[0]; + } + + returnType = signature.returnType; + + if (returnType && !signature.isGeneric() && returnType.isGeneric() && !returnType.getIsSpecialized()) { + if (typeArgs && typeArgs.length) { + returnType = this.createInstantiatedType(returnType, typeArgs); + } else { + returnType = this.instantiateTypeToAny(returnType, context); + } + } + + if (usedCallSignaturesInstead) { + if (returnType != this.semanticInfoChain.voidTypeSymbol) { + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Call_signatures_used_in_a_new_expression_must_have_a_void_return_type), additionalResults, context); + + return this.getNewErrorTypeSymbol(); + } else { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + } + + if (!returnType) { + returnType = signature.returnType; + + if (!returnType) { + returnType = targetTypeSymbol; + } + } + + var actualParametersContextTypeSymbols = []; + if (callEx.argumentList && callEx.argumentList.arguments) { + var len = callEx.argumentList.arguments.nonSeparatorCount(); + var params = signature.parameters; + var contextualType = null; + var signatureDecl = signature.getDeclarations()[0]; + + for (var i = 0; i < len; i++) { + if (params.length) { + if (i < params.length - 1 || (i < params.length && !signature.hasVarArgs)) { + this.resolveDeclaredSymbol(params[i], context); + contextualType = params[i].type; + } else if (signature.hasVarArgs) { + contextualType = params[params.length - 1].type; + if (contextualType.isArrayNamedTypeReference()) { + contextualType = contextualType.getElementType(); + } + } + } + + if (contextualType) { + context.pushContextualType(contextualType, context.inProvisionalResolution(), null); + actualParametersContextTypeSymbols[i] = contextualType; + } + + this.resolveAST(callEx.argumentList.arguments.nonSeparatorAt(i), contextualType != null, context); + + if (contextualType) { + context.popContextualType(); + contextualType = null; + } + } + } + + additionalResults.targetSymbol = targetSymbol; + additionalResults.resolvedSignatures = constructSignatures; + additionalResults.candidateSignature = signature; + additionalResults.actualParametersContextTypeSymbols = actualParametersContextTypeSymbols; + + if (errorCondition) { + return errorCondition; + } + + if (!returnType) { + returnType = this.semanticInfoChain.anyTypeSymbol; + } + + return returnType; + } else if (callEx.argumentList) { + this.resolveAST(callEx.argumentList.arguments, false, context); + } + + this.postOverloadResolutionDiagnostics(this.semanticInfoChain.diagnosticFromAST(targetAST, TypeScript.DiagnosticCode.Invalid_new_expression), additionalResults, context); + + return this.getNewErrorTypeSymbol(); + }; + + PullTypeResolver.prototype.instantiateSignatureInContext = function (signatureA, signatureB, context) { + var typeReplacementMap = []; + var inferredTypeArgs; + var specializedSignature; + var typeParameters = signatureA.getTypeParameters(); + var typeConstraint = null; + + var fixedParameterTypes = []; + + for (var i = 0; i < signatureB.parameters.length; i++) { + fixedParameterTypes.push(signatureB.parameters[i].isVarArg ? signatureB.parameters[i].type.getElementType() : signatureB.parameters[i].type); + } + + inferredTypeArgs = this.inferArgumentTypesForSignature(signatureA, new TypeScript.ArgumentInferenceContext(this, fixedParameterTypes), new TypeComparisonInfo(), context); + + var functionTypeA = signatureA.functionType; + var functionTypeB = signatureB.functionType; + var enclosingTypeParameterMap; + + if (functionTypeA) { + enclosingTypeParameterMap = functionTypeA.getTypeParameterArgumentMap(); + + for (var id in enclosingTypeParameterMap) { + typeReplacementMap[id] = enclosingTypeParameterMap[id]; + } + } + + if (functionTypeB) { + enclosingTypeParameterMap = functionTypeB.getTypeParameterArgumentMap(); + + for (var id in enclosingTypeParameterMap) { + typeReplacementMap[id] = enclosingTypeParameterMap[id]; + } + } + + for (var i = 0; i < typeParameters.length; i++) { + typeReplacementMap[typeParameters[i].pullSymbolID] = inferredTypeArgs[i]; + } + for (var i = 0; i < typeParameters.length; i++) { + typeConstraint = typeParameters[i].getConstraint(); + + if (typeConstraint) { + if (typeConstraint.isTypeParameter()) { + for (var j = 0; j < typeParameters.length && j < inferredTypeArgs.length; j++) { + if (typeParameters[j] == typeConstraint) { + typeConstraint = inferredTypeArgs[j]; + } + } + } else if (typeConstraint.isGeneric()) { + typeConstraint = TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, typeConstraint, typeReplacementMap); + } + + if (!this.sourceIsAssignableToTarget(inferredTypeArgs[i], typeConstraint, null, context, null, true)) { + if (this.signaturesAreIdentical(signatureA, signatureB, true)) { + return signatureA; + } else { + return null; + } + } + } + } + + return this.instantiateSignature(signatureA, typeReplacementMap, true); + }; + + PullTypeResolver.prototype.resolveCastExpression = function (assertionExpression, context) { + var typeAssertionType = this.resolveTypeReference(assertionExpression.type, context).type; + + if (this.canTypeCheckAST(assertionExpression, context)) { + this.typeCheckCastExpression(assertionExpression, context, typeAssertionType); + } + + return typeAssertionType; + }; + + PullTypeResolver.prototype.typeCheckCastExpression = function (assertionExpression, context, typeAssertionType) { + this.setTypeChecked(assertionExpression, context); + + context.pushContextualType(typeAssertionType, context.inProvisionalResolution(), null); + var exprType = this.resolveAST(assertionExpression.expression, true, context).type; + context.popContextualType(); + + this.resolveDeclaredSymbol(typeAssertionType, context); + this.resolveDeclaredSymbol(exprType, context); + + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(typeAssertionType, exprType, assertionExpression, context, comparisonInfo) || this.sourceIsAssignableToTarget(exprType, typeAssertionType, assertionExpression, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(assertionExpression); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(assertionExpression, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [exprType.toString(enclosingSymbol), typeAssertionType.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.resolveAssignmentExpression = function (binaryExpression, context) { + var leftExpr = this.resolveAST(binaryExpression.left, false, context); + var leftType = leftExpr.type; + + context.pushContextualType(leftType, context.inProvisionalResolution(), null); + var rightType = this.resolveAST(binaryExpression.right, true, context).type; + context.popContextualType(); + + rightType = this.getInstanceTypeForAssignment(binaryExpression.left, rightType, context); + + if (this.canTypeCheckAST(binaryExpression, context)) { + this.setTypeChecked(binaryExpression, context); + + if (!this.isReference(binaryExpression.left, leftExpr)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(binaryExpression.left, TypeScript.DiagnosticCode.Invalid_left_hand_side_of_assignment_expression)); + } else { + this.checkAssignability(binaryExpression.left, rightType, leftExpr.type, context); + } + } + + return rightType; + }; + + PullTypeResolver.prototype.getInstanceTypeForAssignment = function (lhs, type, context) { + var typeToReturn = type; + if (typeToReturn && typeToReturn.isAlias()) { + typeToReturn = typeToReturn.getExportAssignedTypeSymbol(); + } + + if (typeToReturn && typeToReturn.isContainer() && !typeToReturn.isEnum()) { + var instanceTypeSymbol = typeToReturn.getInstanceType(); + + if (!instanceTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(lhs, TypeScript.DiagnosticCode.Tried_to_set_variable_type_to_uninitialized_module_type_0, [type.toString()])); + typeToReturn = null; + } else { + typeToReturn = instanceTypeSymbol; + } + } + + return typeToReturn; + }; + + PullTypeResolver.prototype.widenType = function (type, ast, context) { + if (type === this.semanticInfoChain.undefinedTypeSymbol || type === this.semanticInfoChain.nullTypeSymbol || type.isError()) { + return this.semanticInfoChain.anyTypeSymbol; + } + + if (type.isArrayNamedTypeReference()) { + var elementType = this.widenType(type.getElementType(), null, context); + + if (this.compilationSettings.noImplicitAny() && ast && ast.kind() === 214 /* ArrayLiteralExpression */) { + if (elementType === this.semanticInfoChain.anyTypeSymbol && type.getElementType() !== this.semanticInfoChain.anyTypeSymbol) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Array_Literal_implicitly_has_an_any_type_from_widening)); + } + } + + var arraySymbol = elementType.getArrayType(); + + if (!arraySymbol) { + arraySymbol = this.createInstantiatedType(this.cachedArrayInterfaceType(), [elementType]); + + if (!arraySymbol) { + arraySymbol = this.semanticInfoChain.anyTypeSymbol; + } + } + + return arraySymbol; + } + + return type; + }; + + PullTypeResolver.prototype.findBestCommonType = function (collection, context, comparisonInfo) { + var len = collection.getLength(); + + for (var i = 0; i < len; i++) { + var candidateType = collection.getTypeAtIndex(i); + if (this.typeIsBestCommonTypeCandidate(candidateType, collection, context)) { + return candidateType; + } + } + + return this.semanticInfoChain.emptyTypeSymbol; + }; + + PullTypeResolver.prototype.typeIsBestCommonTypeCandidate = function (candidateType, collection, context) { + for (var i = 0; i < collection.getLength(); i++) { + var otherType = collection.getTypeAtIndex(i); + if (candidateType == otherType) { + continue; + } + + if (candidateType.isTypeParameter() && !otherType.isTypeParameter()) { + return false; + } else if (!candidateType.isTypeParameter() && otherType.isTypeParameter()) { + continue; + } else if (!this.sourceIsSubtypeOfTarget(otherType, candidateType, null, context)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.typesAreIdenticalInEnclosingTypes = function (t1, t2, t1EnclosingType, t2EnclosingType, val) { + t1 = this.getSymbolForRelationshipCheck(t1); + t2 = this.getSymbolForRelationshipCheck(t2); + + if (t1 === t2) { + return true; + } + + if (t1 && t2) { + var t1GenerativeTypeKind = t1EnclosingType ? t1.getGenerativeTypeClassification(t1EnclosingType) : 0 /* Unknown */; + var t2GenerativeTypeKind = t2EnclosingType ? t2.getGenerativeTypeClassification(t2EnclosingType) : 0 /* Unknown */; + if (t1GenerativeTypeKind == 3 /* InfinitelyExpanding */ || t2GenerativeTypeKind == 3 /* InfinitelyExpanding */) { + return this.infinitelyExpandingTypesAreIdentical(t1, t2); + } + } + + return this.typesAreIdentical(t1, t2, val); + }; + + PullTypeResolver.prototype.typesAreIdentical = function (t1, t2, val) { + t1 = this.getSymbolForRelationshipCheck(t1); + t2 = this.getSymbolForRelationshipCheck(t2); + + if (t1 === t2) { + return true; + } + + if (!t1 || !t2) { + return false; + } + + if (val && t1.isPrimitive() && t1.isStringConstant() && t2 === this.semanticInfoChain.stringTypeSymbol) { + return (val.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(val.text()) === TypeScript.stripStartAndEndQuotes(t1.name)); + } + + if (val && t2.isPrimitive() && t2.isStringConstant() && t2 === this.semanticInfoChain.stringTypeSymbol) { + return (val.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(val.text()) === TypeScript.stripStartAndEndQuotes(t2.name)); + } + + if (t1.isPrimitive() && t1.isStringConstant() && t2.isPrimitive() && t2.isStringConstant()) { + return TypeScript.stripStartAndEndQuotes(t1.name) === TypeScript.stripStartAndEndQuotes(t2.name); + } + + if (t1.isPrimitive() || t2.isPrimitive()) { + return false; + } + + if (t1.isError() && t2.isError()) { + return true; + } + + if (t1.isTypeParameter() != t2.isTypeParameter()) { + return false; + } else if (t1.isTypeParameter()) { + var t1ParentDeclaration = t1.getDeclarations()[0].getParentDecl(); + var t2ParentDeclaration = t2.getDeclarations()[0].getParentDecl(); + + if (t1ParentDeclaration === t2ParentDeclaration) { + return this.symbolsShareDeclaration(t1, t2); + } else { + return false; + } + } + + var isIdentical = this.identicalCache.valueAt(t1.pullSymbolID, t2.pullSymbolID); + if (isIdentical != undefined) { + return isIdentical; + } + + if ((t1.kind & 64 /* Enum */) || (t2.kind & 64 /* Enum */)) { + return t1.getAssociatedContainerType() === t2 || t2.getAssociatedContainerType() === t1; + } + + if (t1.isPrimitive() != t2.isPrimitive()) { + return false; + } + + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, false); + + if (t1.hasMembers() && t2.hasMembers()) { + var t1Members = t1.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + var t2Members = t2.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + if (t1Members.length != t2Members.length) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + var t1MemberSymbol = null; + var t2MemberSymbol = null; + + var t1MemberType = null; + var t2MemberType = null; + + for (var iMember = 0; iMember < t1Members.length; iMember++) { + t1MemberSymbol = t1Members[iMember]; + t2MemberSymbol = this.getMemberSymbol(t1MemberSymbol.name, 68147712 /* SomeValue */, t2); + + if (!t2MemberSymbol || (t1MemberSymbol.isOptional != t2MemberSymbol.isOptional)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + t1MemberType = t1MemberSymbol.type; + t2MemberType = t2MemberSymbol.type; + + if (!this.typesAreIdenticalInEnclosingTypes(t1MemberType, t2MemberType, t1, t2)) { + return false; + } + } + } else if (t1.hasMembers() || t2.hasMembers()) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + var t1CallSigs = t1.getCallSignatures(); + var t2CallSigs = t2.getCallSignatures(); + + var t1ConstructSigs = t1.getConstructSignatures(); + var t2ConstructSigs = t2.getConstructSignatures(); + + var t1IndexSigs = t1.getIndexSignatures(); + var t2IndexSigs = t2.getIndexSignatures(); + + if (!this.signatureGroupsAreIdentical(t1CallSigs, t2CallSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + if (!this.signatureGroupsAreIdentical(t1ConstructSigs, t2ConstructSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + if (!this.signatureGroupsAreIdentical(t1IndexSigs, t2IndexSigs)) { + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, undefined); + return false; + } + + this.identicalCache.setValueAt(t1.pullSymbolID, t2.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.signatureGroupsAreIdentical = function (sg1, sg2) { + if (sg1 === sg2) { + return true; + } + + if (!sg1 || !sg2) { + return false; + } + + if (sg1.length != sg2.length) { + return false; + } + + var sig1 = null; + var sig2 = null; + var sigsMatch = false; + + for (var iSig1 = 0; iSig1 < sg1.length; iSig1++) { + sig1 = sg1[iSig1]; + + for (var iSig2 = 0; iSig2 < sg2.length; iSig2++) { + sig2 = sg2[iSig2]; + + if (this.signaturesAreIdentical(sig1, sig2)) { + sigsMatch = true; + break; + } + } + + if (sigsMatch) { + sigsMatch = false; + continue; + } + + return false; + } + + return true; + }; + + PullTypeResolver.prototype.signaturesAreIdentical = function (s1, s2, includingReturnType) { + if (typeof includingReturnType === "undefined") { includingReturnType = true; } + if (s1 === s2) { + return true; + } + + if (s1.hasVarArgs != s2.hasVarArgs) { + return false; + } + + if (s1.nonOptionalParamCount != s2.nonOptionalParamCount) { + return false; + } + + if (!!(s1.typeParameters && s1.typeParameters.length) != !!(s2.typeParameters && s2.typeParameters.length)) { + return false; + } + + if (s1.typeParameters && s2.typeParameters && (s1.typeParameters.length != s2.typeParameters.length)) { + return false; + } + + if (s1.parameters.length != s2.parameters.length) { + return false; + } + + this.resolveDeclaredSymbol(s1); + this.resolveDeclaredSymbol(s2); + + var s1Params = s1.parameters; + var s2Params = s2.parameters; + + if (includingReturnType && !this.typesAreIdenticalInEnclosingTypes(s1.returnType, s2.returnType, s1.functionType, s2.functionType)) { + return false; + } + + for (var iParam = 0; iParam < s1Params.length; iParam++) { + if (!this.typesAreIdenticalInEnclosingTypes(s1Params[iParam].type, s2Params[iParam].type, s1.functionType, s2.functionType)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.substituteUpperBoundForType = function (type) { + if (!type || !type.isTypeParameter()) { + return type; + } + + var constraint = type.getConstraint(); + + if (constraint && (constraint != type)) { + return this.substituteUpperBoundForType(constraint); + } + + return type; + }; + + PullTypeResolver.prototype.symbolsShareDeclaration = function (symbol1, symbol2) { + var decls1 = symbol1.getDeclarations(); + var decls2 = symbol2.getDeclarations(); + + if (decls1.length && decls2.length) { + return decls1[0].isEqual(decls2[0]); + } + + return false; + }; + + PullTypeResolver.prototype.sourceExtendsTarget = function (source, target, context) { + if (source.isGeneric() != target.isGeneric()) { + return false; + } + + if (source.isTypeReference() && target.isTypeReference()) { + if (source.referencedTypeSymbol.hasBase(target.referencedTypeSymbol)) { + var sourceTypeArguments = source.getTypeArguments(); + var targetTypeArguments = target.getTypeArguments(); + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + return false; + } + + for (var i = 0; i < targetTypeArguments.length; i++) { + if (!this.sourceExtendsTarget(sourceTypeArguments[i], targetTypeArguments[i], context)) { + return false; + } + } + + return true; + } + } + + if (source.hasBase(target)) { + return true; + } + + if (context.isInBaseTypeResolution() && (source.kind & (16 /* Interface */ | 8 /* Class */)) && (target.kind & (16 /* Interface */ | 8 /* Class */))) { + var sourceDecls = source.getDeclarations(); + var extendsSymbol = null; + + for (var i = 0; i < sourceDecls.length; i++) { + var sourceAST = this.semanticInfoChain.getASTForDecl(sourceDecls[i]); + var extendsClause = TypeScript.getExtendsHeritageClause(sourceAST.heritageClauses); + + if (extendsClause) { + for (var j = 0; j < extendsClause.typeNames.nonSeparatorCount(); j++) { + extendsSymbol = this.semanticInfoChain.getSymbolForAST(extendsClause.typeNames.nonSeparatorAt(j)); + + if (extendsSymbol && (extendsSymbol == target || this.sourceExtendsTarget(extendsSymbol, target, context))) { + return true; + } + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.sourceIsSubtypeOfTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIsRelatableToTarget(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceMembersAreSubtypeOfTargetMembers = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceMembersAreRelatableToTargetMembers(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourcePropertyIsSubtypeOfTargetProperty = function (source, target, sourceProp, targetProp, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceCallSignaturesAreSubtypeOfTargetCallSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceCallSignaturesAreRelatableToTargetCallSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(source, target, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.typeIsSubtypeOfFunction = function (source, ast, context) { + if (source.getCallSignatures().length || source.getConstructSignatures().length) { + return true; + } + + return this.cachedFunctionInterfaceType() && this.sourceIsSubtypeOfTarget(source, this.cachedFunctionInterfaceType(), ast, context); + }; + + PullTypeResolver.prototype.signatureIsSubtypeOfTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.signatureIsRelatableToTarget(s1, s2, false, this.subtypeCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIsAssignableToTarget = function (source, target, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.sourceIsRelatableToTarget(source, target, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.signatureIsAssignableToTarget = function (s1, s2, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + return this.signatureIsRelatableToTarget(s1, s2, true, this.assignableCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.getSymbolForRelationshipCheck = function (symbol) { + if (symbol && symbol.isTypeReference()) { + return symbol.getReferencedTypeSymbol(); + } + + return symbol; + }; + + PullTypeResolver.prototype.sourceIsRelatableToTargetInEnclosingTypes = function (source, target, sourceEnclosingType, targetEnclosingType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + source = this.getSymbolForRelationshipCheck(source); + target = this.getSymbolForRelationshipCheck(target); + + if (source === target) { + return true; + } + + if (source && target) { + var sourceGenerativeTypeKind = sourceEnclosingType ? source.getGenerativeTypeClassification(sourceEnclosingType) : 0 /* Unknown */; + var targetGenerativeTypeKind = targetEnclosingType ? target.getGenerativeTypeClassification(targetEnclosingType) : 0 /* Unknown */; + if (sourceGenerativeTypeKind == 3 /* InfinitelyExpanding */ || targetGenerativeTypeKind == 3 /* InfinitelyExpanding */) { + return this.infinitelyExpandingSourceTypeIsRelatableToTargetType(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + } + } + + return this.sourceIsRelatableToTarget(source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures); + }; + + PullTypeResolver.prototype.sourceIsRelatableToTarget = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + source = this.getSymbolForRelationshipCheck(source); + target = this.getSymbolForRelationshipCheck(target); + + if (source === target) { + return true; + } + + if (!(source && target)) { + return true; + } + + var sourceSubstitution = source; + + if (source == this.semanticInfoChain.stringTypeSymbol && this.cachedStringInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedStringInterfaceType(), context); + sourceSubstitution = this.cachedStringInterfaceType(); + } else if (source == this.semanticInfoChain.numberTypeSymbol && this.cachedNumberInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedNumberInterfaceType(), context); + sourceSubstitution = this.cachedNumberInterfaceType(); + } else if (source == this.semanticInfoChain.booleanTypeSymbol && this.cachedBooleanInterfaceType()) { + this.resolveDeclaredSymbol(this.cachedBooleanInterfaceType(), context); + sourceSubstitution = this.cachedBooleanInterfaceType(); + } else if (TypeScript.PullHelpers.symbolIsEnum(source) && this.cachedNumberInterfaceType()) { + sourceSubstitution = this.cachedNumberInterfaceType(); + } else if (source.isTypeParameter()) { + sourceSubstitution = this.substituteUpperBoundForType(source); + } + + if (comparisonCache.valueAt(source.pullSymbolID, target.pullSymbolID) != undefined) { + return true; + } + + if (source === this.semanticInfoChain.stringTypeSymbol && target.isPrimitive() && target.isStringConstant()) { + return comparisonInfo && comparisonInfo.stringConstantVal && (comparisonInfo.stringConstantVal.kind() === 14 /* StringLiteral */) && (TypeScript.stripStartAndEndQuotes(comparisonInfo.stringConstantVal.text()) === TypeScript.stripStartAndEndQuotes(target.name)); + } + + if (assignableTo) { + if (this.isAnyOrEquivalent(source) || this.isAnyOrEquivalent(target)) { + return true; + } + } else { + if (this.isAnyOrEquivalent(target)) { + return true; + } + + if (target === this.semanticInfoChain.stringTypeSymbol && source.isPrimitive() && source.isStringConstant()) { + return true; + } + } + + if (source.isPrimitive() && source.isStringConstant() && target.isPrimitive() && target.isStringConstant()) { + return TypeScript.stripStartAndEndQuotes(source.name) === TypeScript.stripStartAndEndQuotes(target.name); + } + + if (source === this.semanticInfoChain.undefinedTypeSymbol) { + return true; + } + + if ((source === this.semanticInfoChain.nullTypeSymbol) && (target != this.semanticInfoChain.undefinedTypeSymbol && target != this.semanticInfoChain.voidTypeSymbol)) { + return true; + } + + if (target == this.semanticInfoChain.voidTypeSymbol) { + if (source == this.semanticInfoChain.undefinedTypeSymbol || source == this.semanticInfoChain.nullTypeSymbol) { + return true; + } + + return false; + } else if (source == this.semanticInfoChain.voidTypeSymbol) { + if (target == this.semanticInfoChain.anyTypeSymbol) { + return true; + } + + return false; + } + + if (target === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(source)) { + return true; + } + + if (source === this.semanticInfoChain.numberTypeSymbol && TypeScript.PullHelpers.symbolIsEnum(target)) { + return assignableTo; + } + + if (TypeScript.PullHelpers.symbolIsEnum(target) && TypeScript.PullHelpers.symbolIsEnum(source)) { + return this.symbolsShareDeclaration(target, source); + } + + if ((source.kind & 64 /* Enum */) || (target.kind & 64 /* Enum */)) { + return false; + } + + if (source.getIsSpecialized() && target.getIsSpecialized()) { + if (TypeScript.PullHelpers.getRootType(source) == TypeScript.PullHelpers.getRootType(target)) { + var sourceTypeArguments = source.getTypeArguments(); + var targetTypeArguments = target.getTypeArguments(); + + if (sourceTypeArguments && targetTypeArguments) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, false); + + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.sourceIsRelatableToTarget(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + break; + } + } + + if (i == sourceTypeArguments.length) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true); + return true; + } else { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + } + } + } + } + + if (sourceSubstitution.isPrimitive() || target.isPrimitive()) { + return false; + } + + if (target.isTypeParameter()) { + if (source.isTypeParameter() && (source === sourceSubstitution)) { + return this.typesAreIdentical(target, source); + } else { + if (isComparingInstantiatedSignatures) { + target = this.substituteUpperBoundForType(target); + } else { + return this.typesAreIdentical(target, sourceSubstitution); + } + } + } + + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, false); + + if ((source.kind & 8216 /* SomeInstantiatableType */) && (target.kind & 8216 /* SomeInstantiatableType */) && this.sourceExtendsTarget(source, target, context)) { + return true; + } + + if (this.cachedObjectInterfaceType() && target === this.cachedObjectInterfaceType()) { + return true; + } + + if (this.cachedFunctionInterfaceType() && (sourceSubstitution.getCallSignatures().length || sourceSubstitution.getConstructSignatures().length) && target.hasBase(this.cachedFunctionInterfaceType())) { + return true; + } + + if (target.hasMembers() && !this.sourceMembersAreRelatableToTargetMembers(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceCallSignaturesAreRelatableToTargetCallSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceConstructSignaturesAreRelatableToTargetConstructSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + if (!this.sourceIndexSignaturesAreRelatableToTargetIndexSignatures(sourceSubstitution, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, undefined); + return false; + } + + comparisonCache.setValueAt(source.pullSymbolID, target.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.sourceMembersAreRelatableToTargetMembers = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetProps = target.getAllMembers(68147712 /* SomeValue */, 0 /* all */); + + for (var itargetProp = 0; itargetProp < targetProps.length; itargetProp++) { + var targetProp = targetProps[itargetProp]; + var sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, source); + + this.resolveDeclaredSymbol(targetProp, context); + + var targetPropType = targetProp.type; + + if (sourceProp && sourceProp.anyDeclHasFlag(16 /* Static */) && source.isClass()) { + sourceProp = null; + } + + if (!sourceProp) { + if (this.cachedObjectInterfaceType()) { + sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, this.cachedObjectInterfaceType()); + } + + if (!sourceProp) { + if (this.cachedFunctionInterfaceType() && (targetPropType.getCallSignatures().length || targetPropType.getConstructSignatures().length)) { + sourceProp = this.getMemberSymbol(targetProp.name, 68147712 /* SomeValue */, this.cachedFunctionInterfaceType()); + } + + if (!sourceProp) { + if (!(targetProp.isOptional)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.flags |= 2 /* RequiredPropertyIsMissing */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_is_missing_property_1_from_type_2, [source.toString(enclosingSymbol), targetProp.getScopedNameEx().toString(), target.toString(enclosingSymbol)])); + } + return false; + } + continue; + } + } + } + + if (!this.sourcePropertyIsRelatableToTargetProperty(source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.infinitelyExpandingSourceTypeIsRelatableToTargetType = function (sourceType, targetType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var widenedTargetType = this.widenType(targetType); + var widenedSourceType = this.widenType(sourceType); + + if ((widenedSourceType != this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType != this.semanticInfoChain.anyTypeSymbol)) { + var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType); + var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType); + + if (sourceTypeNamedTypeReference != targetTypeNamedTypeReference) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_do_not_refer_to_same_named_type, [sourceType.getScopedNameEx(enclosingSymbol).toString(), targetType.toString(enclosingSymbol)])); + } + return false; + } + + var sourceTypeArguments = sourceType.getTypeArguments(); + var targetTypeArguments = targetType.getTypeArguments(); + + if (!sourceTypeArguments && !targetTypeArguments) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + } + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)])); + } + return false; + } + + var comparisonInfoTypeArgumentsCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoTypeArgumentsCheck = new TypeComparisonInfo(comparisonInfo); + } + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.sourceIsRelatableToTarget(sourceTypeArguments[i], targetTypeArguments[i], assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + + if (comparisonInfoTypeArgumentsCheck && comparisonInfoTypeArgumentsCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments_NL_2, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol), comparisonInfoTypeArgumentsCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_originating_in_inifinitely_expanding_type_reference_have_incompatible_type_arguments, [sourceType.toString(enclosingSymbol), targetType.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(message); + } + } + } + } + + comparisonCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.infinitelyExpandingTypesAreIdentical = function (sourceType, targetType) { + var widenedTargetType = this.widenType(targetType); + var widenedSourceType = this.widenType(sourceType); + + if ((widenedSourceType != this.semanticInfoChain.anyTypeSymbol) && (widenedTargetType != this.semanticInfoChain.anyTypeSymbol)) { + var sourceTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(sourceType); + var targetTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(targetType); + if (sourceTypeNamedTypeReference != targetTypeNamedTypeReference) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + + var sourceTypeArguments = sourceType.getTypeArguments(); + var targetTypeArguments = targetType.getTypeArguments(); + + if (!sourceTypeArguments && !targetTypeArguments) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + } + + if (!(sourceTypeArguments && targetTypeArguments) || sourceTypeArguments.length != targetTypeArguments.length) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + + for (var i = 0; i < sourceTypeArguments.length; i++) { + if (!this.typesAreIdentical(sourceTypeArguments[i], targetTypeArguments[i])) { + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, false); + return false; + } + } + } + + this.identicalCache.setValueAt(sourceType.pullSymbolID, targetType.pullSymbolID, true); + return true; + }; + + PullTypeResolver.prototype.sourcePropertyIsRelatableToTargetProperty = function (source, target, sourceProp, targetProp, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetPropIsPrivate = targetProp.anyDeclHasFlag(2 /* Private */); + var sourcePropIsPrivate = sourceProp.anyDeclHasFlag(2 /* Private */); + + if (targetPropIsPrivate != sourcePropIsPrivate) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (targetPropIsPrivate) { + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_public_in_type_1_is_defined_as_private_in_type_2, [targetProp.getScopedNameEx().toString(), sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol)])); + } else { + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Property_0_defined_as_private_in_type_1_is_defined_as_public_in_type_2, [targetProp.getScopedNameEx().toString(), sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol)])); + } + comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */; + } + return false; + } else if (sourcePropIsPrivate && targetPropIsPrivate) { + var targetDecl = targetProp.getDeclarations()[0]; + var sourceDecl = sourceProp.getDeclarations()[0]; + + if (!targetDecl.isEqual(sourceDecl)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + + comparisonInfo.flags |= 128 /* InconsistantPropertyAccesibility */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_0_and_1_define_property_2_as_private, [sourceProp.getContainer().toString(enclosingSymbol), targetProp.getContainer().toString(enclosingSymbol), targetProp.getScopedNameEx().toString()])); + } + + return false; + } + } + + this.resolveDeclaredSymbol(sourceProp, context); + + var sourcePropType = sourceProp.type; + var targetPropType = targetProp.type; + + if (comparisonCache.valueAt(sourcePropType.pullSymbolID, targetPropType.pullSymbolID)) { + return true; + } + + var comparisonInfoPropertyTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoPropertyTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + if (this.sourceIsRelatableToTargetInEnclosingTypes(sourcePropType, targetPropType, source, target, assignableTo, comparisonCache, ast, context, comparisonInfoPropertyTypeCheck, isComparingInstantiatedSignatures)) { + return true; + } + + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + comparisonInfo.flags |= 32 /* IncompatiblePropertyTypes */; + var message; + if (comparisonInfoPropertyTypeCheck && comparisonInfoPropertyTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible_NL_3, [targetProp.getScopedNameEx().toString(), source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoPropertyTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_incompatible, [targetProp.getScopedNameEx().toString(), source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(message); + } + + return false; + }; + + PullTypeResolver.prototype.sourceCallSignaturesAreRelatableToTargetCallSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetCallSigs = target.getCallSignatures(); + + if (targetCallSigs.length) { + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + var sourceCallSigs = source.getCallSignatures(); + if (!this.signatureGroupIsRelatableToTarget(sourceCallSigs, targetCallSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (sourceCallSigs.length && targetCallSigs.length) { + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + } else { + var hasSig = targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + var lacksSig = !targetCallSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_call_signature_but_type_1_lacks_one, [hasSig, lacksSig]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.sourceConstructSignaturesAreRelatableToTargetConstructSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetConstructSigs = target.getConstructSignatures(); + if (targetConstructSigs.length) { + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + var sourceConstructSigs = source.getConstructSignatures(); + if (!this.signatureGroupIsRelatableToTarget(sourceConstructSigs, targetConstructSigs, assignableTo, comparisonCache, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + var message; + if (sourceConstructSigs.length && targetConstructSigs.length) { + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Construct_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + } else { + var hasSig = targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + var lacksSig = !targetConstructSigs.length ? target.toString(enclosingSymbol) : source.toString(enclosingSymbol); + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_0_requires_a_construct_signature_but_type_1_lacks_one, [hasSig, lacksSig]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.sourceIndexSignaturesAreRelatableToTargetIndexSignatures = function (source, target, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var targetIndexSigs = this.getBothKindsOfIndexSignatures(target, context); + var targetStringSig = targetIndexSigs.stringSignature; + var targetNumberSig = targetIndexSigs.numericSignature; + + if (targetStringSig || targetNumberSig) { + var sourceIndexSigs = this.getBothKindsOfIndexSignatures(source, context); + var sourceStringSig = sourceIndexSigs.stringSignature; + var sourceNumberSig = sourceIndexSigs.numericSignature; + + var comparable = true; + var comparisonInfoSignatuesTypeCheck = null; + if (comparisonInfo && !comparisonInfo.onlyCaptureFirstError) { + comparisonInfoSignatuesTypeCheck = new TypeComparisonInfo(comparisonInfo); + } + + if (targetStringSig) { + if (sourceStringSig) { + comparable = this.signatureIsAssignableToTarget(sourceStringSig, targetStringSig, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures); + } else { + comparable = false; + } + } + + if (comparable && targetNumberSig) { + if (sourceNumberSig) { + comparable = this.signatureIsAssignableToTarget(sourceNumberSig, targetNumberSig, ast, context, comparisonInfoSignatuesTypeCheck, isComparingInstantiatedSignatures); + } else if (sourceStringSig) { + comparable = this.sourceIsAssignableToTarget(sourceStringSig.returnType, targetNumberSig.returnType, ast, context, comparisonInfoSignatuesTypeCheck); + } else { + comparable = false; + } + } + + if (!comparable) { + if (comparisonInfo) { + var message; + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (comparisonInfoSignatuesTypeCheck && comparisonInfoSignatuesTypeCheck.message) { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfoSignatuesTypeCheck.message]); + } else { + message = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Index_signatures_of_types_0_and_1_are_incompatible, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)]); + } + comparisonInfo.flags |= 4 /* IncompatibleSignatures */; + comparisonInfo.addMessage(message); + } + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.signatureGroupIsRelatableToTarget = function (sourceSG, targetSG, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + if (sourceSG === targetSG) { + return true; + } + + if (!(sourceSG.length && targetSG.length)) { + return false; + } + + var mSig = null; + var nSig = null; + var foundMatch = false; + + var targetExcludeDefinition = targetSG.length > 1; + var sourceExcludeDefinition = sourceSG.length > 1; + for (var iMSig = 0; iMSig < targetSG.length; iMSig++) { + mSig = targetSG[iMSig]; + + if (mSig.isStringConstantOverloadSignature() || (targetExcludeDefinition && mSig.isDefinition())) { + continue; + } + + for (var iNSig = 0; iNSig < sourceSG.length; iNSig++) { + nSig = sourceSG[iNSig]; + + if (nSig.isStringConstantOverloadSignature() || (sourceExcludeDefinition && nSig.isDefinition())) { + continue; + } + + if (this.signatureIsRelatableToTarget(nSig, mSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + foundMatch = true; + break; + } + } + + if (foundMatch) { + foundMatch = false; + continue; + } + return false; + } + + return true; + }; + + PullTypeResolver.prototype.signatureIsRelatableToTarget = function (sourceSig, targetSig, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) { + var sourceParameters = sourceSig.parameters; + var targetParameters = targetSig.parameters; + + if (!sourceParameters || !targetParameters) { + return false; + } + + var targetVarArgCount = targetSig.nonOptionalParamCount; + var sourceVarArgCount = sourceSig.nonOptionalParamCount; + + if (sourceVarArgCount > targetVarArgCount) { + if (comparisonInfo) { + comparisonInfo.flags |= 3 /* SourceSignatureHasTooManyParameters */; + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Call_signature_expects_0_or_fewer_parameters, [targetVarArgCount])); + } + return false; + } + + if (sourceSig.isGeneric()) { + sourceSig = this.instantiateSignatureInContext(sourceSig, targetSig, context); + + if (!sourceSig) { + return false; + } else { + sourceParameters = sourceSig.parameters; + } + } + + comparisonCache.setValueAt(sourceSig.pullSymbolID, targetSig.pullSymbolID, false); + + var sourceReturnType = sourceSig.returnType; + var targetReturnType = targetSig.returnType; + + if (targetReturnType != this.semanticInfoChain.voidTypeSymbol) { + if (!this.sourceIsRelatableToTargetInEnclosingTypes(sourceReturnType, targetReturnType, sourceSig.functionType, targetSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures)) { + if (comparisonInfo) { + comparisonInfo.flags |= 16 /* IncompatibleReturnTypes */; + } + + return false; + } + } + + var len = (sourceVarArgCount < targetVarArgCount && (sourceSig.hasVarArgs || (sourceParameters.length > sourceVarArgCount))) ? targetVarArgCount : sourceVarArgCount; + + if (!len) { + len = (sourceParameters.length < targetParameters.length) ? sourceParameters.length : targetParameters.length; + } + + var sourceParamType = null; + var targetParamType = null; + var sourceParamName = ""; + var targetParamName = ""; + + for (var iSource = 0, iTarget = 0; iSource < len; iSource++, iTarget++) { + if (iSource < sourceParameters.length && (!sourceSig.hasVarArgs || iSource < sourceVarArgCount)) { + sourceParamType = sourceParameters[iSource].type; + sourceParamName = sourceParameters[iSource].name; + } else if (iSource === sourceVarArgCount) { + sourceParamType = sourceParameters[iSource].type; + if (sourceParamType.isArrayNamedTypeReference()) { + sourceParamType = sourceParamType.getElementType(); + } + sourceParamName = sourceParameters[iSource].name; + } + + if (iTarget < targetParameters.length && !targetSig.hasVarArgs && (!targetVarArgCount || (iTarget < targetVarArgCount))) { + targetParamType = targetParameters[iTarget].type; + targetParamName = targetParameters[iTarget].name; + } else if (targetSig.hasVarArgs && iTarget === targetVarArgCount) { + targetParamType = targetParameters[iTarget].type; + + if (targetParamType.isArrayNamedTypeReference()) { + targetParamType = targetParamType.getElementType(); + } + targetParamName = targetParameters[iTarget].name; + } + + if (!(this.sourceIsRelatableToTargetInEnclosingTypes(sourceParamType, targetParamType, sourceSig.functionType, targetSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures) || this.sourceIsRelatableToTargetInEnclosingTypes(targetParamType, sourceParamType, targetSig.functionType, sourceSig.functionType, assignableTo, comparisonCache, ast, context, comparisonInfo, isComparingInstantiatedSignatures))) { + if (comparisonInfo) { + comparisonInfo.flags |= 64 /* IncompatibleParameterTypes */; + } + + return false; + } + } + + return true; + }; + + PullTypeResolver.prototype.resolveOverloads = function (application, group, haveTypeArgumentsAtCallSite, context, diagnostics) { + var _this = this; + var hasOverloads = group.length > 1; + var comparisonInfo = new TypeComparisonInfo(); + var args = application.argumentList ? application.argumentList.arguments : null; + + var initialCandidates = TypeScript.ArrayUtilities.where(group, function (signature) { + if (hasOverloads && signature.isDefinition()) { + return false; + } + + if (haveTypeArgumentsAtCallSite && !signature.isGeneric()) { + return false; + } + + return _this.overloadHasCorrectArity(signature, args); + }); + + var firstAssignableButNotSupertypeSignature = null; + var firstAssignableWithProvisionalErrorsSignature = null; + + for (var i = 0; i < initialCandidates.length; i++) { + var applicability = this.overloadIsApplicable(initialCandidates[i], args, context, comparisonInfo); + if (applicability === 3 /* Subtype */) { + return initialCandidates[i]; + } else if (applicability === 2 /* AssignableWithNoProvisionalErrors */ && !firstAssignableButNotSupertypeSignature) { + firstAssignableButNotSupertypeSignature = initialCandidates[i]; + } else if (applicability === 1 /* AssignableButWithProvisionalErrors */ && !firstAssignableWithProvisionalErrorsSignature) { + firstAssignableWithProvisionalErrorsSignature = initialCandidates[i]; + } + } + + if (firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature) { + return firstAssignableButNotSupertypeSignature || firstAssignableWithProvisionalErrorsSignature; + } else { + var target = this.getCallTargetErrorSpanAST(application); + if (comparisonInfo.message) { + diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target_NL_0, [comparisonInfo.message])); + } else { + diagnostics.push(this.semanticInfoChain.diagnosticFromAST(target, TypeScript.DiagnosticCode.Supplied_parameters_do_not_match_any_signature_of_call_target, null)); + } + } + + return null; + }; + + PullTypeResolver.prototype.getCallTargetErrorSpanAST = function (callEx) { + return (callEx.expression.kind() === 212 /* MemberAccessExpression */) ? callEx.expression.name : callEx.expression; + }; + + PullTypeResolver.prototype.overloadHasCorrectArity = function (signature, args) { + if (args == null) { + return signature.nonOptionalParamCount === 0; + } + + var numberOfArgs = (args.nonSeparatorCount() && args.nonSeparatorCount() === args.separatorCount()) ? args.separatorCount() + 1 : args.nonSeparatorCount(); + if (numberOfArgs < signature.nonOptionalParamCount) { + return false; + } + if (!signature.hasVarArgs && numberOfArgs > signature.parameters.length) { + return false; + } + + return true; + }; + + PullTypeResolver.prototype.overloadIsApplicable = function (signature, args, context, comparisonInfo) { + if (args === null) { + return 3 /* Subtype */; + } + + var isInVarArg = false; + var parameters = signature.parameters; + var paramType = null; + + var overloadApplicability = 3 /* Subtype */; + + for (var i = 0; i < args.nonSeparatorCount(); i++) { + if (!isInVarArg) { + this.resolveDeclaredSymbol(parameters[i], context); + + if (parameters[i].isVarArg) { + paramType = parameters[i].type.getElementType() || this.getNewErrorTypeSymbol(parameters[i].type.getName()); + isInVarArg = true; + } else { + paramType = parameters[i].type; + } + } + + var statusOfCurrentArgument = this.overloadIsApplicableForArgument(paramType, args.nonSeparatorAt(i), i, context, comparisonInfo); + + if (statusOfCurrentArgument === 0 /* NotAssignable */) { + return 0 /* NotAssignable */; + } else if (statusOfCurrentArgument === 1 /* AssignableButWithProvisionalErrors */) { + overloadApplicability = 1 /* AssignableButWithProvisionalErrors */; + } else if (overloadApplicability !== 1 /* AssignableButWithProvisionalErrors */ && statusOfCurrentArgument === 2 /* AssignableWithNoProvisionalErrors */) { + overloadApplicability = 2 /* AssignableWithNoProvisionalErrors */; + } + } + + return overloadApplicability; + }; + + PullTypeResolver.prototype.overloadIsApplicableForArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (paramType.isAny()) { + return 3 /* Subtype */; + } else if (paramType.isError()) { + return 1 /* AssignableButWithProvisionalErrors */; + } else if (arg.kind() === 219 /* SimpleArrowFunctionExpression */) { + var simpleArrowFunction = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, null, TypeScript.Parameters.fromIdentifier(simpleArrowFunction.identifier), null, simpleArrowFunction.block, simpleArrowFunction.expression, argIndex, context, comparisonInfo); + } else if (arg.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + var arrowFunction = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, arrowFunction.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(arrowFunction.callSignature.parameterList), TypeScript.getType(arrowFunction), arrowFunction.block, arrowFunction.expression, argIndex, context, comparisonInfo); + } else if (arg.kind() === 222 /* FunctionExpression */) { + var functionExpression = arg; + return this.overloadIsApplicableForAnyFunctionExpressionArgument(paramType, arg, functionExpression.callSignature.typeParameterList, TypeScript.Parameters.fromParameterList(functionExpression.callSignature.parameterList), TypeScript.getType(functionExpression), functionExpression.block, null, argIndex, context, comparisonInfo); + } else if (arg.kind() === 215 /* ObjectLiteralExpression */) { + return this.overloadIsApplicableForObjectLiteralArgument(paramType, arg, argIndex, context, comparisonInfo); + } else if (arg.kind() === 214 /* ArrayLiteralExpression */) { + return this.overloadIsApplicableForArrayLiteralArgument(paramType, arg, argIndex, context, comparisonInfo); + } else { + return this.overloadIsApplicableForOtherArgument(paramType, arg, argIndex, context, comparisonInfo); + } + }; + + PullTypeResolver.prototype.overloadIsApplicableForAnyFunctionExpressionArgument = function (paramType, arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, argIndex, context, comparisonInfo) { + if (this.cachedFunctionInterfaceType() && paramType === this.cachedFunctionInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + + var argSym = this.resolveAnyFunctionExpression(arg, typeParameters, parameters, returnTypeAnnotation, block, bodyExpression, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForObjectLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (this.cachedObjectInterfaceType() && paramType === this.cachedObjectInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + var argSym = this.resolveObjectLiteralExpression(arg, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForArrayLiteralArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + if (paramType === this.cachedArrayInterfaceType()) { + return 2 /* AssignableWithNoProvisionalErrors */; + } + + context.pushContextualType(paramType, true, null); + var argSym = this.resolveArrayLiteralExpression(arg, true, context); + + var applicabilityStatus = this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + + context.popContextualType(); + + return applicabilityStatus; + }; + + PullTypeResolver.prototype.overloadIsApplicableForOtherArgument = function (paramType, arg, argIndex, context, comparisonInfo) { + var argSym = this.resolveAST(arg, false, context); + + if (argSym.type.isAlias()) { + var aliasSym = argSym.type; + argSym = aliasSym.getExportAssignedTypeSymbol(); + } + + comparisonInfo.stringConstantVal = arg; + return this.overloadIsApplicableForArgumentHelper(paramType, argSym.type, argIndex, comparisonInfo, arg, context); + }; + + PullTypeResolver.prototype.overloadIsApplicableForArgumentHelper = function (paramType, argSym, argumentIndex, comparisonInfo, arg, context) { + var tempComparisonInfo = new TypeComparisonInfo(); + tempComparisonInfo.stringConstantVal = comparisonInfo.stringConstantVal; + if (!context.hasProvisionalErrors() && this.sourceIsSubtypeOfTarget(argSym.type, paramType, arg, context, tempComparisonInfo)) { + return 3 /* Subtype */; + } + + if (this.sourceIsAssignableToTarget(argSym.type, paramType, arg, context, comparisonInfo.message ? tempComparisonInfo : comparisonInfo)) { + return context.hasProvisionalErrors() ? 1 /* AssignableButWithProvisionalErrors */ : 2 /* AssignableWithNoProvisionalErrors */; + } + + if (!comparisonInfo.message) { + var enclosingSymbol = this.getEnclosingSymbolForAST(arg); + comparisonInfo.addMessage(TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Could_not_apply_type_0_to_argument_1_which_is_of_type_2, [paramType.toString(enclosingSymbol), (argumentIndex + 1), argSym.getTypeName(enclosingSymbol)])); + } + + return 0 /* NotAssignable */; + }; + + PullTypeResolver.prototype.inferArgumentTypesForSignature = function (signature, argContext, comparisonInfo, context) { + var cxt = null; + + var parameters = signature.parameters; + var typeParameters = signature.getTypeParameters(); + + var parameterType = null; + var argCount = argContext.getInferenceArgumentCount(); + + for (var i = 0; i < typeParameters.length; i++) { + argContext.addInferenceRoot(typeParameters[i]); + } + + for (var i = 0; i < argCount; i++) { + if (i >= parameters.length) { + break; + } + + parameterType = parameters[i].type; + + if (signature.hasVarArgs && (i >= signature.nonOptionalParamCount - 1) && parameterType.isArrayNamedTypeReference()) { + parameterType = parameterType.getElementType(); + } + + var inferenceCandidates = argContext.getInferenceCandidates(); + + if (inferenceCandidates.length) { + for (var j = 0; j < inferenceCandidates.length; j++) { + argContext.resetRelationshipCache(); + var substitutions = inferenceCandidates[j]; + + context.pushContextualType(parameterType, true, substitutions); + + this.relateTypeToTypeParameters(argContext.getArgumentTypeSymbolAtIndex(i, context), parameterType, false, argContext, context); + + cxt = context.popContextualType(); + } + } else { + context.pushContextualType(parameterType, true, []); + + this.relateTypeToTypeParameters(argContext.getArgumentTypeSymbolAtIndex(i, context), parameterType, false, argContext, context); + + cxt = context.popContextualType(); + } + } + + var inferenceResults = argContext.inferArgumentTypes(this, context); + + if (inferenceResults.unfit) { + return null; + } + + var resultTypes = []; + + for (var i = 0; i < typeParameters.length; i++) { + for (var j = 0; j < inferenceResults.results.length; j++) { + if ((inferenceResults.results[j].param == typeParameters[i]) && inferenceResults.results[j].type) { + resultTypes[resultTypes.length] = inferenceResults.results[j].type; + break; + } + } + } + + if (!argCount && !resultTypes.length && typeParameters.length) { + for (var i = 0; i < typeParameters.length; i++) { + resultTypes[resultTypes.length] = this.semanticInfoChain.emptyTypeSymbol; + } + } else if (resultTypes.length < typeParameters.length) { + for (var i = resultTypes.length; i < typeParameters.length; i++) { + resultTypes[i] = this.semanticInfoChain.emptyTypeSymbol; + } + } + + var inferringAtCallExpression = argContext.argumentASTs && argContext.argumentASTs.parent && argContext.argumentASTs.parent.kind() === 226 /* ArgumentList */ && (argContext.argumentASTs.parent.parent.kind() === 213 /* InvocationExpression */ || argContext.argumentASTs.parent.parent.kind() === 216 /* ObjectCreationExpression */); + + if (inferringAtCallExpression) { + if (!this.typeParametersAreInScopeAtArgumentList(typeParameters, argContext.argumentASTs)) { + for (var i = 0; i < resultTypes.length; i++) { + if (resultTypes[i].wrapsSomeTypeParameter(argContext.candidateCache)) { + resultTypes[i] = this.semanticInfoChain.emptyTypeSymbol; + } + } + } + } + + return resultTypes; + }; + + PullTypeResolver.prototype.typeParametersAreInScopeAtArgumentList = function (typeParameters, args) { + var enclosingDecl = this.getEnclosingDeclForAST(args); + var typeParameterParentDecl = typeParameters[0].getDeclarations()[0].getParentDecl(); + return enclosingDecl.getParentPath().indexOf(typeParameterParentDecl) > -1; + }; + + PullTypeResolver.prototype.relateTypeToTypeParametersInEnclosingType = function (expressionType, parameterType, expressionTypeEnclosingType, parameterTypeEnclosingType, shouldFix, argContext, context) { + if (expressionType && parameterType) { + var expressionTypeGenerativeTypeClassification = expressionTypeEnclosingType ? expressionType.getGenerativeTypeClassification(expressionTypeEnclosingType) : 0 /* Unknown */; + var parameterTypeGenerativeTypeClassification = parameterTypeEnclosingType ? parameterType.getGenerativeTypeClassification(parameterTypeEnclosingType) : 0 /* Unknown */; + if (expressionTypeGenerativeTypeClassification == 3 /* InfinitelyExpanding */ || parameterTypeGenerativeTypeClassification == 3 /* InfinitelyExpanding */) { + this.relateInifinitelyExpandingTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + return; + } + } + this.relateTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.relateTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + if (!expressionType || !parameterType) { + return; + } + + if (expressionType.isError()) { + expressionType = this.semanticInfoChain.anyTypeSymbol; + } + + if (parameterType.isTypeParameter()) { + argContext.addCandidateForInference(parameterType, expressionType, shouldFix); + return; + } + + var parameterDeclarations = parameterType.getDeclarations(); + var expressionDeclarations = expressionType.getDeclarations(); + + if (!parameterType.isArrayNamedTypeReference() && parameterDeclarations.length && expressionDeclarations.length && !(parameterType.isTypeParameter() || expressionType.isTypeParameter()) && (parameterDeclarations[0].isEqual(expressionDeclarations[0]) || (expressionType.isGeneric() && parameterType.isGeneric() && this.sourceIsSubtypeOfTarget(this.instantiateTypeToAny(expressionType, context), this.instantiateTypeToAny(parameterType, context), null, context, null))) && expressionType.isGeneric()) { + this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + } + + if (expressionType.isArrayNamedTypeReference() && parameterType.isArrayNamedTypeReference()) { + this.relateArrayTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + + return; + } + + this.relateObjectTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.relateTypeArgumentsOfTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + var typeParameters = parameterType.getTypeArgumentsOrTypeParameters(); + var typeArguments = expressionType.getTypeArguments(); + + if (!typeArguments) { + typeParameters = parameterType.getTypeArguments(); + typeArguments = expressionType.getTypeArgumentsOrTypeParameters(); + } + + if (typeParameters && typeArguments && typeParameters.length === typeArguments.length) { + for (var i = 0; i < typeParameters.length; i++) { + if (typeArguments[i] != typeParameters[i]) { + this.relateTypeToTypeParameters(typeArguments[i], typeParameters[i], true, argContext, context); + } + } + } + }; + + PullTypeResolver.prototype.relateInifinitelyExpandingTypeToTypeParameters = function (expressionType, parameterType, shouldFix, argContext, context) { + if (!expressionType || !parameterType) { + return; + } + + var expressionTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(expressionType); + var parameterTypeNamedTypeReference = TypeScript.PullHelpers.getRootType(parameterType); + if (expressionTypeNamedTypeReference != parameterTypeNamedTypeReference) { + return; + } + + var expressionTypeTypeArguments = expressionType.getTypeArguments(); + var parameterTypeParameters = parameterType.getTypeParameters(); + + if (expressionTypeTypeArguments && parameterTypeParameters && expressionTypeTypeArguments.length === parameterTypeParameters.length) { + for (var i = 0; i < expressionTypeTypeArguments.length; i++) { + this.relateTypeArgumentsOfTypeToTypeParameters(expressionType, parameterType, shouldFix, argContext, context); + } + } + }; + + PullTypeResolver.prototype.relateFunctionSignatureToTypeParameters = function (expressionSignature, parameterSignature, argContext, context) { + var expressionParams = expressionSignature.parameters; + var expressionReturnType = expressionSignature.returnType; + + var parameterParams = parameterSignature.parameters; + var parameterReturnType = parameterSignature.returnType; + + var len = parameterParams.length < expressionParams.length ? parameterParams.length : expressionParams.length; + + for (var i = 0; i < len; i++) { + this.relateTypeToTypeParametersInEnclosingType(expressionParams[i].type, parameterParams[i].type, expressionSignature.functionType, parameterSignature.functionType, true, argContext, context); + } + + this.relateTypeToTypeParametersInEnclosingType(expressionReturnType, parameterReturnType, expressionSignature.functionType, parameterSignature.functionType, false, argContext, context); + }; + + PullTypeResolver.prototype.relateObjectTypeToTypeParameters = function (objectType, parameterType, shouldFix, argContext, context) { + var parameterTypeMembers = parameterType.getMembers(); + var parameterSignatures; + + var objectMember; + var objectSignatures; + + if (argContext.alreadyRelatingTypes(objectType, parameterType)) { + return; + } + + var objectTypeArguments = objectType.getTypeArguments(); + var parameterTypeParameters = parameterType.getTypeParameters(); + + if (objectTypeArguments) { + if (objectTypeArguments.length === parameterTypeParameters.length) { + for (var i = 0; i < objectTypeArguments.length; i++) { + argContext.addCandidateForInference(parameterTypeParameters[i], objectTypeArguments[i], shouldFix); + } + } else if (parameterType == this.semanticInfoChain.anyTypeSymbol) { + for (var i = 0; i < objectTypeArguments.length; i++) { + this.relateTypeToTypeParameters(parameterType, objectTypeArguments[i], shouldFix, argContext, context); + } + } + } + + for (var i = 0; i < parameterTypeMembers.length; i++) { + objectMember = this.getMemberSymbol(parameterTypeMembers[i].name, 68147712 /* SomeValue */, objectType); + if (objectMember) { + this.relateTypeToTypeParametersInEnclosingType(objectMember.type, parameterTypeMembers[i].type, objectType, parameterType, shouldFix, argContext, context); + } + } + + parameterSignatures = parameterType.getCallSignatures(); + objectSignatures = objectType.getCallSignatures(); + + if ((parameterSignatures.length == 1) && (objectSignatures.length == 1) && !objectSignatures[0].isGeneric() && (parameterSignatures[0].nonOptionalParamCount >= objectSignatures[0].nonOptionalParamCount)) { + this.relateFunctionSignatureToTypeParameters(objectSignatures[0], parameterSignatures[0], argContext, context); + } + + parameterSignatures = parameterType.getConstructSignatures(); + objectSignatures = objectType.getConstructSignatures(); + + if ((parameterSignatures.length == 1) && (objectSignatures.length == 1) && !objectSignatures[0].isGeneric() && (parameterSignatures[0].nonOptionalParamCount >= objectSignatures[0].nonOptionalParamCount)) { + this.relateFunctionSignatureToTypeParameters(objectSignatures[0], parameterSignatures[0], argContext, context); + } + + var parameterIndexSignatures = this.getBothKindsOfIndexSignatures(parameterType, context); + var objectIndexSignatures = this.getBothKindsOfIndexSignatures(objectType, context); + + if (parameterIndexSignatures.stringSignature && objectIndexSignatures.stringSignature) { + this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.stringSignature, parameterIndexSignatures.stringSignature, argContext, context); + } + if (parameterIndexSignatures.numericSignature && objectIndexSignatures.numericSignature) { + this.relateFunctionSignatureToTypeParameters(objectIndexSignatures.numericSignature, parameterIndexSignatures.numericSignature, argContext, context); + } + }; + + PullTypeResolver.prototype.relateArrayTypeToTypeParameters = function (argArrayType, parameterArrayType, shouldFix, argContext, context) { + var argElement = argArrayType.getElementType(); + var paramElement = parameterArrayType.getElementType(); + + this.relateTypeToTypeParameters(argElement, paramElement, shouldFix, argContext, context); + }; + + PullTypeResolver.prototype.instantiateTypeToAny = function (typeToSpecialize, context) { + var typeParameters = typeToSpecialize.getTypeParameters(); + + if (!typeParameters.length) { + return typeToSpecialize; + } + + var typeArguments = null; + + if (!this._cachedAnyTypeArgs) { + this._cachedAnyTypeArgs = [ + [this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol], + [this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol, this.semanticInfoChain.anyTypeSymbol] + ]; + } + + if (typeParameters.length < this._cachedAnyTypeArgs.length) { + typeArguments = this._cachedAnyTypeArgs[typeParameters.length - 1]; + } else { + typeArguments = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeArguments[typeArguments.length] = this.semanticInfoChain.anyTypeSymbol; + } + } + + var type = this.createInstantiatedType(typeToSpecialize, typeArguments); + + return type; + }; + + PullTypeResolver.typeCheck = function (compilationSettings, semanticInfoChain, document) { + var sourceUnit = document.sourceUnit(); + + var resolver = semanticInfoChain.getResolver(); + var context = new TypeScript.PullTypeResolutionContext(resolver, true, sourceUnit.fileName()); + + if (resolver.canTypeCheckAST(sourceUnit, context)) { + resolver.resolveAST(sourceUnit, false, context); + resolver.validateVariableDeclarationGroups(semanticInfoChain.getDeclForAST(sourceUnit), context); + + while (resolver.typeCheckCallBacks.length) { + var callBack = resolver.typeCheckCallBacks.pop(); + callBack(context); + } + + resolver.processPostTypeCheckWorkItems(context); + } + }; + + PullTypeResolver.prototype.validateVariableDeclarationGroups = function (enclosingDecl, context) { + var importDeclarationNames = null; + if (enclosingDecl.kind & (4 /* Container */ | 32 /* DynamicModule */ | 1 /* Script */)) { + var childDecls = enclosingDecl.getChildDecls(); + for (var i = 0, n = childDecls.length; i < n; i++) { + var childDecl = childDecls[i]; + if (childDecl.kind === 128 /* TypeAlias */) { + importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject(); + importDeclarationNames[childDecl.name] = true; + } + } + } + + var declGroups = enclosingDecl.getVariableDeclGroups(); + + for (var i = 0, i_max = declGroups.length; i < i_max; i++) { + var firstSymbol = null; + var firstSymbolType = null; + + if (enclosingDecl.kind === 1 /* Script */ && declGroups[i].length) { + var name = declGroups[i][0].name; + var candidateSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 512 /* Variable */, enclosingDecl); + if (candidateSymbol && candidateSymbol.isResolved) { + if (!candidateSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */)) { + firstSymbol = candidateSymbol; + firstSymbolType = candidateSymbol.type; + } + } + + var importSymbol = this.semanticInfoChain.findTopLevelSymbol(name, 128 /* TypeAlias */, null); + if (importSymbol && importSymbol.isAlias()) { + importDeclarationNames = importDeclarationNames || TypeScript.createIntrinsicsObject(); + } + } + + for (var j = 0, j_max = declGroups[i].length; j < j_max; j++) { + var decl = declGroups[i][j]; + var boundDeclAST = this.semanticInfoChain.getASTForDecl(decl); + + var name = decl.name; + + if (importDeclarationNames && importDeclarationNames[name]) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Variable_declaration_cannot_have_the_same_name_as_an_import_declaration)); + continue; + } + + var symbol = decl.getSymbol(); + var symbolType = symbol.type; + + if (j === 0 && !firstSymbol) { + firstSymbol = symbol; + firstSymbolType = symbolType; + continue; + } + + if (symbolType && firstSymbolType && symbolType !== firstSymbolType && !this.typesAreIdentical(symbolType, firstSymbolType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(boundDeclAST, TypeScript.DiagnosticCode.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, [symbol.getScopedName(), firstSymbolType.toString(), symbolType.toString()])); + continue; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckFunctionOverloads = function (funcDecl, context, signature, allSignatures) { + if (!signature) { + var functionSignatureInfo = TypeScript.PullHelpers.getSignatureForFuncDecl(this.semanticInfoChain.getDeclForAST(funcDecl)); + signature = functionSignatureInfo.signature; + allSignatures = functionSignatureInfo.allSignatures; + } + var functionDeclaration = this.semanticInfoChain.getDeclForAST(funcDecl); + var funcSymbol = functionDeclaration.getSymbol(); + + var definitionSignature = null; + for (var i = allSignatures.length - 1; i >= 0; i--) { + if (allSignatures[i].isDefinition()) { + definitionSignature = allSignatures[i]; + break; + } + } + + if (!signature.isDefinition()) { + for (var i = 0; i < allSignatures.length; i++) { + if (allSignatures[i] === signature) { + break; + } + + if (this.signaturesAreIdentical(allSignatures[i], signature, false)) { + if (!this.typesAreIdentical(allSignatures[i].returnType, signature.returnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overloads_cannot_differ_only_by_return_type)); + } else if (funcDecl.kind() === 137 /* ConstructorDeclaration */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_constructor_overload_signature)); + } else if (functionDeclaration.kind === 2097152 /* ConstructSignature */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_construct_signature)); + } else if (functionDeclaration.kind === 1048576 /* CallSignature */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_call_signature)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Duplicate_overload_signature_for_0, [funcSymbol.getScopedNameEx().toString()])); + } + + break; + } + } + } + + var isConstantOverloadSignature = signature.isStringConstantOverloadSignature(); + if (isConstantOverloadSignature) { + if (signature.isDefinition()) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_implementation_cannot_use_specialized_type)); + } else { + var foundSubtypeSignature = false; + for (var i = 0; i < allSignatures.length; i++) { + if (allSignatures[i].isDefinition() || allSignatures[i] === signature) { + continue; + } + + if (!allSignatures[i].isResolved) { + this.resolveDeclaredSymbol(allSignatures[i], context); + } + + if (allSignatures[i].isStringConstantOverloadSignature()) { + continue; + } + + if (this.signatureIsSubtypeOfTarget(signature, allSignatures[i], null, context)) { + foundSubtypeSignature = true; + break; + } + } + + if (!foundSubtypeSignature) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Specialized_overload_signature_is_not_subtype_of_any_non_specialized_signature)); + } + } + } else if (definitionSignature && definitionSignature != signature) { + var comparisonInfo = new TypeComparisonInfo(); + + if (!definitionSignature.isResolved) { + this.resolveDeclaredSymbol(definitionSignature, context); + } + + if (!this.signatureIsAssignableToTarget(definitionSignature, signature, funcDecl, context, comparisonInfo)) { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition_NL_0, [comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, TypeScript.DiagnosticCode.Overload_signature_is_not_compatible_with_function_definition)); + } + } + } + + var signatureForVisibilityCheck = definitionSignature; + if (!definitionSignature) { + if (allSignatures[0] === signature) { + return; + } + signatureForVisibilityCheck = allSignatures[0]; + } + + if (funcDecl.kind() !== 137 /* ConstructorDeclaration */ && functionDeclaration.kind !== 2097152 /* ConstructSignature */ && signatureForVisibilityCheck && signature != signatureForVisibilityCheck) { + var errorCode; + + if (signatureForVisibilityCheck.anyDeclHasFlag(2 /* Private */) != signature.anyDeclHasFlag(2 /* Private */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_public_or_private; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(1 /* Exported */) != signature.anyDeclHasFlag(1 /* Exported */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_exported_or_not_exported; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(8 /* Ambient */) != signature.anyDeclHasFlag(8 /* Ambient */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_ambient_or_non_ambient; + } else if (signatureForVisibilityCheck.anyDeclHasFlag(128 /* Optional */) != signature.anyDeclHasFlag(128 /* Optional */)) { + errorCode = TypeScript.DiagnosticCode.Overload_signatures_must_all_be_optional_or_required; + } + + if (errorCode) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(funcDecl, errorCode)); + } + } + }; + + PullTypeResolver.prototype.checkSymbolPrivacy = function (declSymbol, symbol, privacyErrorReporter) { + if (!symbol || symbol.kind === 2 /* Primitive */) { + return; + } + + if (symbol.isType()) { + var typeSymbol = symbol; + var isNamedType = typeSymbol.isNamedTypeSymbol(); + + if (typeSymbol.isArrayNamedTypeReference()) { + this.checkSymbolPrivacy(declSymbol, typeSymbol.getElementType(), privacyErrorReporter); + return; + } + + if (!isNamedType) { + var typeOfSymbol = typeSymbol.getTypeOfSymbol(); + if (typeOfSymbol) { + this.checkSymbolPrivacy(declSymbol, typeOfSymbol, privacyErrorReporter); + return; + } + } + + if (typeSymbol.inSymbolPrivacyCheck) { + return; + } + + typeSymbol.inSymbolPrivacyCheck = true; + + var typars = typeSymbol.getTypeArgumentsOrTypeParameters(); + if (typars) { + for (var i = 0; i < typars.length; i++) { + this.checkSymbolPrivacy(declSymbol, typars[i], privacyErrorReporter); + } + } + + if (!isNamedType) { + var members = typeSymbol.getMembers(); + for (var i = 0; i < members.length; i++) { + this.checkSymbolPrivacy(declSymbol, members[i].type, privacyErrorReporter); + } + + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getCallSignatures(), privacyErrorReporter); + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getConstructSignatures(), privacyErrorReporter); + this.checkTypePrivacyOfSignatures(declSymbol, typeSymbol.getIndexSignatures(), privacyErrorReporter); + } else if (typeSymbol.kind == 8192 /* TypeParameter */) { + this.checkSymbolPrivacy(declSymbol, typeSymbol.getConstraint(), privacyErrorReporter); + } + + typeSymbol.inSymbolPrivacyCheck = false; + + if (!isNamedType) { + return; + } + } + + if (declSymbol.isExternallyVisible()) { + var symbolIsVisible = symbol.isExternallyVisible(); + + if (symbolIsVisible && symbol.kind != 8192 /* TypeParameter */) { + var symbolPath = symbol.pathToRoot(); + var declSymbolPath = declSymbol.pathToRoot(); + + if (symbolPath[symbolPath.length - 1].kind === 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1].kind == 32 /* DynamicModule */ && declSymbolPath[declSymbolPath.length - 1] != symbolPath[symbolPath.length - 1]) { + symbolIsVisible = false; + var declSymbolScope = declSymbolPath[declSymbolPath.length - 1]; + for (var i = symbolPath.length - 1; i >= 0; i--) { + var aliasSymbols = symbolPath[i].getExternalAliasedSymbols(declSymbolScope); + if (aliasSymbols) { + symbolIsVisible = true; + aliasSymbols[0].setTypeUsedExternally(true); + break; + } + } + symbol = symbolPath[symbolPath.length - 1]; + } + } else if (symbol.kind == 128 /* TypeAlias */) { + var aliasSymbol = symbol; + symbolIsVisible = true; + aliasSymbol.setTypeUsedExternally(true); + } + + if (!symbolIsVisible) { + privacyErrorReporter(symbol); + } + } + }; + + PullTypeResolver.prototype.checkTypePrivacyOfSignatures = function (declSymbol, signatures, privacyErrorReporter) { + for (var i = 0; i < signatures.length; i++) { + var signature = signatures[i]; + if (signatures.length > 1 && signature.isDefinition()) { + continue; + } + + var typeParams = signature.getTypeParameters(); + for (var j = 0; j < typeParams.length; j++) { + this.checkSymbolPrivacy(declSymbol, typeParams[j], privacyErrorReporter); + } + + var params = signature.parameters; + for (var j = 0; j < params.length; j++) { + var paramType = params[j].type; + this.checkSymbolPrivacy(declSymbol, paramType, privacyErrorReporter); + } + + var returnType = signature.returnType; + this.checkSymbolPrivacy(declSymbol, returnType, privacyErrorReporter); + } + }; + + PullTypeResolver.prototype.typeParameterOfTypeDeclarationPrivacyErrorReporter = function (classOrInterface, indexOfTypeParameter, typeParameter, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + var messageCode; + + var typeParameters = classOrInterface.kind() === 131 /* ClassDeclaration */ ? classOrInterface.typeParameterList : classOrInterface.typeParameterList; + + var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(indexOfTypeParameter); + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_is_using_inaccessible_module_1; + } + } else { + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_interface_has_or_is_using_private_type_1; + } + } + + var messageArguments = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.baseListPrivacyErrorReporter = function (classOrInterface, declSymbol, baseAst, isExtendedType, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(classOrInterface); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + var messageCode; + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + if (isExtendedType) { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_class_from_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_interface_from_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_interface_from_inaccessible_module_1; + } + } else { + if (classOrInterface.kind() === 131 /* ClassDeclaration */) { + if (isExtendedType) { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_extends_private_class_1; + } else { + messageCode = TypeScript.DiagnosticCode.Exported_class_0_implements_private_interface_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_interface_0_extends_private_interface_1; + } + } + + var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseAst, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.variablePrivacyErrorReporter = function (declAST, declSymbol, symbol, context) { + var typeSymbol = symbol; + var enclosingDecl = this.getEnclosingDecl(declSymbol.getDeclarations()[0]); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isProperty = declSymbol.kind === 4096 /* Property */; + var isPropertyOfClass = false; + var declParent = declSymbol.getContainer(); + if (declParent && (declParent.kind === 8 /* Class */ || declParent.kind === 32768 /* ConstructorMethod */)) { + isPropertyOfClass = true; + } + + var messageCode; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (declSymbol.anyDeclHasFlag(16 /* Static */)) { + messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_is_using_inaccessible_module_1; + } else if (isProperty) { + if (isPropertyOfClass) { + messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_is_using_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_variable_0_is_using_inaccessible_module_1; + } + } else { + if (declSymbol.anyDeclHasFlag(16 /* Static */)) { + messageCode = TypeScript.DiagnosticCode.Public_static_property_0_of_exported_class_has_or_is_using_private_type_1; + } else if (isProperty) { + if (isPropertyOfClass) { + messageCode = TypeScript.DiagnosticCode.Public_property_0_of_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Property_0_of_exported_interface_has_or_is_using_private_type_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.Exported_variable_0_has_or_is_using_private_type_1; + } + } + + var messageArguments = [declSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments)); + }; + + PullTypeResolver.prototype.checkFunctionTypePrivacy = function (funcDeclAST, isStatic, typeParameters, parameters, returnTypeAnnotation, block, context) { + var _this = this; + if (funcDeclAST.kind() === 222 /* FunctionExpression */ || funcDeclAST.kind() === 241 /* FunctionPropertyAssignment */ || (funcDeclAST.kind() === 139 /* GetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */) || (funcDeclAST.kind() === 140 /* SetAccessor */ && funcDeclAST.parent.parent.kind() === 215 /* ObjectLiteralExpression */)) { + return; + } + + var functionDecl = this.semanticInfoChain.getDeclForAST(funcDeclAST); + var functionSymbol = functionDecl.getSymbol(); + ; + var functionSignature; + + var isGetter = funcDeclAST.kind() === 139 /* GetAccessor */; + var isSetter = funcDeclAST.kind() === 140 /* SetAccessor */; + var isIndexSignature = functionDecl.kind === 4194304 /* IndexSignature */; + + if (isGetter || isSetter) { + var accessorSymbol = functionSymbol; + functionSignature = (isGetter ? accessorSymbol.getGetter() : accessorSymbol.getSetter()).type.getCallSignatures()[0]; + } else { + if (!functionSymbol) { + var parentDecl = functionDecl.getParentDecl(); + functionSymbol = parentDecl.getSymbol(); + if (functionSymbol && functionSymbol.isType() && !functionSymbol.isNamedTypeSymbol()) { + return; + } + } else if (functionSymbol.kind == 65536 /* Method */ && !isStatic && !functionSymbol.getContainer().isNamedTypeSymbol()) { + return; + } + functionSignature = functionDecl.getSignatureSymbol(); + } + + if (typeParameters && !isGetter && !isSetter && !isIndexSignature && funcDeclAST.kind() !== 137 /* ConstructorDeclaration */) { + for (var i = 0; i < typeParameters.typeParameters.nonSeparatorCount(); i++) { + var typeParameterAST = typeParameters.typeParameters.nonSeparatorAt(i); + var typeParameter = this.resolveTypeParameterDeclaration(typeParameterAST, context); + this.checkSymbolPrivacy(functionSymbol, typeParameter, function (symbol) { + return _this.functionTypeArgumentArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, typeParameterAST, typeParameter, symbol, context); + }); + } + } + + if (!isGetter && !isIndexSignature) { + var funcParams = functionSignature.parameters; + for (var i = 0; i < funcParams.length; i++) { + this.checkSymbolPrivacy(functionSymbol, funcParams[i].type, function (symbol) { + return _this.functionArgumentTypePrivacyErrorReporter(funcDeclAST, isStatic, parameters, i, funcParams[i], symbol, context); + }); + } + } + + if (!isSetter) { + this.checkSymbolPrivacy(functionSymbol, functionSignature.returnType, function (symbol) { + return _this.functionReturnTypePrivacyErrorReporter(funcDeclAST, isStatic, returnTypeAnnotation, block, functionSignature.returnType, symbol, context); + }); + } + }; + + PullTypeResolver.prototype.functionTypeArgumentArgumentTypePrivacyErrorReporter = function (declAST, isStatic, typeParameterAST, typeParameter, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + var messageCode; + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_is_using_inaccessible_module_1; + } + } else { + if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1; + } + } else { + messageCode = TypeScript.DiagnosticCode.TypeParameter_0_of_exported_function_has_or_is_using_private_type_1; + } + } + + if (messageCode) { + var messageArgs = [typeParameter.getScopedName(enclosingSymbol, false, true), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(typeParameterAST, messageCode, messageArgs)); + } + }; + + PullTypeResolver.prototype.functionArgumentTypePrivacyErrorReporter = function (declAST, isStatic, parameters, argIndex, paramSymbol, symbol, context) { + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + var enclosingSymbol = enclosingDecl ? enclosingDecl.getSymbol() : null; + + var isGetter = declAST.kind() === 139 /* GetAccessor */; + var isSetter = declAST.kind() === 140 /* SetAccessor */; + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingSymbol); + var messageCode; + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (declAST.kind() === 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_is_using_inaccessible_module_1; + } else if (isSetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_is_using_inaccessible_module_1; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_is_using_inaccessible_module_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_is_using_inaccessible_module_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_is_using_inaccessible_module_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_is_using_inaccessible_module_1; + } + } else if (!isGetter) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_is_using_inaccessible_module_1; + } + } else { + if (declAST.kind() === 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_type_1; + } else if (isSetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_type_1; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_type_1; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_type_1; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_type_1; + } else { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_type_1; + } + } else if (!isGetter && decl.kind !== 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Parameter_0_of_exported_function_has_or_is_using_private_type_1; + } + } + + if (messageCode) { + var parameter = parameters.astAt(argIndex); + + var messageArgs = [paramSymbol.getScopedName(enclosingSymbol), typeSymbolName]; + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(parameter, messageCode, messageArgs)); + } + }; + + PullTypeResolver.prototype.functionReturnTypePrivacyErrorReporter = function (declAST, isStatic, returnTypeAnnotation, block, funcReturnType, symbol, context) { + var _this = this; + var decl = this.semanticInfoChain.getDeclForAST(declAST); + var enclosingDecl = this.getEnclosingDecl(decl); + + var isGetter = declAST.kind() === 139 /* GetAccessor */; + var isSetter = declAST.kind() === 140 /* SetAccessor */; + var isMethod = decl.kind === 65536 /* Method */; + var isMethodOfClass = false; + var declParent = decl.getParentDecl(); + if (declParent && (declParent.kind === 8 /* Class */ || isStatic)) { + isMethodOfClass = true; + } + + var messageCode = null; + var typeSymbol = symbol; + var typeSymbolName = typeSymbol.getScopedName(enclosingDecl ? enclosingDecl.getSymbol() : null); + if (typeSymbol.isContainer() && !typeSymbol.isEnum()) { + if (!TypeScript.isQuoted(typeSymbolName)) { + typeSymbolName = "'" + typeSymbolName + "'"; + } + + if (isGetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_is_using_inaccessible_module_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_is_using_inaccessible_module_0; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (decl.kind === 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_is_using_inaccessible_module_0; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_is_using_inaccessible_module_0; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_is_using_inaccessible_module_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_is_using_inaccessible_module_0; + } + } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_is_using_inaccessible_module_0; + } + } else { + if (isGetter) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_type_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_type_0; + } + } else if (decl.kind === 2097152 /* ConstructSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (decl.kind === 1048576 /* CallSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (decl.kind === 4194304 /* IndexSignature */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_type_0; + } else if (isMethod) { + if (isStatic) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_type_0; + } else if (isMethodOfClass) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_public_method_from_exported_class_has_or_is_using_private_type_0; + } else { + messageCode = TypeScript.DiagnosticCode.Return_type_of_method_from_exported_interface_has_or_is_using_private_type_0; + } + } else if (!isSetter && declAST.kind() !== 137 /* ConstructorDeclaration */) { + messageCode = TypeScript.DiagnosticCode.Return_type_of_exported_function_has_or_is_using_private_type_0; + } + } + + if (messageCode) { + var messageArguments = [typeSymbolName]; + var reportOnFuncDecl = false; + + if (returnTypeAnnotation) { + var returnExpressionSymbol = this.resolveTypeReference(returnTypeAnnotation, context); + + if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(returnTypeAnnotation, messageCode, messageArguments)); + } + } + + if (block) { + var reportErrorOnReturnExpressions = function (ast, walker) { + var go = true; + switch (ast.kind()) { + case 129 /* FunctionDeclaration */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + case 222 /* FunctionExpression */: + go = false; + break; + + case 150 /* ReturnStatement */: + var returnStatement = ast; + var returnExpressionSymbol = _this.resolveAST(returnStatement.expression, false, context).type; + + if (TypeScript.PullHelpers.typeSymbolsAreIdentical(returnExpressionSymbol, funcReturnType)) { + context.postDiagnostic(_this.semanticInfoChain.diagnosticFromAST(returnStatement, messageCode, messageArguments)); + } else { + reportOnFuncDecl = true; + } + go = false; + break; + + default: + break; + } + + walker.options.goChildren = go; + return ast; + }; + + TypeScript.getAstWalkerFactory().walk(block, reportErrorOnReturnExpressions); + } + + if (reportOnFuncDecl) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(declAST, messageCode, messageArguments)); + } + } + }; + + PullTypeResolver.prototype.enclosingClassIsDerived = function (classDecl) { + TypeScript.Debug.assert(classDecl.kind === 8 /* Class */); + + var classSymbol = classDecl.getSymbol(); + return classSymbol.getExtendedTypes().length > 0; + }; + + PullTypeResolver.prototype.isSuperInvocationExpression = function (ast) { + if (ast.kind() === 213 /* InvocationExpression */) { + var invocationExpression = ast; + if (invocationExpression.expression.kind() === 50 /* SuperKeyword */) { + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.isSuperInvocationExpressionStatement = function (node) { + if (node && node.kind() === 149 /* ExpressionStatement */) { + var expressionStatement = node; + if (this.isSuperInvocationExpression(expressionStatement.expression)) { + return true; + } + } + return false; + }; + + PullTypeResolver.prototype.getFirstStatementOfBlockOrNull = function (block) { + if (block && block.statements && block.statements.childCount() > 0) { + return block.statements.childAt(0); + } + + return null; + }; + + PullTypeResolver.prototype.superCallMustBeFirstStatementInConstructor = function (constructorDecl) { + TypeScript.Debug.assert(constructorDecl.kind === 32768 /* ConstructorMethod */); + + if (constructorDecl) { + var enclosingClass = constructorDecl.getParentDecl(); + + var classSymbol = enclosingClass.getSymbol(); + if (classSymbol.getExtendedTypes().length === 0) { + return false; + } + + var classMembers = classSymbol.getMembers(); + for (var i = 0, n1 = classMembers.length; i < n1; i++) { + var member = classMembers[i]; + + if (member.kind === 4096 /* Property */) { + var declarations = member.getDeclarations(); + for (var j = 0, n2 = declarations.length; j < n2; j++) { + var declaration = declarations[j]; + var ast = this.semanticInfoChain.getASTForDecl(declaration); + if (ast.kind() === 242 /* Parameter */) { + return true; + } + + if (ast.kind() === 136 /* MemberVariableDeclaration */) { + var variableDeclarator = ast; + if (variableDeclarator.variableDeclarator.equalsValueClause) { + return true; + } + } + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.checkForThisCaptureInArrowFunction = function (expression) { + var enclosingDecl = this.getEnclosingDeclForAST(expression); + + var declPath = enclosingDecl.getParentPath(); + + if (declPath.length) { + var inArrowFunction = false; + for (var i = declPath.length - 1; i >= 0; i--) { + var decl = declPath[i]; + var declKind = decl.kind; + var declFlags = decl.flags; + + if (declKind === 131072 /* FunctionExpression */ && TypeScript.hasFlag(declFlags, 8192 /* ArrowFunction */)) { + inArrowFunction = true; + continue; + } + + if (inArrowFunction) { + if (declKind === 16384 /* Function */ || declKind === 65536 /* Method */ || declKind === 32768 /* ConstructorMethod */ || declKind === 262144 /* GetAccessor */ || declKind === 524288 /* SetAccessor */ || declKind === 131072 /* FunctionExpression */ || declKind === 8 /* Class */ || declKind === 4 /* Container */ || declKind === 32 /* DynamicModule */ || declKind === 1 /* Script */) { + decl.setFlags(decl.flags | 262144 /* MustCaptureThis */); + + if (declKind === 8 /* Class */) { + var constructorSymbol = decl.getSymbol().getConstructorMethod(); + var constructorDecls = constructorSymbol.getDeclarations(); + for (var i = 0; i < constructorDecls.length; i++) { + constructorDecls[i].flags = constructorDecls[i].flags | 262144 /* MustCaptureThis */; + } + } + break; + } + } else if (declKind === 16384 /* Function */ || declKind === 131072 /* FunctionExpression */) { + break; + } + } + } + }; + + PullTypeResolver.prototype.typeCheckMembersAgainstIndexer = function (containerType, containerTypeDecl, context) { + var indexSignatures = this.getBothKindsOfIndexSignatures(containerType, context); + var stringSignature = indexSignatures.stringSignature; + var numberSignature = indexSignatures.numericSignature; + + if (stringSignature || numberSignature) { + var members = containerTypeDecl.getChildDecls(); + for (var i = 0; i < members.length; i++) { + var member = members[i]; + if ((member.name || (member.kind === 4096 /* Property */ && member.name === "")) && member.kind !== 32768 /* ConstructorMethod */ && !TypeScript.hasFlag(member.flags, 16 /* Static */)) { + var memberSymbol = member.getSymbol(); + var relevantSignature = this.determineRelevantIndexerForMember(memberSymbol, numberSignature, stringSignature); + if (relevantSignature) { + var comparisonInfo = new TypeComparisonInfo(); + if (!this.sourceIsSubtypeOfTarget(memberSymbol.type, relevantSignature.returnType, member.ast(), context, comparisonInfo)) { + this.reportErrorThatMemberIsNotSubtypeOfIndexer(memberSymbol, relevantSignature, member.ast(), context, comparisonInfo); + } + } + } + } + } + }; + + PullTypeResolver.prototype.determineRelevantIndexerForMember = function (member, numberIndexSignature, stringIndexSignature) { + if (numberIndexSignature && TypeScript.PullHelpers.isNameNumeric(member.name)) { + return numberIndexSignature; + } else if (stringIndexSignature) { + return stringIndexSignature; + } + + return null; + }; + + PullTypeResolver.prototype.reportErrorThatMemberIsNotSubtypeOfIndexer = function (member, indexSignature, astForError, context, comparisonInfo) { + var enclosingSymbol = this.getEnclosingSymbolForAST(astForError); + if (indexSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol) { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_numerically_named_properties_must_be_subtypes_of_numeric_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)])); + } + } else { + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_subtypes_of_string_indexer_type_0_NL_1, [indexSignature.returnType.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(astForError, TypeScript.DiagnosticCode.All_named_properties_must_be_subtypes_of_string_indexer_type_0, [indexSignature.returnType.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.typeCheckIfTypeMemberPropertyOkToOverride = function (typeSymbol, extendedType, typeMember, extendedTypeMember, enclosingDecl, comparisonInfo) { + if (!typeSymbol.isClass()) { + return true; + } + + var typeMemberKind = typeMember.kind; + var extendedMemberKind = extendedTypeMember.kind; + + if (typeMemberKind === extendedMemberKind) { + return true; + } + + var errorCode; + if (typeMemberKind === 4096 /* Property */) { + if (typeMember.isAccessor()) { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; + } else { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + } + } else if (typeMemberKind === 65536 /* Method */) { + if (extendedTypeMember.isAccessor()) { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } else { + errorCode = TypeScript.DiagnosticCode.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property; + } + } + + var message = TypeScript.getDiagnosticMessage(errorCode, [typeSymbol.toString(), typeMember.getScopedNameEx().toString(), extendedType.toString()]); + comparisonInfo.addMessage(message); + return false; + }; + + PullTypeResolver.prototype.typeCheckIfTypeExtendsType = function (classOrInterface, name, typeSymbol, extendedType, enclosingDecl, context) { + var typeMembers = typeSymbol.getMembers(); + + var comparisonInfo = new TypeComparisonInfo(); + var foundError = false; + var foundError1 = false; + var foundError2 = false; + + for (var i = 0; i < typeMembers.length; i++) { + var propName = typeMembers[i].name; + var extendedTypeProp = extendedType.findMember(propName, true); + if (extendedTypeProp) { + this.resolveDeclaredSymbol(extendedTypeProp, context); + foundError1 = !this.typeCheckIfTypeMemberPropertyOkToOverride(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, enclosingDecl, comparisonInfo); + + if (!foundError1) { + foundError2 = !this.sourcePropertyIsSubtypeOfTargetProperty(typeSymbol, extendedType, typeMembers[i], extendedTypeProp, classOrInterface, context, comparisonInfo); + } + + if (foundError1 || foundError2) { + foundError = true; + break; + } + } + } + + if (!foundError && typeSymbol.hasOwnCallSignatures()) { + foundError = !this.sourceCallSignaturesAreSubtypeOfTargetCallSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.hasOwnConstructSignatures()) { + foundError = !this.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.hasOwnIndexSignatures()) { + foundError = !this.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures(typeSymbol, extendedType, classOrInterface, context, comparisonInfo); + } + + if (!foundError && typeSymbol.isClass()) { + var typeConstructorType = typeSymbol.getConstructorMethod().type; + var typeConstructorTypeMembers = typeConstructorType.getMembers(); + if (typeConstructorTypeMembers.length) { + var extendedConstructorType = extendedType.getConstructorMethod().type; + var comparisonInfoForPropTypeCheck = new TypeComparisonInfo(comparisonInfo); + + for (var i = 0; i < typeConstructorTypeMembers.length; i++) { + var propName = typeConstructorTypeMembers[i].name; + var extendedConstructorTypeProp = extendedConstructorType.findMember(propName, true); + if (extendedConstructorTypeProp) { + if (!extendedConstructorTypeProp.isResolved) { + this.resolveDeclaredSymbol(extendedConstructorTypeProp, context); + } + + var typeConstructorTypePropType = typeConstructorTypeMembers[i].type; + var extendedConstructorTypePropType = extendedConstructorTypeProp.type; + if (!this.sourceIsSubtypeOfTarget(typeConstructorTypePropType, extendedConstructorTypePropType, classOrInterface, context, comparisonInfoForPropTypeCheck)) { + var propMessage; + var enclosingSymbol = this.getEnclosingSymbolForAST(classOrInterface); + if (comparisonInfoForPropTypeCheck.message) { + propMessage = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible_NL_3, [extendedConstructorTypeProp.getScopedNameEx().toString(), typeSymbol.toString(enclosingSymbol), extendedType.toString(enclosingSymbol), comparisonInfoForPropTypeCheck.message]); + } else { + propMessage = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_static_property_0_of_class_1_and_class_2_are_incompatible, [extendedConstructorTypeProp.getScopedNameEx().toString(), typeSymbol.toString(enclosingSymbol), extendedType.toString(enclosingSymbol)]); + } + comparisonInfo.addMessage(propMessage); + foundError = true; + break; + } + } + } + } + } + + if (foundError) { + var errorCode; + if (typeSymbol.isClass()) { + errorCode = TypeScript.DiagnosticCode.Class_0_cannot_extend_class_1_NL_2; + } else { + if (extendedType.isClass()) { + errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_class_1_NL_2; + } else { + errorCode = TypeScript.DiagnosticCode.Interface_0_cannot_extend_interface_1_NL_2; + } + } + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, errorCode, [typeSymbol.getScopedName(), extendedType.getScopedName(), comparisonInfo.message])); + } + }; + + PullTypeResolver.prototype.typeCheckIfClassImplementsType = function (classDecl, classSymbol, implementedType, enclosingDecl, context) { + var comparisonInfo = new TypeComparisonInfo(); + var foundError = !this.sourceMembersAreSubtypeOfTargetMembers(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceCallSignaturesAreSubtypeOfTargetCallSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceConstructSignaturesAreSubtypeOfTargetConstructSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + if (!foundError) { + foundError = !this.sourceIndexSignaturesAreSubtypeOfTargetIndexSignatures(classSymbol, implementedType, classDecl, context, comparisonInfo); + } + } + } + + if (foundError) { + var enclosingSymbol = this.getEnclosingSymbolForAST(classDecl); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(classDecl.identifier, TypeScript.DiagnosticCode.Class_0_declares_interface_1_but_does_not_implement_it_NL_2, [classSymbol.getScopedName(enclosingSymbol), implementedType.getScopedName(enclosingSymbol), comparisonInfo.message])); + } + }; + + PullTypeResolver.prototype.hasClassTypeSymbolConflictAsValue = function (valueDeclAST, typeSymbol, enclosingDecl, context) { + var typeSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST); + var valueSymbol = this.computeNameExpression(valueDeclAST, context, false); + var valueSymbolAlias = this.semanticInfoChain.getAliasSymbolForAST(valueDeclAST); + + this.semanticInfoChain.setAliasSymbolForAST(valueDeclAST, typeSymbolAlias); + + if (typeSymbolAlias && valueSymbolAlias) { + return typeSymbolAlias != valueSymbolAlias; + } + + if (!valueSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */)) { + return true; + } + + var associatedContainerType = valueSymbol.type ? valueSymbol.type.getAssociatedContainerType() : null; + + if (associatedContainerType) { + return associatedContainerType != typeSymbol.getRootSymbol(); + } + + return true; + }; + + PullTypeResolver.prototype.typeCheckBase = function (classOrInterface, name, typeSymbol, baseDeclAST, isExtendedType, enclosingDecl, context) { + var _this = this; + var typeDecl = this.semanticInfoChain.getDeclForAST(classOrInterface); + + var baseType = this.resolveTypeReference(baseDeclAST, context).type; + + if (!baseType) { + return; + } + + var typeDeclIsClass = typeSymbol.isClass(); + + if (!typeSymbol.isValidBaseKind(baseType, isExtendedType)) { + if (!baseType.isError()) { + if (isExtendedType) { + if (typeDeclIsClass) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_extend_another_class)); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.An_interface_may_only_extend_another_class_or_interface)); + } + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.A_class_may_only_implement_another_class_or_interface)); + } + } + return; + } else if (typeDeclIsClass && isExtendedType && baseDeclAST.kind() == 11 /* IdentifierName */) { + if (this.hasClassTypeSymbolConflictAsValue(baseDeclAST, baseType, enclosingDecl, context)) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(baseDeclAST, TypeScript.DiagnosticCode.Type_reference_0_in_extends_clause_does_not_reference_constructor_function_for_1, [baseDeclAST.text(), baseType.toString(enclosingDecl ? enclosingDecl.getSymbol() : null)])); + } + } + + if (baseType.hasBase(typeSymbol)) { + typeSymbol.setHasBaseTypeConflict(); + baseType.setHasBaseTypeConflict(); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, typeDeclIsClass ? TypeScript.DiagnosticCode.Class_0_is_recursively_referenced_as_a_base_type_of_itself : TypeScript.DiagnosticCode.Interface_0_is_recursively_referenced_as_a_base_type_of_itself, [typeSymbol.getScopedName()])); + return; + } + + if (isExtendedType) { + this.typeCheckIfTypeExtendsType(classOrInterface, name, typeSymbol, baseType, enclosingDecl, context); + } else { + TypeScript.Debug.assert(classOrInterface.kind() === 131 /* ClassDeclaration */); + + this.typeCheckIfClassImplementsType(classOrInterface, typeSymbol, baseType, enclosingDecl, context); + } + + this.checkSymbolPrivacy(typeSymbol, baseType, function (errorSymbol) { + return _this.baseListPrivacyErrorReporter(classOrInterface, typeSymbol, baseDeclAST, isExtendedType, errorSymbol, context); + }); + }; + + PullTypeResolver.prototype.typeCheckBases = function (classOrInterface, name, heritageClauses, typeSymbol, enclosingDecl, context) { + var _this = this; + var extendsClause = TypeScript.getExtendsHeritageClause(heritageClauses); + var implementsClause = TypeScript.getImplementsHeritageClause(heritageClauses); + if (!extendsClause && !implementsClause) { + return; + } + + var typeDeclIsClass = classOrInterface.kind() === 131 /* ClassDeclaration */; + + if (extendsClause) { + for (var i = 0; i < extendsClause.typeNames.nonSeparatorCount(); i++) { + this.typeCheckBase(classOrInterface, name, typeSymbol, extendsClause.typeNames.nonSeparatorAt(i), true, enclosingDecl, context); + } + } + + if (typeSymbol.isClass()) { + if (implementsClause) { + for (var i = 0; i < implementsClause.typeNames.nonSeparatorCount(); i++) { + this.typeCheckBase(classOrInterface, name, typeSymbol, implementsClause.typeNames.nonSeparatorAt(i), false, enclosingDecl, context); + } + } + } else if (extendsClause && !typeSymbol.hasBaseTypeConflict() && typeSymbol.getExtendedTypes().length > 1) { + var firstInterfaceASTWithExtendsClause = TypeScript.ArrayUtilities.firstOrDefault(typeSymbol.getDeclarations(), function (decl) { + return decl.ast().heritageClauses !== null; + }).ast(); + if (classOrInterface === firstInterfaceASTWithExtendsClause) { + this.typeCheckCallBacks.push(function (context) { + _this.checkTypeCompatibilityBetweenBases(classOrInterface.identifier, typeSymbol, context); + }); + } + } + }; + + PullTypeResolver.prototype.checkTypeCompatibilityBetweenBases = function (name, typeSymbol, context) { + var derivedIndexSignatures = typeSymbol.getOwnIndexSignatures(); + + var inheritedMembersMap = TypeScript.createIntrinsicsObject(); + var inheritedIndexSignatures = new InheritedIndexSignatureInfo(); + + var typeHasOwnNumberIndexer = false; + var typeHasOwnStringIndexer = false; + + if (typeSymbol.hasOwnIndexSignatures()) { + var ownIndexSignatures = typeSymbol.getOwnIndexSignatures(); + for (var i = 0; i < ownIndexSignatures.length; i++) { + if (ownIndexSignatures[i].parameters[0].type === this.semanticInfoChain.numberTypeSymbol) { + typeHasOwnNumberIndexer = true; + } else { + typeHasOwnStringIndexer = true; + } + } + } + var baseTypes = typeSymbol.getExtendedTypes(); + for (var i = 0; i < baseTypes.length; i++) { + if (this.checkNamedPropertyTypeIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedMembersMap, context) || this.checkIndexSignatureIdentityBetweenBases(name, typeSymbol, baseTypes[i], inheritedIndexSignatures, typeHasOwnNumberIndexer, typeHasOwnStringIndexer, context)) { + return; + } + } + + if (this.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature(name, typeSymbol, inheritedIndexSignatures, context)) { + return; + } + + this.checkInheritedMembersAgainstInheritedIndexSignatures(name, typeSymbol, inheritedIndexSignatures, inheritedMembersMap, context); + }; + + PullTypeResolver.prototype.checkNamedPropertyTypeIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, inheritedMembersMap, context) { + var baseMembers = baseTypeSymbol.getAllMembers(4096 /* Property */ | 65536 /* Method */, 0 /* all */); + for (var i = 0; i < baseMembers.length; i++) { + var member = baseMembers[i]; + var memberName = member.name; + + if (interfaceSymbol.findMember(memberName, false)) { + continue; + } + + if (inheritedMembersMap[memberName]) { + var prevMember = inheritedMembersMap[memberName]; + if (prevMember.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(member.type, prevMember.memberSymbol.type)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_property_0_of_types_1_and_2_are_not_identical, [memberName, prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), prevMember.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + inheritedMembersMap[memberName] = new MemberWithBaseOrigin(member, baseTypeSymbol); + } + } + + return false; + }; + + PullTypeResolver.prototype.checkIndexSignatureIdentityBetweenBases = function (interfaceName, interfaceSymbol, baseTypeSymbol, allInheritedSignatures, derivedTypeHasOwnNumberSignature, derivedTypeHasOwnStringSignature, context) { + if (derivedTypeHasOwnNumberSignature && derivedTypeHasOwnStringSignature) { + return false; + } + + var indexSignaturesFromThisBaseType = baseTypeSymbol.getIndexSignatures(); + for (var i = 0; i < indexSignaturesFromThisBaseType.length; i++) { + var currentInheritedSignature = indexSignaturesFromThisBaseType[i]; + + var parameterTypeIsString = currentInheritedSignature.parameters[0].type === this.semanticInfoChain.stringTypeSymbol; + var parameterTypeIsNumber = !parameterTypeIsString; + if (parameterTypeIsString && derivedTypeHasOwnStringSignature || parameterTypeIsNumber && derivedTypeHasOwnNumberSignature) { + continue; + } + + if (parameterTypeIsString) { + if (allInheritedSignatures.stringSignatureWithBaseOrigin) { + if (allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.stringSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_string_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + allInheritedSignatures.stringSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol); + } + } else if (parameterTypeIsNumber) { + if (allInheritedSignatures.numberSignatureWithBaseOrigin) { + if (allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin !== baseTypeSymbol && !this.typesAreIdentical(allInheritedSignatures.numberSignatureWithBaseOrigin.signature.returnType, currentInheritedSignature.returnType)) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Types_of_number_indexer_of_types_0_and_1_are_not_identical, [allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName()]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(), allInheritedSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), baseTypeSymbol.getScopedName(), innerDiagnostic])); + return true; + } + } else { + allInheritedSignatures.numberSignatureWithBaseOrigin = new SignatureWithBaseOrigin(currentInheritedSignature, baseTypeSymbol); + } + } + } + + return false; + }; + + PullTypeResolver.prototype.checkInheritedMembersAgainstInheritedIndexSignatures = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, inheritedMembers, context) { + if (!inheritedIndexSignatures.stringSignatureWithBaseOrigin && !inheritedIndexSignatures.numberSignatureWithBaseOrigin) { + return false; + } + + var comparisonInfo = new TypeComparisonInfo(); + var stringSignature = inheritedIndexSignatures.stringSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature; + var numberSignature = inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature; + for (var memberName in inheritedMembers) { + var memberWithBaseOrigin = inheritedMembers[memberName]; + if (!memberWithBaseOrigin) { + continue; + } + + var relevantSignature = this.determineRelevantIndexerForMember(memberWithBaseOrigin.memberSymbol, numberSignature, stringSignature); + if (!relevantSignature) { + continue; + } + + var relevantSignatureIsNumberSignature = relevantSignature.parameters[0].type === this.semanticInfoChain.numberTypeSymbol; + var signatureBaseOrigin = relevantSignatureIsNumberSignature ? inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin : inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin; + + if (signatureBaseOrigin === memberWithBaseOrigin.baseOrigin) { + continue; + } + + var memberIsSubtype = this.sourceIsSubtypeOfTarget(memberWithBaseOrigin.memberSymbol.type, relevantSignature.returnType, interfaceName, context, comparisonInfo); + + if (!memberIsSubtype) { + var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName); + if (relevantSignatureIsNumberSignature) { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_a_subtype_of_number_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + } else { + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_property_0_in_type_1_is_not_a_subtype_of_string_indexer_type_in_type_2_NL_3, [memberName, memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [interfaceSymbol.getDisplayName(enclosingSymbol), memberWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + } + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.checkThatInheritedNumberSignatureIsSubtypeOfInheritedStringSignature = function (interfaceName, interfaceSymbol, inheritedIndexSignatures, context) { + if (inheritedIndexSignatures.numberSignatureWithBaseOrigin && inheritedIndexSignatures.stringSignatureWithBaseOrigin) { + if (inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin === inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin) { + return false; + } + + var comparisonInfo = new TypeComparisonInfo(); + var signatureIsSubtype = this.sourceIsSubtypeOfTarget(inheritedIndexSignatures.numberSignatureWithBaseOrigin.signature.returnType, inheritedIndexSignatures.stringSignatureWithBaseOrigin.signature.returnType, interfaceName, context, comparisonInfo); + + if (!signatureIsSubtype) { + var enclosingSymbol = this.getEnclosingSymbolForAST(interfaceName); + var innerDiagnostic = TypeScript.getDiagnosticMessage(TypeScript.DiagnosticCode.Type_of_number_indexer_in_type_0_is_not_a_subtype_of_string_indexer_type_in_type_1_NL_2, [ + inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), + inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), comparisonInfo.message]); + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(interfaceName, TypeScript.DiagnosticCode.Interface_0_cannot_simultaneously_extend_types_1_and_2_NL_3, [ + interfaceSymbol.getDisplayName(enclosingSymbol), inheritedIndexSignatures.numberSignatureWithBaseOrigin.baseOrigin.getScopedName(), + inheritedIndexSignatures.stringSignatureWithBaseOrigin.baseOrigin.getScopedName(enclosingSymbol), innerDiagnostic])); + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.checkAssignability = function (ast, source, target, context) { + var comparisonInfo = new TypeComparisonInfo(); + + var isAssignable = this.sourceIsAssignableToTarget(source, target, ast, context, comparisonInfo); + + if (!isAssignable) { + var enclosingSymbol = this.getEnclosingSymbolForAST(ast); + if (comparisonInfo.message) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1_NL_2, [source.toString(enclosingSymbol), target.toString(enclosingSymbol), comparisonInfo.message])); + } else { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(ast, TypeScript.DiagnosticCode.Cannot_convert_0_to_1, [source.toString(enclosingSymbol), target.toString(enclosingSymbol)])); + } + } + }; + + PullTypeResolver.prototype.isReference = function (ast, astSymbol) { + if (ast.kind() === 217 /* ParenthesizedExpression */) { + return this.isReference(ast.expression, astSymbol); + } + + if (ast.kind() !== 11 /* IdentifierName */ && ast.kind() !== 212 /* MemberAccessExpression */ && ast.kind() !== 221 /* ElementAccessExpression */) { + return false; + } + + if (ast.kind() === 11 /* IdentifierName */) { + if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(4096 /* Enum */)) { + return false; + } + + if (astSymbol.kind === 512 /* Variable */ && astSymbol.anyDeclHasFlag(102400 /* SomeInitializedModule */)) { + return false; + } + + if (astSymbol.kind === 32768 /* ConstructorMethod */) { + return false; + } + } + + if (ast.kind() === 212 /* MemberAccessExpression */ && astSymbol.kind === 67108864 /* EnumMember */) { + return false; + } + + return true; + }; + + PullTypeResolver.prototype.checkForSuperMemberAccess = function (expression, name, resolvedName, context) { + if (resolvedName) { + if (expression.kind() === 50 /* SuperKeyword */ && !resolvedName.isError() && resolvedName.kind !== 65536 /* Method */) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode.Only_public_methods_of_the_base_class_are_accessible_via_the_super_keyword)); + return true; + } + } + + return false; + }; + + PullTypeResolver.prototype.getEnclosingDeclForAST = function (ast) { + return this.semanticInfoChain.getEnclosingDecl(ast); + }; + + PullTypeResolver.prototype.getEnclosingSymbolForAST = function (ast) { + var enclosingDecl = this.getEnclosingDeclForAST(ast); + return enclosingDecl ? enclosingDecl.getSymbol() : null; + }; + + PullTypeResolver.prototype.checkForPrivateMemberAccess = function (name, expressionType, resolvedName, context) { + if (resolvedName) { + if (resolvedName.anyDeclHasFlag(2 /* Private */)) { + var memberContainer = resolvedName.getContainer(); + if (memberContainer && memberContainer.kind === 33554432 /* ConstructorType */) { + memberContainer = memberContainer.getAssociatedContainerType(); + } + + if (memberContainer && memberContainer.isClass()) { + var memberClass = memberContainer.getDeclarations()[0].ast(); + TypeScript.Debug.assert(memberClass); + + var containingClass = this.getEnclosingClassDeclaration(name); + + if (!containingClass || containingClass !== memberClass) { + context.postDiagnostic(this.semanticInfoChain.diagnosticFromAST(name, TypeScript.DiagnosticCode._0_1_is_inaccessible, [memberContainer.toString(null, false), name.text()])); + return true; + } + } + } + } + + return false; + }; + + PullTypeResolver.prototype.instantiateType = function (type, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + if (type.isPrimitive()) { + return type; + } + + if (type.isError()) { + return type; + } + + if (typeParameterArgumentMap[type.pullSymbolID]) { + return typeParameterArgumentMap[type.pullSymbolID]; + } + + if (type.isTypeParameter() && type.isFunctionTypeParameter()) { + return type; + } + + type._resolveDeclaredSymbol(); + if (type.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return TypeScript.PullInstantiatedTypeReferenceSymbol.create(this, type, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + return type; + }; + + PullTypeResolver.prototype.instantiateSignature = function (signature, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + if (!signature.wrapsSomeTypeParameter(typeParameterArgumentMap)) { + return signature; + } + + var typeArguments = []; + + TypeScript.nSpecializedSignaturesCreated++; + + var instantiatedSignature = new TypeScript.PullSignatureSymbol(signature.kind); + instantiatedSignature.setRootSymbol(signature); + + var typeParameters = signature.getTypeParameters(); + var constraint = null; + var typeParameter = null; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = typeParameters[i]; + + instantiatedSignature.addTypeParameter(typeParameter); + } + + instantiatedSignature.returnType = this.instantiateType((signature.returnType || this.semanticInfoChain.anyTypeSymbol), typeParameterArgumentMap, instantiateFunctionTypeParameters); + + if (instantiateFunctionTypeParameters) { + instantiatedSignature.functionType = this.instantiateType(signature.functionType, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + var parameters = signature.parameters; + var parameter = null; + + if (parameters) { + for (var j = 0; j < parameters.length; j++) { + parameter = new TypeScript.PullSymbol(parameters[j].name, 2048 /* Parameter */); + parameter.setRootSymbol(parameters[j]); + + if (parameters[j].isOptional) { + parameter.isOptional = true; + } + if (parameters[j].isVarArg) { + parameter.isVarArg = true; + instantiatedSignature.hasVarArgs = true; + } + instantiatedSignature.addParameter(parameter, parameter.isOptional); + + parameter.type = this.instantiateType(parameters[j].type, typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + } + + return instantiatedSignature; + }; + PullTypeResolver.globalTypeCheckPhase = 0; + return PullTypeResolver; + })(); + TypeScript.PullTypeResolver = PullTypeResolver; + + var TypeComparisonInfo = (function () { + function TypeComparisonInfo(sourceComparisonInfo) { + this.onlyCaptureFirstError = false; + this.flags = 0 /* SuccessfulComparison */; + this.message = ""; + this.stringConstantVal = null; + this.indent = 1; + if (sourceComparisonInfo) { + this.flags = sourceComparisonInfo.flags; + this.onlyCaptureFirstError = sourceComparisonInfo.onlyCaptureFirstError; + this.stringConstantVal = sourceComparisonInfo.stringConstantVal; + this.indent = sourceComparisonInfo.indent + 1; + } + } + TypeComparisonInfo.prototype.indentString = function () { + var result = ""; + + for (var i = 0; i < this.indent; i++) { + result += "\t"; + } + + return result; + }; + + TypeComparisonInfo.prototype.addMessage = function (message) { + if (!this.onlyCaptureFirstError && this.message) { + this.message = this.message + TypeScript.newLine() + this.indentString() + message; + } else { + this.message = this.indentString() + message; + } + }; + return TypeComparisonInfo; + })(); + TypeScript.TypeComparisonInfo = TypeComparisonInfo; + + function getPropertyAssignmentNameTextFromIdentifier(identifier) { + if (identifier.kind() === 11 /* IdentifierName */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else if (identifier.kind() === 14 /* StringLiteral */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else if (identifier.kind() === 13 /* NumericLiteral */) { + return { actualText: identifier.text(), memberName: identifier.valueText() }; + } else { + throw TypeScript.Errors.invalidOperation(); + } + } + TypeScript.getPropertyAssignmentNameTextFromIdentifier = getPropertyAssignmentNameTextFromIdentifier; + + function isTypesOnlyLocation(ast) { + while (ast && ast.parent) { + switch (ast.parent.kind()) { + case 244 /* TypeAnnotation */: + return true; + case 127 /* TypeQuery */: + return false; + case 125 /* ConstructorType */: + var constructorType = ast.parent; + if (constructorType.type === ast) { + return true; + } + break; + case 123 /* FunctionType */: + var functionType = ast.parent; + if (functionType.type === ast) { + return true; + } + break; + case 239 /* Constraint */: + var constraint = ast.parent; + if (constraint.type === ast) { + return true; + } + break; + case 220 /* CastExpression */: + var castExpression = ast.parent; + return castExpression.type === ast; + case 230 /* ExtendsHeritageClause */: + case 231 /* ImplementsHeritageClause */: + return true; + case 228 /* TypeArgumentList */: + return true; + case 131 /* ClassDeclaration */: + case 128 /* InterfaceDeclaration */: + case 130 /* ModuleDeclaration */: + case 129 /* FunctionDeclaration */: + case 145 /* MethodSignature */: + case 212 /* MemberAccessExpression */: + case 242 /* Parameter */: + return false; + } + + ast = ast.parent; + } + + return false; + } + TypeScript.isTypesOnlyLocation = isTypesOnlyLocation; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + TypeScript.declCacheHit = 0; + TypeScript.declCacheMiss = 0; + TypeScript.symbolCacheHit = 0; + TypeScript.symbolCacheMiss = 0; + + var sentinalEmptyArray = []; + + var SemanticInfoChain = (function () { + function SemanticInfoChain(compiler, logger) { + this.compiler = compiler; + this.logger = logger; + this.documents = []; + this.fileNameToDocument = TypeScript.createIntrinsicsObject(); + this.anyTypeDecl = null; + this.booleanTypeDecl = null; + this.numberTypeDecl = null; + this.stringTypeDecl = null; + this.nullTypeDecl = null; + this.undefinedTypeDecl = null; + this.voidTypeDecl = null; + this.undefinedValueDecl = null; + this.anyTypeSymbol = null; + this.booleanTypeSymbol = null; + this.numberTypeSymbol = null; + this.stringTypeSymbol = null; + this.nullTypeSymbol = null; + this.undefinedTypeSymbol = null; + this.voidTypeSymbol = null; + this.undefinedValueSymbol = null; + this.emptyTypeSymbol = null; + this.astSymbolMap = []; + this.astAliasSymbolMap = []; + this.astCallResolutionDataMap = []; + this.declSymbolMap = []; + this.declSignatureSymbolMap = []; + this.declCache = null; + this.symbolCache = null; + this.fileNameToDiagnostics = null; + this._binder = null; + this._resolver = null; + this._topLevelDecls = null; + this._fileNames = null; + var span = new TypeScript.TextSpan(0, 0); + var globalDecl = new TypeScript.RootPullDecl("", "", 0 /* Global */, 0 /* None */, span, this, false); + this.documents[0] = new TypeScript.Document(this.compiler, this, "", [], null, 0 /* None */, 0, false, null, globalDecl); + + this.anyTypeDecl = new TypeScript.NormalPullDecl("any", "any", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.booleanTypeDecl = new TypeScript.NormalPullDecl("boolean", "boolean", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.numberTypeDecl = new TypeScript.NormalPullDecl("number", "number", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.stringTypeDecl = new TypeScript.NormalPullDecl("string", "string", 2 /* Primitive */, 0 /* None */, globalDecl, span); + this.voidTypeDecl = new TypeScript.NormalPullDecl("void", "void", 2 /* Primitive */, 0 /* None */, globalDecl, span); + + this.nullTypeDecl = new TypeScript.RootPullDecl("null", "", 2 /* Primitive */, 0 /* None */, span, this, false); + this.undefinedTypeDecl = new TypeScript.RootPullDecl("undefined", "", 2 /* Primitive */, 0 /* None */, span, this, false); + this.undefinedValueDecl = new TypeScript.NormalPullDecl("undefined", "undefined", 512 /* Variable */, 8 /* Ambient */, globalDecl, span); + + this.invalidate(); + } + SemanticInfoChain.prototype.getDocument = function (fileName) { + var document = this.fileNameToDocument[fileName]; + return document ? document : null; + }; + + SemanticInfoChain.prototype.lineMap = function (fileName) { + return this.getDocument(fileName).lineMap(); + }; + + SemanticInfoChain.prototype.fileNames = function () { + if (this._fileNames === null) { + this._fileNames = this.documents.slice(1).map(function (s) { + return s.fileName; + }); + } + + return this._fileNames; + }; + + SemanticInfoChain.prototype.bindPrimitiveSymbol = function (decl, newSymbol) { + newSymbol.addDeclaration(decl); + decl.setSymbol(newSymbol); + newSymbol.setResolved(); + + return newSymbol; + }; + + SemanticInfoChain.prototype.addPrimitiveTypeSymbol = function (decl) { + var newSymbol = new TypeScript.PullPrimitiveTypeSymbol(decl.name); + return this.bindPrimitiveSymbol(decl, newSymbol); + }; + + SemanticInfoChain.prototype.addPrimitiveValueSymbol = function (decl, type) { + var newSymbol = new TypeScript.PullSymbol(decl.name, 512 /* Variable */); + newSymbol.type = type; + return this.bindPrimitiveSymbol(decl, newSymbol); + }; + + SemanticInfoChain.prototype.resetGlobalSymbols = function () { + this.anyTypeSymbol = this.addPrimitiveTypeSymbol(this.anyTypeDecl); + this.booleanTypeSymbol = this.addPrimitiveTypeSymbol(this.booleanTypeDecl); + this.numberTypeSymbol = this.addPrimitiveTypeSymbol(this.numberTypeDecl); + this.stringTypeSymbol = this.addPrimitiveTypeSymbol(this.stringTypeDecl); + this.voidTypeSymbol = this.addPrimitiveTypeSymbol(this.voidTypeDecl); + this.nullTypeSymbol = this.addPrimitiveTypeSymbol(this.nullTypeDecl); + this.undefinedTypeSymbol = this.addPrimitiveTypeSymbol(this.undefinedTypeDecl); + this.undefinedValueSymbol = this.addPrimitiveValueSymbol(this.undefinedValueDecl, this.undefinedTypeSymbol); + + var span = new TypeScript.TextSpan(0, 0); + var emptyTypeDecl = new TypeScript.PullSynthesizedDecl("{}", "{}", 8388608 /* ObjectType */, 0 /* None */, null, span, this); + var emptyTypeSymbol = new TypeScript.PullTypeSymbol("{}", 8388608 /* ObjectType */); + emptyTypeDecl.setSymbol(emptyTypeSymbol); + emptyTypeSymbol.addDeclaration(emptyTypeDecl); + emptyTypeSymbol.setResolved(); + this.emptyTypeSymbol = emptyTypeSymbol; + }; + + SemanticInfoChain.prototype.addDocument = function (document) { + var fileName = document.fileName; + + var existingIndex = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) { + return u.fileName === fileName; + }); + if (existingIndex < 0) { + this.documents.push(document); + } else { + this.documents[existingIndex] = document; + } + + this.fileNameToDocument[fileName] = document; + + this.invalidate(); + }; + + SemanticInfoChain.prototype.removeDocument = function (fileName) { + TypeScript.Debug.assert(fileName !== "", "Can't remove the semantic info for the global decl."); + var index = TypeScript.ArrayUtilities.indexOf(this.documents, function (u) { + return u.fileName === fileName; + }); + if (index > 0) { + this.fileNameToDocument[fileName] = undefined; + this.documents.splice(index, 1); + this.invalidate(); + } + }; + + SemanticInfoChain.prototype.getDeclPathCacheID = function (declPath, declKind) { + var cacheID = ""; + + for (var i = 0; i < declPath.length; i++) { + cacheID += "#" + declPath[i]; + } + + return cacheID + "#" + declKind.toString(); + }; + + SemanticInfoChain.prototype.findTopLevelSymbol = function (name, kind, doNotGoPastThisDecl) { + var cacheID = this.getDeclPathCacheID([name], kind); + + var symbol = this.symbolCache[cacheID]; + + if (!symbol) { + for (var i = 0, n = this.documents.length; i < n; i++) { + var topLevelDecl = this.documents[i].topLevelDecl(); + + var symbol = this.findTopLevelSymbolInDecl(topLevelDecl, name, kind, doNotGoPastThisDecl); + if (symbol) { + break; + } + + if (doNotGoPastThisDecl && topLevelDecl.name == doNotGoPastThisDecl.fileName()) { + return null; + } + } + + if (symbol) { + this.symbolCache[cacheID] = symbol; + } + } + + return symbol; + }; + + SemanticInfoChain.prototype.findTopLevelSymbolInDecl = function (topLevelDecl, name, kind, doNotGoPastThisDecl) { + var doNotGoPastThisPosition = doNotGoPastThisDecl && doNotGoPastThisDecl.fileName() === topLevelDecl.fileName() ? doNotGoPastThisDecl.ast().start() : -1; + + var foundDecls = topLevelDecl.searchChildDecls(name, kind); + + for (var j = 0; j < foundDecls.length; j++) { + var foundDecl = foundDecls[j]; + + if (doNotGoPastThisPosition !== -1 && foundDecl.ast() && foundDecl.ast().start() > doNotGoPastThisPosition) { + break; + } + + var symbol = foundDecls[j].getSymbol(); + if (symbol) { + return symbol; + } + } + + return null; + }; + + SemanticInfoChain.prototype.findExternalModule = function (id) { + id = TypeScript.normalizePath(id); + + var dtsFile = id + ".d.ts"; + var dtsCacheID = this.getDeclPathCacheID([dtsFile], 32 /* DynamicModule */); + var symbol = this.symbolCache[dtsCacheID]; + if (symbol) { + return symbol; + } + + var tsFile = id + ".ts"; + var tsCacheID = this.getDeclPathCacheID([tsFile], 32 /* DynamicModule */); + symbol = this.symbolCache[tsCacheID]; + if (symbol != undefined) { + return symbol; + } + + symbol = null; + for (var i = 0; i < this.documents.length; i++) { + var document = this.documents[i]; + var topLevelDecl = document.topLevelDecl(); + + if (topLevelDecl.isExternalModule()) { + var isDtsFile = document.fileName == dtsFile; + if (isDtsFile || document.fileName == tsFile) { + var dynamicModuleDecl = topLevelDecl.getChildDecls()[0]; + symbol = dynamicModuleDecl.getSymbol(); + this.symbolCache[dtsCacheID] = isDtsFile ? symbol : null; + this.symbolCache[tsCacheID] = !TypeScript.isDTSFile ? symbol : null; + return symbol; + } + } + } + + this.symbolCache[dtsCacheID] = null; + this.symbolCache[tsCacheID] = null; + + return symbol; + }; + + SemanticInfoChain.prototype.findAmbientExternalModuleInGlobalContext = function (id) { + var cacheID = this.getDeclPathCacheID([id], 32 /* DynamicModule */); + + var symbol = this.symbolCache[cacheID]; + if (symbol == undefined) { + symbol = null; + for (var i = 0; i < this.documents.length; i++) { + var document = this.documents[i]; + var topLevelDecl = document.topLevelDecl(); + + if (!topLevelDecl.isExternalModule()) { + var dynamicModules = topLevelDecl.searchChildDecls(id, 32 /* DynamicModule */); + if (dynamicModules.length) { + symbol = dynamicModules[0].getSymbol(); + break; + } + } + } + + this.symbolCache[cacheID] = symbol; + } + + return symbol; + }; + + SemanticInfoChain.prototype.findDecls = function (declPath, declKind) { + var cacheID = this.getDeclPathCacheID(declPath, declKind); + + if (declPath.length) { + var cachedDecls = this.declCache[cacheID]; + + if (cachedDecls && cachedDecls.length) { + TypeScript.declCacheHit++; + return cachedDecls; + } + } + + TypeScript.declCacheMiss++; + + var declsToSearch = this.topLevelDecls(); + + var decls = TypeScript.sentinelEmptyArray; + var path; + var foundDecls = TypeScript.sentinelEmptyArray; + var keepSearching = (declKind & 164 /* SomeContainer */) || (declKind & 16 /* Interface */); + + for (var i = 0; i < declPath.length; i++) { + path = declPath[i]; + decls = TypeScript.sentinelEmptyArray; + + for (var j = 0; j < declsToSearch.length; j++) { + foundDecls = declsToSearch[j].searchChildDecls(path, declKind); + + for (var k = 0; k < foundDecls.length; k++) { + if (decls == TypeScript.sentinelEmptyArray) { + decls = []; + } + decls[decls.length] = foundDecls[k]; + } + + if (foundDecls.length && !keepSearching) { + break; + } + } + + declsToSearch = decls; + + if (!declsToSearch) { + break; + } + } + + if (decls.length) { + this.declCache[cacheID] = decls; + } + + return decls; + }; + + SemanticInfoChain.prototype.findDeclsFromPath = function (declPath, declKind) { + var declString = []; + + for (var i = 0, n = declPath.length; i < n; i++) { + if (declPath[i].kind & 1 /* Script */) { + continue; + } + + declString.push(declPath[i].name); + } + + return this.findDecls(declString, declKind); + }; + + SemanticInfoChain.prototype.findSymbol = function (declPath, declType) { + var cacheID = this.getDeclPathCacheID(declPath, declType); + + if (declPath.length) { + var cachedSymbol = this.symbolCache[cacheID]; + + if (cachedSymbol) { + TypeScript.symbolCacheHit++; + return cachedSymbol; + } + } + + TypeScript.symbolCacheMiss++; + + var decls = this.findDecls(declPath, declType); + var symbol = null; + + if (decls.length) { + var decl = decls[0]; + if (TypeScript.hasFlag(declType, 164 /* SomeContainer */)) { + var valueDecl = decl.getValueDecl(); + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + } + + symbol = decl.getSymbol(); + + if (symbol) { + this.symbolCache[cacheID] = symbol; + } + } + + return symbol; + }; + + SemanticInfoChain.prototype.cacheGlobalSymbol = function (symbol, kind) { + var cacheID1 = this.getDeclPathCacheID([symbol.name], kind); + var cacheID2 = this.getDeclPathCacheID([symbol.name], symbol.kind); + + if (!this.symbolCache[cacheID1]) { + this.symbolCache[cacheID1] = symbol; + } + + if (!this.symbolCache[cacheID2]) { + this.symbolCache[cacheID2] = symbol; + } + }; + + SemanticInfoChain.prototype.invalidate = function (oldSettings, newSettings) { + if (typeof oldSettings === "undefined") { oldSettings = null; } + if (typeof newSettings === "undefined") { newSettings = null; } + TypeScript.PullTypeResolver.globalTypeCheckPhase++; + + var cleanStart = new Date().getTime(); + + this.astSymbolMap.length = 0; + this.astAliasSymbolMap.length = 0; + this.astCallResolutionDataMap.length = 0; + + this.declCache = TypeScript.createIntrinsicsObject(); + this.symbolCache = TypeScript.createIntrinsicsObject(); + this.fileNameToDiagnostics = TypeScript.createIntrinsicsObject(); + this._binder = null; + this._resolver = null; + this._topLevelDecls = null; + this._fileNames = null; + + this.declSymbolMap.length = 0; + this.declSignatureSymbolMap.length = 0; + + if (oldSettings && newSettings) { + if (this.settingsChangeAffectsSyntax(oldSettings, newSettings)) { + for (var i = 1, n = this.documents.length; i < n; i++) { + this.documents[i].invalidate(); + } + } + } + + TypeScript.pullSymbolID = 0; + TypeScript.globalTyvarID = 0; + + this.resetGlobalSymbols(); + + var cleanEnd = new Date().getTime(); + }; + + SemanticInfoChain.prototype.settingsChangeAffectsSyntax = function (before, after) { + return before.allowAutomaticSemicolonInsertion() !== after.allowAutomaticSemicolonInsertion() || before.codeGenTarget() !== after.codeGenTarget() || before.propagateEnumConstants() != after.propagateEnumConstants(); + }; + + SemanticInfoChain.prototype.setSymbolForAST = function (ast, symbol) { + this.astSymbolMap[ast.syntaxID()] = symbol; + }; + + SemanticInfoChain.prototype.getSymbolForAST = function (ast) { + return this.astSymbolMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.setAliasSymbolForAST = function (ast, symbol) { + this.astAliasSymbolMap[ast.syntaxID()] = symbol; + }; + + SemanticInfoChain.prototype.getAliasSymbolForAST = function (ast) { + return this.astAliasSymbolMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.getCallResolutionDataForAST = function (ast) { + return this.astCallResolutionDataMap[ast.syntaxID()]; + }; + + SemanticInfoChain.prototype.setCallResolutionDataForAST = function (ast, callResolutionData) { + if (callResolutionData) { + this.astCallResolutionDataMap[ast.syntaxID()] = callResolutionData; + } + }; + + SemanticInfoChain.prototype.setSymbolForDecl = function (decl, symbol) { + this.declSymbolMap[decl.declID] = symbol; + }; + + SemanticInfoChain.prototype.getSymbolForDecl = function (decl) { + return this.declSymbolMap[decl.declID]; + }; + + SemanticInfoChain.prototype.setSignatureSymbolForDecl = function (decl, signatureSymbol) { + this.declSignatureSymbolMap[decl.declID] = signatureSymbol; + }; + + SemanticInfoChain.prototype.getSignatureSymbolForDecl = function (decl) { + return this.declSignatureSymbolMap[decl.declID]; + }; + + SemanticInfoChain.prototype.addDiagnostic = function (diagnostic) { + var fileName = diagnostic.fileName(); + var diagnostics = this.fileNameToDiagnostics[fileName]; + if (!diagnostics) { + diagnostics = []; + this.fileNameToDiagnostics[fileName] = diagnostics; + } + + diagnostics.push(diagnostic); + }; + + SemanticInfoChain.prototype.getDiagnostics = function (fileName) { + var diagnostics = this.fileNameToDiagnostics[fileName]; + return diagnostics ? diagnostics : []; + }; + + SemanticInfoChain.prototype.getBinder = function () { + if (!this._binder) { + this._binder = new TypeScript.PullSymbolBinder(this); + } + + return this._binder; + }; + + SemanticInfoChain.prototype.getResolver = function () { + if (!this._resolver) { + this._resolver = new TypeScript.PullTypeResolver(this.compiler.compilationSettings(), this); + } + + return this._resolver; + }; + + SemanticInfoChain.prototype.addSyntheticIndexSignature = function (containingDecl, containingSymbol, ast, indexParamName, indexParamType, returnType) { + var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + var indexParameterSymbol = new TypeScript.PullSymbol(indexParamName, 2048 /* Parameter */); + indexParameterSymbol.type = indexParamType; + indexSignature.addParameter(indexParameterSymbol); + indexSignature.returnType = returnType; + indexSignature.setResolved(); + indexParameterSymbol.setResolved(); + + containingSymbol.addIndexSignature(indexSignature); + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + var indexSigDecl = new TypeScript.PullSynthesizedDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, containingDecl, span, containingDecl.semanticInfoChain()); + var indexParamDecl = new TypeScript.PullSynthesizedDecl(indexParamName, indexParamName, 2048 /* Parameter */, 0 /* None */, indexSigDecl, span, containingDecl.semanticInfoChain()); + indexSigDecl.setSignatureSymbol(indexSignature); + indexParamDecl.setSymbol(indexParameterSymbol); + indexSignature.addDeclaration(indexSigDecl); + indexParameterSymbol.addDeclaration(indexParamDecl); + }; + + SemanticInfoChain.prototype.getDeclForAST = function (ast) { + var document = this.getDocument(ast.fileName()); + + if (document) { + return document._getDeclForAST(ast); + } + + return null; + }; + + SemanticInfoChain.prototype.getEnclosingDecl = function (ast) { + return this.getDocument(ast.fileName()).getEnclosingDecl(ast); + }; + + SemanticInfoChain.prototype.setDeclForAST = function (ast, decl) { + this.getDocument(decl.fileName())._setDeclForAST(ast, decl); + }; + + SemanticInfoChain.prototype.getASTForDecl = function (decl) { + var document = this.getDocument(decl.fileName()); + if (document) { + return document._getASTForDecl(decl); + } + + return null; + }; + + SemanticInfoChain.prototype.setASTForDecl = function (decl, ast) { + this.getDocument(decl.fileName())._setASTForDecl(decl, ast); + }; + + SemanticInfoChain.prototype.topLevelDecl = function (fileName) { + var document = this.getDocument(fileName); + if (document) { + return document.topLevelDecl(); + } + + return null; + }; + + SemanticInfoChain.prototype.topLevelDecls = function () { + if (!this._topLevelDecls) { + this._topLevelDecls = TypeScript.ArrayUtilities.select(this.documents, function (u) { + return u.topLevelDecl(); + }); + } + + return this._topLevelDecls; + }; + + SemanticInfoChain.prototype.addDiagnosticFromAST = function (ast, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + this.addDiagnostic(this.diagnosticFromAST(ast, diagnosticKey, arguments)); + }; + + SemanticInfoChain.prototype.diagnosticFromAST = function (ast, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + return new TypeScript.Diagnostic(ast.fileName(), this.lineMap(ast.fileName()), ast.start(), ast.width(), diagnosticKey, arguments); + }; + return SemanticInfoChain; + })(); + TypeScript.SemanticInfoChain = SemanticInfoChain; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var DeclCollectionContext = (function () { + function DeclCollectionContext(document, semanticInfoChain, propagateEnumConstants) { + this.document = document; + this.semanticInfoChain = semanticInfoChain; + this.propagateEnumConstants = propagateEnumConstants; + this.isDeclareFile = false; + this.parentChain = []; + } + DeclCollectionContext.prototype.getParent = function () { + return this.parentChain ? this.parentChain[this.parentChain.length - 1] : null; + }; + + DeclCollectionContext.prototype.pushParent = function (parentDecl) { + if (parentDecl) { + this.parentChain[this.parentChain.length] = parentDecl; + } + }; + + DeclCollectionContext.prototype.popParent = function () { + this.parentChain.length--; + }; + return DeclCollectionContext; + })(); + + function containingModuleHasExportAssignment(ast) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + var moduleDecl = ast; + return moduleDecl.moduleElements.any(function (m) { + return m.kind() === 134 /* ExportAssignment */; + }); + } else if (ast.kind() === 120 /* SourceUnit */) { + var sourceUnit = ast; + return sourceUnit.moduleElements.any(function (m) { + return m.kind() === 134 /* ExportAssignment */; + }); + } + + ast = ast.parent; + } + + return false; + } + + function isParsingAmbientModule(ast, context) { + ast = ast.parent; + while (ast) { + if (ast.kind() === 130 /* ModuleDeclaration */) { + if (TypeScript.hasModifier(ast.modifiers, 8 /* Ambient */)) { + return true; + } + } + + ast = ast.parent; + } + + return false; + } + + function preCollectImportDecls(ast, context) { + var importDecl = ast; + var declFlags = 0 /* None */; + var span = TypeScript.TextSpan.fromBounds(importDecl.start(), importDecl.end()); + + var parent = context.getParent(); + + if (TypeScript.hasModifier(importDecl.modifiers, 1 /* Exported */) && !containingModuleHasExportAssignment(ast)) { + declFlags |= 1 /* Exported */; + } + + var decl = new TypeScript.NormalPullDecl(importDecl.identifier.valueText(), importDecl.identifier.text(), 128 /* TypeAlias */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + } + + function preCollectScriptDecls(sourceUnit, context) { + var span = TypeScript.TextSpan.fromBounds(sourceUnit.start(), sourceUnit.end()); + + var fileName = sourceUnit.fileName(); + + var isExternalModule = context.document.isExternalModule(); + + var decl = new TypeScript.RootPullDecl(fileName, fileName, 1 /* Script */, 0 /* None */, span, context.semanticInfoChain, isExternalModule); + context.semanticInfoChain.setDeclForAST(sourceUnit, decl); + context.semanticInfoChain.setASTForDecl(decl, sourceUnit); + + context.isDeclareFile = context.document.isDeclareFile(); + + context.pushParent(decl); + + if (isExternalModule) { + var declFlags = 1 /* Exported */; + if (TypeScript.isDTSFile(fileName)) { + declFlags |= 8 /* Ambient */; + } + + var moduleContainsExecutableCode = containsExecutableCode(sourceUnit.moduleElements); + var kind = 32 /* DynamicModule */; + var span = TypeScript.TextSpan.fromBounds(sourceUnit.start(), sourceUnit.end()); + var valueText = TypeScript.quoteStr(fileName); + + var decl = new TypeScript.NormalPullDecl(valueText, fileName, kind, declFlags, context.getParent(), span); + + context.semanticInfoChain.setASTForDecl(decl, sourceUnit); + + context.semanticInfoChain.setDeclForAST(sourceUnit, decl); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, sourceUnit, context); + } + + context.pushParent(decl); + } + } + + function preCollectEnumDecls(enumDecl, context) { + var declFlags = 0 /* None */; + var enumName = enumDecl.identifier.valueText(); + var kind = 4 /* Container */; + + if ((TypeScript.hasModifier(enumDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(enumDecl, context)) && !containingModuleHasExportAssignment(enumDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(enumDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(enumDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + declFlags |= 4096 /* Enum */; + kind = 64 /* Enum */; + + var span = TypeScript.TextSpan.fromBounds(enumDecl.start(), enumDecl.end()); + + var enumDeclaration = new TypeScript.NormalPullDecl(enumName, enumDecl.identifier.text(), kind, declFlags, context.getParent(), span); + context.semanticInfoChain.setDeclForAST(enumDecl, enumDeclaration); + context.semanticInfoChain.setASTForDecl(enumDeclaration, enumDecl); + + var enumIndexerDecl = new TypeScript.NormalPullDecl("", "", 4194304 /* IndexSignature */, 2048 /* Signature */, enumDeclaration, span); + var enumIndexerParameter = new TypeScript.NormalPullDecl("x", "x", 2048 /* Parameter */, 0 /* None */, enumIndexerDecl, span); + + var valueDecl = new TypeScript.NormalPullDecl(enumDeclaration.name, enumDeclaration.getDisplayName(), 512 /* Variable */, enumDeclaration.flags, context.getParent(), enumDeclaration.getSpan()); + enumDeclaration.setValueDecl(valueDecl); + context.semanticInfoChain.setASTForDecl(valueDecl, enumDecl); + + context.pushParent(enumDeclaration); + } + + function createEnumElementDecls(propertyDecl, context) { + var parent = context.getParent(); + + var span = TypeScript.TextSpan.fromBounds(propertyDecl.start(), propertyDecl.end()); + + var decl = new TypeScript.PullEnumElementDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), parent, span); + context.semanticInfoChain.setDeclForAST(propertyDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyDecl); + } + + function preCollectModuleDecls(moduleDecl, context) { + var declFlags = 0 /* None */; + + var moduleContainsExecutableCode = containsExecutableCode(moduleDecl.moduleElements); + + var isDynamic = moduleDecl.stringLiteral !== null; + + if ((TypeScript.hasModifier(moduleDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(moduleDecl, context)) && !containingModuleHasExportAssignment(moduleDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(moduleDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(moduleDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var kind = isDynamic ? 32 /* DynamicModule */ : 4 /* Container */; + + var span = TypeScript.TextSpan.fromBounds(moduleDecl.start(), moduleDecl.end()); + + if (moduleDecl.stringLiteral) { + var valueText = TypeScript.quoteStr(moduleDecl.stringLiteral.valueText()); + var text = moduleDecl.stringLiteral.text(); + + var decl = new TypeScript.NormalPullDecl(valueText, text, kind, declFlags, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(moduleDecl, decl); + context.semanticInfoChain.setDeclForAST(moduleDecl.stringLiteral, decl); + context.semanticInfoChain.setASTForDecl(decl, moduleDecl.stringLiteral); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, moduleDecl.stringLiteral, context); + } + + context.pushParent(decl); + } else { + var moduleNames = getModuleNames(moduleDecl.name); + for (var i = 0, n = moduleNames.length; i < n; i++) { + var moduleName = moduleNames[i]; + + var specificFlags = declFlags; + if (i > 0) { + specificFlags |= 1 /* Exported */; + } + + var decl = new TypeScript.NormalPullDecl(moduleName.valueText(), moduleName.text(), kind, specificFlags, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(moduleDecl, decl); + context.semanticInfoChain.setDeclForAST(moduleName, decl); + context.semanticInfoChain.setASTForDecl(decl, moduleName); + + if (moduleContainsExecutableCode) { + createModuleVariableDecl(decl, moduleName, context); + } + + context.pushParent(decl); + } + } + } + + function getModuleNames(name, result) { + result = result || []; + + if (name.kind() === 121 /* QualifiedName */) { + getModuleNames(name.left, result); + result.push(name.right); + } else { + result.push(name); + } + + return result; + } + TypeScript.getModuleNames = getModuleNames; + + function createModuleVariableDecl(decl, moduleNameAST, context) { + decl.setFlags(decl.flags | getInitializationFlag(decl)); + + var valueDecl = new TypeScript.NormalPullDecl(decl.name, decl.getDisplayName(), 512 /* Variable */, decl.flags, context.getParent(), decl.getSpan()); + decl.setValueDecl(valueDecl); + context.semanticInfoChain.setASTForDecl(valueDecl, moduleNameAST); + } + + function containsExecutableCode(members) { + for (var i = 0, n = members.childCount(); i < n; i++) { + var member = members.childAt(i); + + if (member.kind() === 130 /* ModuleDeclaration */) { + var moduleDecl = member; + + if (containsExecutableCode(moduleDecl.moduleElements)) { + return true; + } + } else if (member.kind() !== 128 /* InterfaceDeclaration */ && member.kind() !== 133 /* ImportDeclaration */) { + return true; + } + } + + return false; + } + + function preCollectClassDecls(classDecl, context) { + var declFlags = 0 /* None */; + var constructorDeclKind = 512 /* Variable */; + + if ((TypeScript.hasModifier(classDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(classDecl, context)) && !containingModuleHasExportAssignment(classDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(classDecl.modifiers, 8 /* Ambient */) || isParsingAmbientModule(classDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var span = TypeScript.TextSpan.fromBounds(classDecl.start(), classDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), 8 /* Class */, declFlags, parent, span); + + var constructorDecl = new TypeScript.NormalPullDecl(classDecl.identifier.valueText(), classDecl.identifier.text(), constructorDeclKind, declFlags | 16384 /* ClassConstructorVariable */, parent, span); + + decl.setValueDecl(constructorDecl); + + context.semanticInfoChain.setDeclForAST(classDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, classDecl); + context.semanticInfoChain.setASTForDecl(constructorDecl, classDecl); + + context.pushParent(decl); + } + + function preCollectObjectTypeDecls(objectType, context) { + if (objectType.parent.kind() === 128 /* InterfaceDeclaration */) { + return; + } + + var declFlags = 0 /* None */; + + var span = TypeScript.TextSpan.fromBounds(objectType.start(), objectType.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", 8388608 /* ObjectType */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(objectType, decl); + context.semanticInfoChain.setASTForDecl(decl, objectType); + + context.pushParent(decl); + } + + function preCollectInterfaceDecls(interfaceDecl, context) { + var declFlags = 0 /* None */; + + if ((TypeScript.hasModifier(interfaceDecl.modifiers, 1 /* Exported */) || isParsingAmbientModule(interfaceDecl, context)) && !containingModuleHasExportAssignment(interfaceDecl)) { + declFlags |= 1 /* Exported */; + } + + var span = TypeScript.TextSpan.fromBounds(interfaceDecl.start(), interfaceDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(interfaceDecl.identifier.valueText(), interfaceDecl.identifier.text(), 16 /* Interface */, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(interfaceDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, interfaceDecl); + + context.pushParent(decl); + } + + function preCollectParameterDecl(argDecl, context) { + var declFlags = 0 /* None */; + + if (TypeScript.hasModifier(argDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (argDecl.questionToken !== null || argDecl.equalsValueClause !== null || argDecl.dotDotDotToken !== null) { + declFlags |= 128 /* Optional */; + } + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var span = TypeScript.TextSpan.fromBounds(argDecl.start(), argDecl.end()); + + var decl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 2048 /* Parameter */, declFlags, parent, span); + + if (argDecl.equalsValueClause) { + parent.flags |= 33554432 /* HasDefaultArgs */; + } + + if (parent.kind == 32768 /* ConstructorMethod */) { + decl.setFlag(67108864 /* ConstructorParameter */); + } + + var isPublicOrPrivate = TypeScript.hasModifier(argDecl.modifiers, 4 /* Public */ | 2 /* Private */); + var isInConstructor = parent.kind === 32768 /* ConstructorMethod */; + if (isPublicOrPrivate && isInConstructor) { + var parentsParent = context.parentChain[context.parentChain.length - 2]; + var propDecl = new TypeScript.NormalPullDecl(argDecl.identifier.valueText(), argDecl.identifier.text(), 4096 /* Property */, declFlags, parentsParent, span); + propDecl.setValueDecl(decl); + decl.setFlag(8388608 /* PropertyParameter */); + propDecl.setFlag(8388608 /* PropertyParameter */); + + if (parent.kind == 32768 /* ConstructorMethod */) { + propDecl.setFlag(67108864 /* ConstructorParameter */); + } + + context.semanticInfoChain.setASTForDecl(decl, argDecl); + context.semanticInfoChain.setASTForDecl(propDecl, argDecl); + context.semanticInfoChain.setDeclForAST(argDecl, propDecl); + } else { + context.semanticInfoChain.setASTForDecl(decl, argDecl); + context.semanticInfoChain.setDeclForAST(argDecl, decl); + } + + parent.addVariableDeclToGroup(decl); + } + + function preCollectTypeParameterDecl(typeParameterDecl, context) { + var declFlags = 0 /* None */; + + var span = TypeScript.TextSpan.fromBounds(typeParameterDecl.start(), typeParameterDecl.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(typeParameterDecl.identifier.valueText(), typeParameterDecl.identifier.text(), 8192 /* TypeParameter */, declFlags, parent, span); + context.semanticInfoChain.setASTForDecl(decl, typeParameterDecl); + context.semanticInfoChain.setDeclForAST(typeParameterDecl, decl); + } + + function createPropertySignature(propertyDecl, context) { + var declFlags = 4 /* Public */; + var parent = context.getParent(); + var declType = 4096 /* Property */; + + if (propertyDecl.questionToken !== null) { + declFlags |= 128 /* Optional */; + } + + var span = TypeScript.TextSpan.fromBounds(propertyDecl.start(), propertyDecl.end()); + + var decl = new TypeScript.NormalPullDecl(propertyDecl.propertyName.valueText(), propertyDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(propertyDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyDecl); + } + + function createMemberVariableDeclaration(memberDecl, context) { + var declFlags = 0 /* None */; + var declType = 4096 /* Property */; + + if (TypeScript.hasModifier(memberDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (TypeScript.hasModifier(memberDecl.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + var span = TypeScript.TextSpan.fromBounds(memberDecl.start(), memberDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(memberDecl.variableDeclarator.propertyName.valueText(), memberDecl.variableDeclarator.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(memberDecl, decl); + context.semanticInfoChain.setDeclForAST(memberDecl.variableDeclarator, decl); + context.semanticInfoChain.setASTForDecl(decl, memberDecl); + } + + function createVariableDeclaration(varDecl, context) { + var declFlags = 0 /* None */; + var declType = 512 /* Variable */; + + var modifiers = TypeScript.getVariableDeclaratorModifiers(varDecl); + if ((TypeScript.hasModifier(modifiers, 1 /* Exported */) || isParsingAmbientModule(varDecl, context)) && !containingModuleHasExportAssignment(varDecl)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(modifiers, 8 /* Ambient */) || isParsingAmbientModule(varDecl, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + var span = TypeScript.TextSpan.fromBounds(varDecl.start(), varDecl.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(varDecl.propertyName.valueText(), varDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(varDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, varDecl); + + if (parent) { + parent.addVariableDeclToGroup(decl); + } + } + + function preCollectVarDecls(ast, context) { + if (ast.parent.kind() === 136 /* MemberVariableDeclaration */) { + return; + } + + var varDecl = ast; + createVariableDeclaration(varDecl, context); + } + + function createFunctionTypeDeclaration(functionTypeDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 16777216 /* FunctionType */; + + var span = TypeScript.TextSpan.fromBounds(functionTypeDeclAST.start(), functionTypeDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(functionTypeDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, functionTypeDeclAST); + + context.pushParent(decl); + } + + function createConstructorTypeDeclaration(constructorTypeDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 33554432 /* ConstructorType */; + + var span = TypeScript.TextSpan.fromBounds(constructorTypeDeclAST.start(), constructorTypeDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructorTypeDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructorTypeDeclAST); + + context.pushParent(decl); + } + + function createFunctionDeclaration(funcDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 16384 /* Function */; + + if ((TypeScript.hasModifier(funcDeclAST.modifiers, 1 /* Exported */) || isParsingAmbientModule(funcDeclAST, context)) && !containingModuleHasExportAssignment(funcDeclAST)) { + declFlags |= 1 /* Exported */; + } + + if (TypeScript.hasModifier(funcDeclAST.modifiers, 8 /* Ambient */) || isParsingAmbientModule(funcDeclAST, context) || context.isDeclareFile) { + declFlags |= 8 /* Ambient */; + } + + if (!funcDeclAST.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(funcDeclAST.start(), funcDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(funcDeclAST.identifier.valueText(), funcDeclAST.identifier.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(funcDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, funcDeclAST); + + context.pushParent(decl); + } + + function createAnyFunctionExpressionDeclaration(functionExpressionDeclAST, id, context, displayName) { + if (typeof displayName === "undefined") { displayName = null; } + var declFlags = 0 /* None */; + + if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */ || functionExpressionDeclAST.kind() === 218 /* ParenthesizedArrowFunctionExpression */) { + declFlags |= 8192 /* ArrowFunction */; + } + + var span = TypeScript.TextSpan.fromBounds(functionExpressionDeclAST.start(), functionExpressionDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var name = id ? id.text() : ""; + var displayNameText = displayName ? displayName.text() : ""; + var decl = new TypeScript.PullFunctionExpressionDecl(name, declFlags, parent, span, displayNameText); + context.semanticInfoChain.setDeclForAST(functionExpressionDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, functionExpressionDeclAST); + + context.pushParent(decl); + + if (functionExpressionDeclAST.kind() === 219 /* SimpleArrowFunctionExpression */) { + var simpleArrow = functionExpressionDeclAST; + var declFlags = 4 /* Public */; + + var parent = context.getParent(); + + if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var span = TypeScript.TextSpan.fromBounds(simpleArrow.identifier.start(), simpleArrow.identifier.end()); + + var decl = new TypeScript.NormalPullDecl(simpleArrow.identifier.valueText(), simpleArrow.identifier.text(), 2048 /* Parameter */, declFlags, parent, span); + + context.semanticInfoChain.setASTForDecl(decl, simpleArrow.identifier); + context.semanticInfoChain.setDeclForAST(simpleArrow.identifier, decl); + + parent.addVariableDeclToGroup(decl); + } + } + + function createMemberFunctionDeclaration(funcDecl, context) { + var declFlags = 0 /* None */; + var declType = 65536 /* Method */; + + if (TypeScript.hasModifier(funcDecl.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(funcDecl.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + if (!funcDecl.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(funcDecl.start(), funcDecl.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(funcDecl.propertyName.valueText(), funcDecl.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(funcDecl, decl); + context.semanticInfoChain.setASTForDecl(decl, funcDecl); + + context.pushParent(decl); + } + + function createIndexSignatureDeclaration(indexSignatureDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 4194304 /* IndexSignature */; + + var span = TypeScript.TextSpan.fromBounds(indexSignatureDeclAST.start(), indexSignatureDeclAST.end()); + + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(indexSignatureDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, indexSignatureDeclAST); + + context.pushParent(decl); + } + + function createCallSignatureDeclaration(callSignature, context) { + var isChildOfObjectType = callSignature.parent && callSignature.parent.parent && callSignature.parent.kind() === 2 /* SeparatedList */ && callSignature.parent.parent.kind() === 122 /* ObjectType */; + + if (!isChildOfObjectType) { + return; + } + + var declFlags = 2048 /* Signature */; + var declType = 1048576 /* CallSignature */; + + var span = TypeScript.TextSpan.fromBounds(callSignature.start(), callSignature.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(callSignature, decl); + context.semanticInfoChain.setASTForDecl(decl, callSignature); + + context.pushParent(decl); + } + + function createMethodSignatureDeclaration(method, context) { + var declFlags = 0 /* None */; + var declType = 65536 /* Method */; + + declFlags |= 4 /* Public */; + declFlags |= 2048 /* Signature */; + + if (method.questionToken !== null) { + declFlags |= 128 /* Optional */; + } + + var span = TypeScript.TextSpan.fromBounds(method.start(), method.end()); + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl(method.propertyName.valueText(), method.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(method, decl); + context.semanticInfoChain.setASTForDecl(decl, method); + + context.pushParent(decl); + } + + function createConstructSignatureDeclaration(constructSignatureDeclAST, context) { + var declFlags = 2048 /* Signature */; + var declType = 2097152 /* ConstructSignature */; + + var span = TypeScript.TextSpan.fromBounds(constructSignatureDeclAST.start(), constructSignatureDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructSignatureDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructSignatureDeclAST); + + context.pushParent(decl); + } + + function createClassConstructorDeclaration(constructorDeclAST, context) { + var declFlags = 0 /* None */; + var declType = 32768 /* ConstructorMethod */; + + if (!constructorDeclAST.block) { + declFlags |= 2048 /* Signature */; + } + + var span = TypeScript.TextSpan.fromBounds(constructorDeclAST.start(), constructorDeclAST.end()); + + var parent = context.getParent(); + + if (parent) { + var parentFlags = parent.flags; + + if (parentFlags & 1 /* Exported */) { + declFlags |= 1 /* Exported */; + } + } + + var decl = new TypeScript.NormalPullDecl(parent.name, parent.getDisplayName(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(constructorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, constructorDeclAST); + + context.pushParent(decl); + } + + function createGetAccessorDeclaration(getAccessorDeclAST, context) { + var declFlags = 4 /* Public */; + var declType = 262144 /* GetAccessor */; + + if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(getAccessorDeclAST.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + var span = TypeScript.TextSpan.fromBounds(getAccessorDeclAST.start(), getAccessorDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(getAccessorDeclAST.propertyName.valueText(), getAccessorDeclAST.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(getAccessorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, getAccessorDeclAST); + + context.pushParent(decl); + } + + function createFunctionExpressionDeclaration(expression, context) { + createAnyFunctionExpressionDeclaration(expression, expression.identifier, context); + } + + function createSetAccessorDeclaration(setAccessorDeclAST, context) { + var declFlags = 4 /* Public */; + var declType = 524288 /* SetAccessor */; + + if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 16 /* Static */)) { + declFlags |= 16 /* Static */; + } + + if (TypeScript.hasModifier(setAccessorDeclAST.modifiers, 2 /* Private */)) { + declFlags |= 2 /* Private */; + } else { + declFlags |= 4 /* Public */; + } + + var span = TypeScript.TextSpan.fromBounds(setAccessorDeclAST.start(), setAccessorDeclAST.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(setAccessorDeclAST.propertyName.valueText(), setAccessorDeclAST.propertyName.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(setAccessorDeclAST, decl); + context.semanticInfoChain.setASTForDecl(decl, setAccessorDeclAST); + + context.pushParent(decl); + } + + function preCollectCatchDecls(ast, context) { + var declFlags = 0 /* None */; + var declType = 268435456 /* CatchBlock */; + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + + var parent = context.getParent(); + + if (parent && (parent.kind === 134217728 /* WithBlock */ || (parent.flags & 2097152 /* DeclaredInAWithBlock */))) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + + var declFlags = 0 /* None */; + var declType = 1024 /* CatchVariable */; + + var span = TypeScript.TextSpan.fromBounds(ast.identifier.start(), ast.identifier.end()); + + var parent = context.getParent(); + + if (TypeScript.hasFlag(parent.flags, 2097152 /* DeclaredInAWithBlock */)) { + declFlags |= 2097152 /* DeclaredInAWithBlock */; + } + + var decl = new TypeScript.NormalPullDecl(ast.identifier.valueText(), ast.identifier.text(), declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast.identifier, decl); + context.semanticInfoChain.setASTForDecl(decl, ast.identifier); + + if (parent) { + parent.addVariableDeclToGroup(decl); + } + } + + function preCollectWithDecls(ast, context) { + var declFlags = 0 /* None */; + var declType = 134217728 /* WithBlock */; + + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + + var parent = context.getParent(); + + var decl = new TypeScript.NormalPullDecl("", "", declType, declFlags, parent, span); + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + } + + function preCollectObjectLiteralDecls(ast, context) { + var span = TypeScript.TextSpan.fromBounds(ast.start(), ast.end()); + var decl = new TypeScript.NormalPullDecl("", "", 256 /* ObjectLiteral */, 0 /* None */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(ast, decl); + context.semanticInfoChain.setASTForDecl(decl, ast); + + context.pushParent(decl); + } + + function preCollectSimplePropertyAssignmentDecls(propertyAssignment, context) { + var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName); + var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end()); + + var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(propertyAssignment, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyAssignment); + } + + function preCollectFunctionPropertyAssignmentDecls(propertyAssignment, context) { + var assignmentText = TypeScript.getPropertyAssignmentNameTextFromIdentifier(propertyAssignment.propertyName); + var span = TypeScript.TextSpan.fromBounds(propertyAssignment.start(), propertyAssignment.end()); + + var decl = new TypeScript.NormalPullDecl(assignmentText.memberName, assignmentText.actualText, 4096 /* Property */, 4 /* Public */, context.getParent(), span); + + context.semanticInfoChain.setDeclForAST(propertyAssignment, decl); + context.semanticInfoChain.setASTForDecl(decl, propertyAssignment); + + createAnyFunctionExpressionDeclaration(propertyAssignment, propertyAssignment.propertyName, context, propertyAssignment.propertyName); + } + + function preCollectDecls(ast, context) { + switch (ast.kind()) { + case 120 /* SourceUnit */: + preCollectScriptDecls(ast, context); + break; + case 132 /* EnumDeclaration */: + preCollectEnumDecls(ast, context); + break; + case 243 /* EnumElement */: + createEnumElementDecls(ast, context); + break; + case 130 /* ModuleDeclaration */: + preCollectModuleDecls(ast, context); + break; + case 131 /* ClassDeclaration */: + preCollectClassDecls(ast, context); + break; + case 128 /* InterfaceDeclaration */: + preCollectInterfaceDecls(ast, context); + break; + case 122 /* ObjectType */: + preCollectObjectTypeDecls(ast, context); + break; + case 242 /* Parameter */: + preCollectParameterDecl(ast, context); + break; + case 136 /* MemberVariableDeclaration */: + createMemberVariableDeclaration(ast, context); + break; + case 141 /* PropertySignature */: + createPropertySignature(ast, context); + break; + case 225 /* VariableDeclarator */: + preCollectVarDecls(ast, context); + break; + case 137 /* ConstructorDeclaration */: + createClassConstructorDeclaration(ast, context); + break; + case 139 /* GetAccessor */: + createGetAccessorDeclaration(ast, context); + break; + case 140 /* SetAccessor */: + createSetAccessorDeclaration(ast, context); + break; + case 222 /* FunctionExpression */: + createFunctionExpressionDeclaration(ast, context); + break; + case 135 /* MemberFunctionDeclaration */: + createMemberFunctionDeclaration(ast, context); + break; + case 144 /* IndexSignature */: + createIndexSignatureDeclaration(ast, context); + break; + case 123 /* FunctionType */: + createFunctionTypeDeclaration(ast, context); + break; + case 125 /* ConstructorType */: + createConstructorTypeDeclaration(ast, context); + break; + case 142 /* CallSignature */: + createCallSignatureDeclaration(ast, context); + break; + case 143 /* ConstructSignature */: + createConstructSignatureDeclaration(ast, context); + break; + case 145 /* MethodSignature */: + createMethodSignatureDeclaration(ast, context); + break; + case 129 /* FunctionDeclaration */: + createFunctionDeclaration(ast, context); + break; + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + createAnyFunctionExpressionDeclaration(ast, null, context); + break; + case 133 /* ImportDeclaration */: + preCollectImportDecls(ast, context); + break; + case 238 /* TypeParameter */: + preCollectTypeParameterDecl(ast, context); + break; + case 236 /* CatchClause */: + preCollectCatchDecls(ast, context); + break; + case 163 /* WithStatement */: + preCollectWithDecls(ast, context); + break; + case 215 /* ObjectLiteralExpression */: + preCollectObjectLiteralDecls(ast, context); + break; + case 240 /* SimplePropertyAssignment */: + preCollectSimplePropertyAssignmentDecls(ast, context); + break; + case 241 /* FunctionPropertyAssignment */: + preCollectFunctionPropertyAssignmentDecls(ast, context); + break; + } + } + + function isContainer(decl) { + return decl.kind === 4 /* Container */ || decl.kind === 32 /* DynamicModule */ || decl.kind === 64 /* Enum */; + } + + function getInitializationFlag(decl) { + if (decl.kind & 4 /* Container */) { + return 32768 /* InitializedModule */; + } else if (decl.kind & 32 /* DynamicModule */) { + return 65536 /* InitializedDynamicModule */; + } + + return 0 /* None */; + } + + function hasInitializationFlag(decl) { + var kind = decl.kind; + + if (kind & 4 /* Container */) { + return (decl.flags & 32768 /* InitializedModule */) !== 0; + } else if (kind & 32 /* DynamicModule */) { + return (decl.flags & 65536 /* InitializedDynamicModule */) !== 0; + } + + return false; + } + + function postCollectDecls(ast, context) { + var currentDecl = context.getParent(); + + if (ast.kind() === 11 /* IdentifierName */ || ast.kind() === 14 /* StringLiteral */) { + if (currentDecl.kind === 4 /* Container */ || currentDecl.kind === 32 /* DynamicModule */) { + return; + } + } + + if (ast.kind() === 130 /* ModuleDeclaration */) { + var moduleDeclaration = ast; + if (moduleDeclaration.stringLiteral) { + TypeScript.Debug.assert(currentDecl.ast() === moduleDeclaration.stringLiteral); + context.popParent(); + } else { + var moduleNames = getModuleNames(moduleDeclaration.name); + for (var i = moduleNames.length - 1; i >= 0; i--) { + var moduleName = moduleNames[i]; + TypeScript.Debug.assert(currentDecl.ast() === moduleName); + context.popParent(); + currentDecl = context.getParent(); + } + } + } + + if (ast.kind() === 132 /* EnumDeclaration */) { + computeEnumElementConstantValues(ast, currentDecl, context); + } + + while (currentDecl.getParentDecl() && currentDecl.ast() === ast) { + context.popParent(); + currentDecl = context.getParent(); + } + } + + function computeEnumElementConstantValues(ast, enumDecl, context) { + TypeScript.Debug.assert(enumDecl.kind === 64 /* Enum */); + + var isAmbientEnum = TypeScript.hasFlag(enumDecl.flags, 8 /* Ambient */); + var inConstantSection = !isAmbientEnum; + var currentConstantValue = 0; + var enumMemberDecls = enumDecl.getChildDecls(); + + for (var i = 0, n = ast.enumElements.nonSeparatorCount(); i < n; i++) { + var enumElement = ast.enumElements.nonSeparatorAt(i); + var enumElementDecl = TypeScript.ArrayUtilities.first(enumMemberDecls, function (d) { + return context.semanticInfoChain.getASTForDecl(d) === enumElement; + }); + + TypeScript.Debug.assert(enumElementDecl.kind === 67108864 /* EnumMember */); + + if (enumElement.equalsValueClause === null) { + if (inConstantSection) { + enumElementDecl.constantValue = currentConstantValue; + currentConstantValue++; + } + } else { + enumElementDecl.constantValue = computeEnumElementConstantValue(enumElement.equalsValueClause.value, enumMemberDecls, context); + if (enumElementDecl.constantValue !== null && !isAmbientEnum) { + inConstantSection = true; + currentConstantValue = enumElementDecl.constantValue + 1; + } else { + inConstantSection = false; + } + } + + TypeScript.Debug.assert(enumElementDecl.constantValue !== undefined); + } + } + + function computeEnumElementConstantValue(expression, enumMemberDecls, context) { + TypeScript.Debug.assert(expression); + + if (TypeScript.isIntegerLiteralAST(expression)) { + var token; + switch (expression.kind()) { + case 164 /* PlusExpression */: + case 165 /* NegateExpression */: + token = expression.operand; + break; + default: + token = expression; + } + + var value = token.value(); + return value && expression.kind() === 165 /* NegateExpression */ ? -value : value; + } else if (context.propagateEnumConstants) { + switch (expression.kind()) { + case 11 /* IdentifierName */: + var name = expression; + var matchingEnumElement = TypeScript.ArrayUtilities.firstOrDefault(enumMemberDecls, function (d) { + return d.name === name.valueText(); + }); + + return matchingEnumElement ? matchingEnumElement.constantValue : null; + + case 202 /* LeftShiftExpression */: + var binaryExpression = expression; + var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context); + var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context); + if (left === null || right === null) { + return null; + } + + return left << right; + + case 189 /* BitwiseOrExpression */: + var binaryExpression = expression; + var left = computeEnumElementConstantValue(binaryExpression.left, enumMemberDecls, context); + var right = computeEnumElementConstantValue(binaryExpression.right, enumMemberDecls, context); + if (left === null || right === null) { + return null; + } + + return left | right; + } + + return null; + } else { + return null; + } + } + + (function (DeclarationCreator) { + function create(document, semanticInfoChain, compilationSettings) { + var declCollectionContext = new DeclCollectionContext(document, semanticInfoChain, compilationSettings.propagateEnumConstants()); + + TypeScript.getAstWalkerFactory().simpleWalk(document.sourceUnit(), preCollectDecls, postCollectDecls, declCollectionContext); + + return declCollectionContext.getParent(); + } + DeclarationCreator.create = create; + })(TypeScript.DeclarationCreator || (TypeScript.DeclarationCreator = {})); + var DeclarationCreator = TypeScript.DeclarationCreator; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var PullSymbolBinder = (function () { + function PullSymbolBinder(semanticInfoChain) { + this.semanticInfoChain = semanticInfoChain; + this.declsBeingBound = []; + } + PullSymbolBinder.prototype.getParent = function (decl, returnInstanceType) { + if (typeof returnInstanceType === "undefined") { returnInstanceType = false; } + var parentDecl = decl.getParentDecl(); + + if (parentDecl.kind == 1 /* Script */) { + return null; + } + + var parent = parentDecl.getSymbol(); + + if (!parent && parentDecl && !parentDecl.hasBeenBound()) { + this.bindDeclToPullSymbol(parentDecl); + } + + parent = parentDecl.getSymbol(); + if (parent) { + var parentDeclKind = parentDecl.kind; + if (parentDeclKind == 262144 /* GetAccessor */) { + parent = parent.getGetter(); + } else if (parentDeclKind == 524288 /* SetAccessor */) { + parent = parent.getSetter(); + } + } + + if (parent) { + if (returnInstanceType && parent.isType() && parent.isContainer()) { + var instanceSymbol = parent.getInstanceSymbol(); + + if (instanceSymbol) { + return instanceSymbol.type; + } + } + + return parent.type; + } + + return null; + }; + + PullSymbolBinder.prototype.findDeclsInContext = function (startingDecl, declKind, searchGlobally) { + if (!searchGlobally) { + var parentDecl = startingDecl.getParentDecl(); + return parentDecl.searchChildDecls(startingDecl.name, declKind); + } + + var contextSymbolPath = startingDecl.getParentPath(); + + if (contextSymbolPath.length) { + var copyOfContextSymbolPath = []; + + for (var i = 0; i < contextSymbolPath.length; i++) { + if (contextSymbolPath[i].kind & 1 /* Script */) { + continue; + } + copyOfContextSymbolPath[copyOfContextSymbolPath.length] = contextSymbolPath[i].name; + } + + return this.semanticInfoChain.findDecls(copyOfContextSymbolPath, declKind); + } + }; + + PullSymbolBinder.prototype.getExistingSymbol = function (decl, searchKind, parent) { + var lookingForValue = (searchKind & 68147712 /* SomeValue */) !== 0; + var lookingForType = (searchKind & 58728539 /* SomeType */) !== 0; + var lookingForContainer = (searchKind & 164 /* SomeContainer */) !== 0; + var name = decl.name; + if (parent) { + var isExported = (decl.flags & 1 /* Exported */) !== 0; + + var prevSymbol = null; + if (lookingForValue) { + prevSymbol = parent.findContainedNonMember(name); + } else if (lookingForType) { + prevSymbol = parent.findContainedNonMemberType(name, searchKind); + } else if (lookingForContainer) { + prevSymbol = parent.findContainedNonMemberContainer(name, searchKind); + } + var prevIsExported = !prevSymbol; + if (!prevSymbol) { + if (lookingForValue) { + prevSymbol = parent.findMember(name, false); + } else if (lookingForType) { + prevSymbol = parent.findNestedType(name, searchKind); + } else if (lookingForContainer) { + prevSymbol = parent.findNestedContainer(name, searchKind); + } + } + + if (isExported && prevIsExported) { + return prevSymbol; + } + if (prevSymbol) { + var prevDecls = prevSymbol.getDeclarations(); + var lastPrevDecl = prevDecls[prevDecls.length - 1]; + var parentDecl = decl.getParentDecl(); + var prevParentDecl = lastPrevDecl && lastPrevDecl.getParentDecl(); + if (parentDecl !== prevParentDecl) { + return null; + } + + return prevSymbol; + } + } else { + var parentDecl = decl.getParentDecl(); + if (parentDecl && parentDecl.kind === 1 /* Script */) { + return this.semanticInfoChain.findTopLevelSymbol(name, searchKind, decl); + } else { + var prevDecls = parentDecl && parentDecl.searchChildDecls(name, searchKind); + return prevDecls[0] && prevDecls[0].getSymbol(); + } + } + + return null; + }; + + PullSymbolBinder.prototype.checkThatExportsMatch = function (decl, prevSymbol, reportError) { + if (typeof reportError === "undefined") { reportError = true; } + var isExported = (decl.flags & 1 /* Exported */) !== 0; + var prevDecls = prevSymbol.getDeclarations(); + var prevIsExported = (prevDecls[prevDecls.length - 1].flags & 1 /* Exported */) !== 0; + if ((isExported !== prevIsExported) && !prevSymbol.isSignature() && (decl.kind & 7340032 /* SomeSignature */) == 0) { + if (reportError) { + var ast = this.semanticInfoChain.getASTForDecl(decl); + this.semanticInfoChain.addDiagnosticFromAST(ast, TypeScript.DiagnosticCode.All_declarations_of_merged_declaration_0_must_be_exported_or_not_exported, [decl.getDisplayName()]); + } + return false; + } + + return true; + }; + + PullSymbolBinder.prototype.bindEnumDeclarationToPullSymbol = function (enumContainerDecl) { + var enumName = enumContainerDecl.name; + + var enumContainerSymbol = null; + var enumInstanceSymbol = null; + var moduleInstanceTypeSymbol = null; + + var enumInstanceDecl = enumContainerDecl.getValueDecl(); + + var enumDeclKind = enumContainerDecl.kind; + + var parent = this.getParent(enumContainerDecl); + var parentInstanceSymbol = this.getParent(enumContainerDecl, true); + var parentDecl = enumContainerDecl.getParentDecl(); + var enumAST = this.semanticInfoChain.getASTForDecl(enumContainerDecl); + + var isExported = enumContainerDecl.flags & 1 /* Exported */; + var isInitializedModule = (enumContainerDecl.flags & 102400 /* SomeInitializedModule */) != 0; + + var createdNewSymbol = false; + + enumContainerSymbol = this.getExistingSymbol(enumContainerDecl, 64 /* Enum */, parent); + + if (enumContainerSymbol) { + if (enumContainerSymbol.kind !== enumDeclKind) { + if (isInitializedModule) { + this.semanticInfoChain.addDiagnosticFromAST(enumAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [enumContainerDecl.getDisplayName()]); + } + enumContainerSymbol = null; + } else if (!this.checkThatExportsMatch(enumContainerDecl, enumContainerSymbol)) { + enumContainerSymbol = null; + } + } + + if (enumContainerSymbol) { + enumInstanceSymbol = enumContainerSymbol.getInstanceSymbol(); + } else { + enumContainerSymbol = new TypeScript.PullContainerSymbol(enumName, enumDeclKind); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(enumContainerSymbol, 64 /* Enum */); + } + } + + enumContainerSymbol.addDeclaration(enumContainerDecl); + enumContainerDecl.setSymbol(enumContainerSymbol); + + this.semanticInfoChain.setSymbolForAST(enumAST.identifier, enumContainerSymbol); + this.semanticInfoChain.setSymbolForAST(enumAST, enumContainerSymbol); + + if (!enumInstanceSymbol && isInitializedModule) { + var variableSymbol = null; + if (parentInstanceSymbol) { + if (isExported) { + variableSymbol = parentInstanceSymbol.findMember(enumName, false); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName); + } + } else { + variableSymbol = parentInstanceSymbol.findContainedNonMember(enumName); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findMember(enumName, false); + } + } + + if (variableSymbol) { + var declarations = variableSymbol.getDeclarations(); + + if (declarations.length) { + var variableSymbolParentDecl = declarations[0].getParentDecl(); + + if (parentDecl !== variableSymbolParentDecl) { + variableSymbol = null; + } + } + } + } else if (!(enumContainerDecl.flags & 1 /* Exported */)) { + var siblingDecls = parentDecl.getChildDecls(); + var augmentedDecl = null; + + for (var i = 0; i < siblingDecls.length; i++) { + if (siblingDecls[i] == enumContainerDecl) { + break; + } + + if ((siblingDecls[i].name == enumName) && (siblingDecls[i].kind & 68147712 /* SomeValue */)) { + augmentedDecl = siblingDecls[i]; + break; + } + } + + if (augmentedDecl) { + variableSymbol = augmentedDecl.getSymbol(); + + if (variableSymbol) { + if (variableSymbol.isContainer()) { + variableSymbol = variableSymbol.getInstanceSymbol(); + } else if (variableSymbol && variableSymbol.isType()) { + variableSymbol = variableSymbol.getConstructorMethod(); + } + } + } + } + + if (variableSymbol) { + enumInstanceSymbol = variableSymbol; + moduleInstanceTypeSymbol = variableSymbol.type; + } else { + enumInstanceSymbol = new TypeScript.PullSymbol(enumName, 512 /* Variable */); + } + + enumContainerSymbol.setInstanceSymbol(enumInstanceSymbol); + + if (!moduleInstanceTypeSymbol) { + moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + enumInstanceSymbol.type = moduleInstanceTypeSymbol; + } + + moduleInstanceTypeSymbol.addDeclaration(enumContainerDecl); + + if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) { + moduleInstanceTypeSymbol.setAssociatedContainerType(enumContainerSymbol); + } + } + + var moduleDeclarations = enumContainerSymbol.getDeclarations(); + + if (moduleDeclarations.length > 1 && enumAST.enumElements.nonSeparatorCount() > 0) { + var multipleEnums = TypeScript.ArrayUtilities.where(moduleDeclarations, function (d) { + return d.kind === 64 /* Enum */; + }).length > 1; + if (multipleEnums) { + var firstVariable = enumAST.enumElements.nonSeparatorAt(0); + if (!firstVariable.equalsValueClause) { + this.semanticInfoChain.addDiagnosticFromAST(firstVariable, TypeScript.DiagnosticCode.Enums_with_multiple_declarations_must_provide_an_initializer_for_the_first_enum_element, null); + } + } + } + + if (createdNewSymbol && parent) { + if (enumContainerDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(enumContainerSymbol); + } else { + parent.addEnclosedNonMemberType(enumContainerSymbol); + } + } + + this.bindEnumIndexerDeclsToPullSymbols(enumContainerDecl, enumContainerSymbol); + + var valueDecl = enumContainerDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + + var otherDecls = this.findDeclsInContext(enumContainerDecl, enumContainerDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindEnumIndexerDeclsToPullSymbols = function (enumContainerDecl, enumContainerSymbol) { + var indexSigDecl = enumContainerDecl.getChildDecls().filter(function (decl) { + return decl.kind == 4194304 /* IndexSignature */; + })[0]; + var indexParamDecl = indexSigDecl.getChildDecls()[0]; + + var syntheticIndexerParameterSymbol = new TypeScript.PullSymbol(indexParamDecl.name, 2048 /* Parameter */); + + syntheticIndexerParameterSymbol.type = this.semanticInfoChain.numberTypeSymbol; + syntheticIndexerParameterSymbol.setResolved(); + + var syntheticIndexerSignatureSymbol = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + syntheticIndexerSignatureSymbol.addParameter(syntheticIndexerParameterSymbol); + syntheticIndexerSignatureSymbol.returnType = this.semanticInfoChain.stringTypeSymbol; + syntheticIndexerSignatureSymbol.setResolved(); + + var enumContainerInstanceTypeSymbol = enumContainerSymbol.getInstanceSymbol().type; + enumContainerInstanceTypeSymbol.addIndexSignature(syntheticIndexerSignatureSymbol); + + indexSigDecl.setSignatureSymbol(syntheticIndexerSignatureSymbol); + indexParamDecl.setSymbol(syntheticIndexerParameterSymbol); + + syntheticIndexerSignatureSymbol.addDeclaration(indexSigDecl); + syntheticIndexerParameterSymbol.addDeclaration(indexParamDecl); + }; + + PullSymbolBinder.prototype.bindModuleDeclarationToPullSymbol = function (moduleContainerDecl) { + var modName = moduleContainerDecl.name; + + var moduleContainerTypeSymbol = null; + var moduleInstanceSymbol = null; + var moduleInstanceTypeSymbol = null; + + var moduleKind = moduleContainerDecl.kind; + + var parent = this.getParent(moduleContainerDecl); + var parentInstanceSymbol = this.getParent(moduleContainerDecl, true); + var parentDecl = moduleContainerDecl.getParentDecl(); + var moduleNameAST = this.semanticInfoChain.getASTForDecl(moduleContainerDecl); + var moduleDeclAST = TypeScript.getEnclosingModuleDeclaration(moduleNameAST); + if (!moduleDeclAST) { + TypeScript.Debug.assert(moduleContainerDecl.kind === 32 /* DynamicModule */); + TypeScript.Debug.assert(moduleNameAST.kind() === 120 /* SourceUnit */); + + moduleDeclAST = moduleNameAST; + } + + var isExported = TypeScript.hasFlag(moduleContainerDecl.flags, 1 /* Exported */); + var searchKind = 164 /* SomeContainer */; + var isInitializedModule = (moduleContainerDecl.flags & 102400 /* SomeInitializedModule */) != 0; + + if (parent && moduleKind == 32 /* DynamicModule */) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_must_be_defined_in_global_context, null); + } + + var createdNewSymbol = false; + + moduleContainerTypeSymbol = this.getExistingSymbol(moduleContainerDecl, searchKind, parent); + + if (moduleContainerTypeSymbol) { + if (moduleContainerTypeSymbol.kind !== moduleKind) { + if (isInitializedModule) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [moduleContainerDecl.getDisplayName()]); + } + + moduleContainerTypeSymbol = null; + } else if (moduleKind == 32 /* DynamicModule */) { + this.semanticInfoChain.addDiagnosticFromAST(moduleNameAST, TypeScript.DiagnosticCode.Ambient_external_module_declaration_cannot_be_reopened); + } else if (!this.checkThatExportsMatch(moduleContainerDecl, moduleContainerTypeSymbol)) { + moduleContainerTypeSymbol = null; + } + } + + if (moduleContainerTypeSymbol) { + moduleInstanceSymbol = moduleContainerTypeSymbol.getInstanceSymbol(); + } else { + moduleContainerTypeSymbol = new TypeScript.PullContainerSymbol(modName, moduleKind); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(moduleContainerTypeSymbol, searchKind); + } + } + + moduleContainerTypeSymbol.addDeclaration(moduleContainerDecl); + moduleContainerDecl.setSymbol(moduleContainerTypeSymbol); + + this.semanticInfoChain.setSymbolForAST(moduleNameAST, moduleContainerTypeSymbol); + this.semanticInfoChain.setSymbolForAST(moduleDeclAST, moduleContainerTypeSymbol); + + if (!moduleInstanceSymbol && isInitializedModule) { + var variableSymbol = null; + if (parentInstanceSymbol) { + if (isExported) { + variableSymbol = parentInstanceSymbol.findMember(modName, false); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findContainedNonMember(modName); + } + } else { + variableSymbol = parentInstanceSymbol.findContainedNonMember(modName); + + if (!variableSymbol) { + variableSymbol = parentInstanceSymbol.findMember(modName, false); + } + } + + if (variableSymbol) { + var declarations = variableSymbol.getDeclarations(); + + if (declarations.length) { + var variableSymbolParentDecl = declarations[0].getParentDecl(); + + if (parentDecl !== variableSymbolParentDecl) { + variableSymbol = null; + } + } + } + } else if (!isExported) { + var siblingDecls = parentDecl.getChildDecls(); + + for (var i = 0; i < siblingDecls.length; i++) { + var sibling = siblingDecls[i]; + if (sibling !== moduleContainerDecl && sibling.name === modName && TypeScript.hasFlag(sibling.kind, 68147712 /* SomeValue */)) { + if (sibling.hasSymbol()) { + variableSymbol = sibling.getSymbol(); + if (variableSymbol.isContainer()) { + variableSymbol = variableSymbol.getInstanceSymbol(); + } else if (variableSymbol && variableSymbol.isType()) { + variableSymbol = variableSymbol.getConstructorMethod(); + } + + break; + } + } + } + } + + if (variableSymbol) { + moduleInstanceSymbol = variableSymbol; + moduleInstanceTypeSymbol = variableSymbol.type; + } else { + moduleInstanceSymbol = new TypeScript.PullSymbol(modName, 512 /* Variable */); + } + + moduleContainerTypeSymbol.setInstanceSymbol(moduleInstanceSymbol); + + if (!moduleInstanceTypeSymbol) { + moduleInstanceTypeSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + moduleInstanceSymbol.type = moduleInstanceTypeSymbol; + } + + moduleInstanceTypeSymbol.addDeclaration(moduleContainerDecl); + + if (!moduleInstanceTypeSymbol.getAssociatedContainerType()) { + moduleInstanceTypeSymbol.setAssociatedContainerType(moduleContainerTypeSymbol); + } + } + + var moduleDeclarations = moduleContainerTypeSymbol.getDeclarations(); + + if (createdNewSymbol) { + if (parent) { + if (moduleContainerDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberContainer(moduleContainerTypeSymbol); + } else { + parent.addEnclosedNonMemberContainer(moduleContainerTypeSymbol); + } + } + } + + var valueDecl = moduleContainerDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + + if (!valueDecl.hasSymbol()) { + valueDecl.setSymbol(moduleInstanceSymbol); + if (!moduleInstanceSymbol.hasDeclaration(valueDecl)) { + moduleInstanceSymbol.addDeclaration(valueDecl); + } + } + } + + var otherDecls = this.findDeclsInContext(moduleContainerDecl, moduleContainerDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindImportDeclaration = function (importDeclaration) { + var declFlags = importDeclaration.flags; + var declKind = importDeclaration.kind; + var importDeclAST = this.semanticInfoChain.getASTForDecl(importDeclaration); + + var isExported = false; + var importSymbol = null; + var declName = importDeclaration.name; + var parentHadSymbol = false; + var parent = this.getParent(importDeclaration); + + importSymbol = this.getExistingSymbol(importDeclaration, 164 /* SomeContainer */, parent); + + if (importSymbol) { + parentHadSymbol = true; + } + + if (importSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(importDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [importDeclaration.getDisplayName()]); + importSymbol = null; + } + + if (!importSymbol) { + importSymbol = new TypeScript.PullTypeAliasSymbol(declName); + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(importSymbol, 164 /* SomeContainer */); + } + } + + importSymbol.addDeclaration(importDeclaration); + importDeclaration.setSymbol(importSymbol); + + this.semanticInfoChain.setSymbolForAST(importDeclAST, importSymbol); + + if (parent && !parentHadSymbol) { + if (declFlags & 1 /* Exported */) { + parent.addEnclosedMemberContainer(importSymbol); + } else { + parent.addEnclosedNonMemberContainer(importSymbol); + } + } + }; + + PullSymbolBinder.prototype.bindClassDeclarationToPullSymbol = function (classDecl) { + var className = classDecl.name; + var classSymbol = null; + + var constructorSymbol = null; + var constructorTypeSymbol = null; + + var classAST = this.semanticInfoChain.getASTForDecl(classDecl); + + var parent = this.getParent(classDecl); + var parentDecl = classDecl.getParentDecl(); + var isExported = classDecl.flags & 1 /* Exported */; + var isGeneric = false; + + classSymbol = this.getExistingSymbol(classDecl, 58728539 /* SomeType */, parent); + + if (classSymbol && classSymbol.kind === 16 /* Interface */) { + this.semanticInfoChain.addDiagnosticFromAST(classAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [classDecl.getDisplayName()]); + classSymbol = null; + } + + var decls; + + classSymbol = new TypeScript.PullTypeSymbol(className, 8 /* Class */); + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(classSymbol, 8 /* Class */); + } + + classSymbol.addDeclaration(classDecl); + + classDecl.setSymbol(classSymbol); + + this.semanticInfoChain.setSymbolForAST(classAST.identifier, classSymbol); + this.semanticInfoChain.setSymbolForAST(classAST, classSymbol); + + if (parent) { + if (classDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(classSymbol); + } else { + parent.addEnclosedNonMemberType(classSymbol); + } + } + + constructorSymbol = classSymbol.getConstructorMethod(); + constructorTypeSymbol = constructorSymbol ? constructorSymbol.type : null; + + if (!constructorSymbol) { + var siblingValueDecls = null; + if (parentDecl) { + siblingValueDecls = parentDecl.searchChildDecls(className, 68147712 /* SomeValue */); + + if (siblingValueDecls && siblingValueDecls[0] && siblingValueDecls[0].hasSymbol()) { + constructorSymbol = siblingValueDecls[0].getSymbol(); + } + } + + if (constructorSymbol) { + constructorTypeSymbol = constructorSymbol.type; + } else { + constructorSymbol = new TypeScript.PullSymbol(className, 32768 /* ConstructorMethod */); + constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + constructorSymbol.setIsSynthesized(); + constructorSymbol.type = constructorTypeSymbol; + } + + classSymbol.setConstructorMethod(constructorSymbol); + classSymbol.setHasDefaultConstructor(); + } + + if (constructorSymbol.getIsSynthesized()) { + constructorSymbol.addDeclaration(classDecl.getValueDecl()); + constructorTypeSymbol.addDeclaration(classDecl); + } else { + classSymbol.setHasDefaultConstructor(false); + } + + constructorTypeSymbol.setAssociatedContainerType(classSymbol); + + var typeParameters = classDecl.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = classSymbol.findTypeParameter(typeParameters[i].name); + + if (typeParameter != null) { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + classSymbol.addTypeParameter(typeParameter); + constructorTypeSymbol.addConstructorTypeParameter(typeParameter); + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + var valueDecl = classDecl.getValueDecl(); + + if (valueDecl) { + valueDecl.ensureSymbolIsBound(); + } + + this.bindStaticPrototypePropertyOfClass(classSymbol, constructorTypeSymbol); + }; + + PullSymbolBinder.prototype.bindInterfaceDeclarationToPullSymbol = function (interfaceDecl) { + var interfaceName = interfaceDecl.name; + var interfaceSymbol = null; + + var interfaceAST = this.semanticInfoChain.getASTForDecl(interfaceDecl); + var createdNewSymbol = false; + var parent = this.getParent(interfaceDecl); + + var acceptableSharedKind = 16 /* Interface */; + + interfaceSymbol = this.getExistingSymbol(interfaceDecl, 58728539 /* SomeType */, parent); + + if (interfaceSymbol) { + if (!(interfaceSymbol.kind & acceptableSharedKind)) { + this.semanticInfoChain.addDiagnosticFromAST(interfaceAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [interfaceDecl.getDisplayName()]); + interfaceSymbol = null; + } else if (!this.checkThatExportsMatch(interfaceDecl, interfaceSymbol)) { + interfaceSymbol = null; + } + } + + if (!interfaceSymbol) { + interfaceSymbol = new TypeScript.PullTypeSymbol(interfaceName, 16 /* Interface */); + createdNewSymbol = true; + + if (!parent) { + this.semanticInfoChain.cacheGlobalSymbol(interfaceSymbol, acceptableSharedKind); + } + } + + interfaceSymbol.addDeclaration(interfaceDecl); + interfaceDecl.setSymbol(interfaceSymbol); + + if (createdNewSymbol) { + if (parent) { + if (interfaceDecl.flags & 1 /* Exported */) { + parent.addEnclosedMemberType(interfaceSymbol); + } else { + parent.addEnclosedNonMemberType(interfaceSymbol); + } + } + } + + var typeParameters = interfaceDecl.getTypeParameters(); + var typeParameter; + var typeParameterDecls = null; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = interfaceSymbol.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + interfaceSymbol.addTypeParameter(typeParameter); + } else { + typeParameterDecls = typeParameter.getDeclarations(); + + for (var j = 0; j < typeParameterDecls.length; j++) { + var typeParameterDeclParent = typeParameterDecls[j].getParentDecl(); + + if (typeParameterDeclParent && typeParameterDeclParent === interfaceDecl) { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameterDecls[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + + break; + } + } + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + var otherDecls = this.findDeclsInContext(interfaceDecl, interfaceDecl.kind, true); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindObjectTypeDeclarationToPullSymbol = function (objectDecl) { + var objectSymbolAST = this.semanticInfoChain.getASTForDecl(objectDecl); + + var objectSymbol = new TypeScript.PullTypeSymbol("", 8388608 /* ObjectType */); + + objectSymbol.addDeclaration(objectDecl); + objectDecl.setSymbol(objectSymbol); + + this.semanticInfoChain.setSymbolForAST(objectSymbolAST, objectSymbol); + + var childDecls = objectDecl.getChildDecls(); + + for (var i = 0; i < childDecls.length; i++) { + this.bindDeclToPullSymbol(childDecls[i]); + } + }; + + PullSymbolBinder.prototype.bindConstructorTypeDeclarationToPullSymbol = function (constructorTypeDeclaration) { + var declKind = constructorTypeDeclaration.kind; + var declFlags = constructorTypeDeclaration.flags; + var constructorTypeAST = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration); + + var constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + + constructorTypeDeclaration.setSymbol(constructorTypeSymbol); + constructorTypeSymbol.addDeclaration(constructorTypeDeclaration); + this.semanticInfoChain.setSymbolForAST(constructorTypeAST, constructorTypeSymbol); + + var signature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + + var funcDecl = this.semanticInfoChain.getASTForDecl(constructorTypeDeclaration); + if (TypeScript.lastParameterIsRest(funcDecl.parameterList)) { + signature.hasVarArgs = true; + } + + signature.addDeclaration(constructorTypeDeclaration); + constructorTypeDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.parameterList), constructorTypeSymbol, signature); + + constructorTypeSymbol.addConstructSignature(signature); + + var typeParameters = constructorTypeDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = constructorTypeSymbol.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, false); + + constructorTypeSymbol.addConstructorTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + }; + + PullSymbolBinder.prototype.bindVariableDeclarationToPullSymbol = function (variableDeclaration) { + var declFlags = variableDeclaration.flags; + var declKind = variableDeclaration.kind; + var varDeclAST = this.semanticInfoChain.getASTForDecl(variableDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var variableSymbol = null; + + var declName = variableDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(variableDeclaration, true); + + var parentDecl = variableDeclaration.getParentDecl(); + + var isImplicit = (declFlags & 118784 /* ImplicitVariable */) !== 0; + var isModuleValue = (declFlags & (32768 /* InitializedModule */)) != 0; + var isEnumValue = (declFlags & 4096 /* Enum */) != 0; + var isClassConstructorVariable = (declFlags & 16384 /* ClassConstructorVariable */) != 0; + + variableSymbol = this.getExistingSymbol(variableDeclaration, 68147712 /* SomeValue */, parent); + + if (variableSymbol && !variableSymbol.isType()) { + parentHadSymbol = true; + } + + var decl; + var decls; + var ast; + var members; + + if (variableSymbol) { + var prevKind = variableSymbol.kind; + var prevIsEnum = variableSymbol.anyDeclHasFlag(4096 /* Enum */); + var prevIsClassConstructorVariable = variableSymbol.anyDeclHasFlag(16384 /* ClassConstructorVariable */); + var prevIsModuleValue = variableSymbol.allDeclsHaveFlag(32768 /* InitializedModule */); + var prevIsImplicit = variableSymbol.anyDeclHasFlag(118784 /* ImplicitVariable */); + var prevIsFunction = prevKind == 16384 /* Function */; + var prevIsAmbient = variableSymbol.allDeclsHaveFlag(8 /* Ambient */); + var isAmbientOrPrevIsAmbient = prevIsAmbient || (variableDeclaration.flags & 8 /* Ambient */) != 0; + var prevDecl = variableSymbol.getDeclarations()[0]; + var prevParentDecl = prevDecl.getParentDecl(); + var bothAreGlobal = parentDecl && (parentDecl.kind == 1 /* Script */) && (prevParentDecl.kind == 1 /* Script */); + var shareParent = bothAreGlobal || prevDecl.getParentDecl() == variableDeclaration.getParentDecl(); + var prevIsParam = shareParent && prevKind == 2048 /* Parameter */ && declKind == 512 /* Variable */; + + var acceptableRedeclaration = prevIsParam || (isImplicit && ((!isEnumValue && !isClassConstructorVariable && prevIsFunction) || ((isModuleValue || isEnumValue) && (prevIsModuleValue || prevIsEnum)) || (isClassConstructorVariable && prevIsModuleValue && isAmbientOrPrevIsAmbient) || (isModuleValue && prevIsClassConstructorVariable))); + + if (acceptableRedeclaration && (prevIsClassConstructorVariable || prevIsFunction) && !isAmbientOrPrevIsAmbient) { + if (prevDecl.fileName() != variableDeclaration.fileName()) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Module_0_cannot_merge_with_previous_declaration_of_1_in_a_different_file_2, [declName, declName, prevDecl.fileName()])); + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } + } + + if (!acceptableRedeclaration || prevIsParam) { + if (!prevIsParam && (isImplicit || prevIsImplicit || (prevKind & 1032192 /* SomeFunction */) !== 0) || !shareParent) { + var diagnostic = TypeScript.diagnosticFromDecl(variableDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [variableDeclaration.getDisplayName()]); + this.semanticInfoChain.addDiagnostic(diagnostic); + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } else { + this.checkThatExportsMatch(variableDeclaration, variableSymbol); + variableSymbol = null; + parentHadSymbol = false; + } + } + + if (variableSymbol && !(variableSymbol.type && variableSymbol.type.isError()) && !this.checkThatExportsMatch(variableDeclaration, variableSymbol, !(isModuleValue && prevIsModuleValue))) { + variableSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(declName); + } + } + + if ((declFlags & 118784 /* ImplicitVariable */) === 0) { + if (!variableSymbol) { + variableSymbol = new TypeScript.PullSymbol(declName, declKind); + if (!parent && parentDecl.kind === 1 /* Script */) { + this.semanticInfoChain.cacheGlobalSymbol(variableSymbol, declKind); + } + } + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + this.semanticInfoChain.setSymbolForAST(varDeclAST.propertyName, variableSymbol); + this.semanticInfoChain.setSymbolForAST(varDeclAST, variableSymbol); + } else if (!parentHadSymbol) { + if (isClassConstructorVariable) { + var classTypeSymbol = variableSymbol; + + if (parent) { + members = parent.getMembers(); + + for (var i = 0; i < members.length; i++) { + if ((members[i].name === declName) && (members[i].kind === 8 /* Class */)) { + classTypeSymbol = members[i]; + break; + } + } + } + + if (!classTypeSymbol) { + var parentDecl = variableDeclaration.getParentDecl(); + + if (parentDecl) { + var childDecls = parentDecl.searchChildDecls(declName, 58728539 /* SomeType */); + + if (childDecls.length) { + for (var i = 0; i < childDecls.length; i++) { + if (childDecls[i].getValueDecl() === variableDeclaration) { + classTypeSymbol = childDecls[i].getSymbol(); + } + } + } + } + + if (!classTypeSymbol) { + classTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 58728539 /* SomeType */, variableDeclaration); + } + } + + if (classTypeSymbol && (classTypeSymbol.kind !== 8 /* Class */)) { + classTypeSymbol = null; + } + + if (classTypeSymbol && classTypeSymbol.isClass()) { + variableSymbol = classTypeSymbol.getConstructorMethod(); + variableDeclaration.setSymbol(variableSymbol); + + decls = classTypeSymbol.getDeclarations(); + + if (decls.length) { + decl = decls[decls.length - 1]; + ast = this.semanticInfoChain.getASTForDecl(decl); + } + } else { + if (!variableSymbol) { + variableSymbol = new TypeScript.PullSymbol(declName, declKind); + } + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + variableSymbol.type = this.semanticInfoChain.anyTypeSymbol; + } + } else if (declFlags & 102400 /* SomeInitializedModule */) { + var moduleContainerTypeSymbol = null; + var moduleParent = this.getParent(variableDeclaration); + + if (moduleParent) { + members = moduleParent.getMembers(); + + for (var i = 0; i < members.length; i++) { + if ((members[i].name === declName) && (members[i].isContainer())) { + moduleContainerTypeSymbol = members[i]; + break; + } + } + } + + if (!moduleContainerTypeSymbol) { + var parentDecl = variableDeclaration.getParentDecl(); + + if (parentDecl) { + var searchKind = (declFlags & (32768 /* InitializedModule */ | 65536 /* InitializedDynamicModule */)) ? 164 /* SomeContainer */ : 64 /* Enum */; + var childDecls = parentDecl.searchChildDecls(declName, searchKind); + + if (childDecls.length) { + for (var i = 0; i < childDecls.length; i++) { + if (childDecls[i].getValueDecl() === variableDeclaration) { + moduleContainerTypeSymbol = childDecls[i].getSymbol(); + } + } + } + } + if (!moduleContainerTypeSymbol) { + moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 164 /* SomeContainer */, variableDeclaration); + + if (!moduleContainerTypeSymbol) { + moduleContainerTypeSymbol = this.semanticInfoChain.findTopLevelSymbol(declName, 64 /* Enum */, variableDeclaration); + } + } + } + + if (moduleContainerTypeSymbol && (!moduleContainerTypeSymbol.isContainer())) { + moduleContainerTypeSymbol = null; + } + + if (moduleContainerTypeSymbol) { + variableSymbol = moduleContainerTypeSymbol.getInstanceSymbol(); + + if (!variableSymbol.hasDeclaration(variableDeclaration)) { + variableSymbol.addDeclaration(variableDeclaration); + } + variableDeclaration.setSymbol(variableSymbol); + } else { + TypeScript.Debug.assert(false, "Attempted to bind invalid implicit variable symbol"); + } + } + } else { + if (!variableSymbol.hasDeclaration(variableDeclaration)) { + variableSymbol.addDeclaration(variableDeclaration); + } + variableDeclaration.setSymbol(variableSymbol); + } + + if (parent && !parentHadSymbol) { + if (declFlags & 1 /* Exported */) { + parent.addMember(variableSymbol); + } else { + parent.addEnclosedNonMember(variableSymbol); + } + } + + var otherDecls = this.findDeclsInContext(variableDeclaration, variableDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindCatchVariableToPullSymbol = function (variableDeclaration) { + var declFlags = variableDeclaration.flags; + var declKind = variableDeclaration.kind; + var identifier = this.semanticInfoChain.getASTForDecl(variableDeclaration); + + var declName = variableDeclaration.name; + + var variableSymbol = new TypeScript.PullSymbol(declName, declKind); + + variableSymbol.addDeclaration(variableDeclaration); + variableDeclaration.setSymbol(variableSymbol); + + variableSymbol.type = this.semanticInfoChain.anyTypeSymbol; + + this.semanticInfoChain.setSymbolForAST(identifier, variableSymbol); + }; + + PullSymbolBinder.prototype.bindEnumMemberDeclarationToPullSymbol = function (propertyDeclaration) { + var declFlags = propertyDeclaration.flags; + var declKind = propertyDeclaration.kind; + var propDeclAST = this.semanticInfoChain.getASTForDecl(propertyDeclaration); + + var declName = propertyDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(propertyDeclaration, true); + + var propertySymbol = parent.findMember(declName, false); + + if (propertySymbol) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(propertyDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [propertyDeclaration.getDisplayName()])); + } + + if (propertySymbol) { + parentHadSymbol = true; + } + + if (!parentHadSymbol) { + propertySymbol = new TypeScript.PullSymbol(declName, declKind); + } + + propertySymbol.addDeclaration(propertyDeclaration); + propertyDeclaration.setSymbol(propertySymbol); + + this.semanticInfoChain.setSymbolForAST(propDeclAST.propertyName, propertySymbol); + this.semanticInfoChain.setSymbolForAST(propDeclAST, propertySymbol); + + if (parent && !parentHadSymbol) { + parent.addMember(propertySymbol); + } + }; + + PullSymbolBinder.prototype.bindPropertyDeclarationToPullSymbol = function (propertyDeclaration) { + var declFlags = propertyDeclaration.flags; + var declKind = propertyDeclaration.kind; + + var ast = this.semanticInfoChain.getASTForDecl(propertyDeclaration); + var astName = ast.kind() === 136 /* MemberVariableDeclaration */ ? ast.variableDeclarator.propertyName : ast.kind() === 141 /* PropertySignature */ ? ast.propertyName : ast.kind() === 242 /* Parameter */ ? ast.identifier : ast.propertyName; + + var isStatic = false; + var isOptional = false; + + var propertySymbol = null; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + if (TypeScript.hasFlag(declFlags, 128 /* Optional */)) { + isOptional = true; + } + + var declName = propertyDeclaration.name; + + var parentHadSymbol = false; + + var parent = this.getParent(propertyDeclaration, true); + + if (parent.isClass() && isStatic) { + parent = parent.getConstructorMethod().type; + } + + propertySymbol = parent.findMember(declName, false); + + if (propertySymbol) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(propertyDeclaration, TypeScript.DiagnosticCode.Duplicate_identifier_0, [propertyDeclaration.getDisplayName()])); + } + + if (propertySymbol) { + parentHadSymbol = true; + } + + var classTypeSymbol; + + if (!parentHadSymbol) { + propertySymbol = new TypeScript.PullSymbol(declName, declKind); + } + + propertySymbol.addDeclaration(propertyDeclaration); + propertyDeclaration.setSymbol(propertySymbol); + + this.semanticInfoChain.setSymbolForAST(astName, propertySymbol); + this.semanticInfoChain.setSymbolForAST(ast, propertySymbol); + + if (isOptional) { + propertySymbol.isOptional = true; + } + + if (parent && !parentHadSymbol) { + parent.addMember(propertySymbol); + } + }; + + PullSymbolBinder.prototype.bindParameterSymbols = function (functionDeclaration, parameterList, funcType, signatureSymbol) { + var parameters = []; + var params = TypeScript.createIntrinsicsObject(); + var funcDecl = this.semanticInfoChain.getDeclForAST(functionDeclaration); + + if (parameterList) { + for (var i = 0, n = parameterList.length; i < n; i++) { + var argDecl = parameterList.astAt(i); + var id = parameterList.identifierAt(i); + var decl = this.semanticInfoChain.getDeclForAST(argDecl); + var isProperty = TypeScript.hasFlag(decl.flags, 8388608 /* PropertyParameter */); + var parameterSymbol = new TypeScript.PullSymbol(id.valueText(), 2048 /* Parameter */); + + if ((i === (n - 1)) && parameterList.lastParameterIsRest()) { + parameterSymbol.isVarArg = true; + } + + if (decl.flags & 128 /* Optional */) { + parameterSymbol.isOptional = true; + } + + if (params[id.valueText()]) { + this.semanticInfoChain.addDiagnosticFromAST(argDecl, TypeScript.DiagnosticCode.Duplicate_identifier_0, [id.text()]); + } else { + params[id.valueText()] = true; + } + if (decl) { + if (isProperty) { + decl.ensureSymbolIsBound(); + var valDecl = decl.getValueDecl(); + + if (valDecl) { + valDecl.setSymbol(parameterSymbol); + parameterSymbol.addDeclaration(valDecl); + } + } else { + parameterSymbol.addDeclaration(decl); + decl.setSymbol(parameterSymbol); + } + } + + signatureSymbol.addParameter(parameterSymbol, parameterSymbol.isOptional); + + if (signatureSymbol.isDefinition()) { + funcType.addEnclosedNonMember(parameterSymbol); + } + } + } + }; + + PullSymbolBinder.prototype.bindFunctionDeclarationToPullSymbol = function (functionDeclaration) { + var declKind = functionDeclaration.kind; + var declFlags = functionDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(functionDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = functionDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(functionDeclaration, true); + var parentDecl = functionDeclaration.getParentDecl(); + var parentHadSymbol = false; + + var functionSymbol = null; + var functionTypeSymbol = null; + + functionSymbol = this.getExistingSymbol(functionDeclaration, 68147712 /* SomeValue */, parent); + + if (functionSymbol) { + var previousIsAmbient = functionSymbol.allDeclsHaveFlag(8 /* Ambient */); + var isAmbientOrPreviousIsAmbient = previousIsAmbient || functionDeclaration.flags & 8 /* Ambient */; + var acceptableRedeclaration = functionSymbol.kind === 16384 /* Function */ && (isSignature || functionSymbol.allDeclsHaveFlag(2048 /* Signature */)) || functionSymbol.allDeclsHaveFlag(32768 /* InitializedModule */) && isAmbientOrPreviousIsAmbient; + if (!acceptableRedeclaration) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [functionDeclaration.getDisplayName()]); + functionSymbol.type = this.semanticInfoChain.getResolver().getNewErrorTypeSymbol(funcName); + } + } + + if (functionSymbol) { + functionTypeSymbol = functionSymbol.type; + parentHadSymbol = true; + } + + if (!functionSymbol) { + functionSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + } + + if (!functionTypeSymbol) { + functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + functionSymbol.type = functionTypeSymbol; + functionTypeSymbol.setFunctionSymbol(functionSymbol); + } + + functionDeclaration.setSymbol(functionSymbol); + functionSymbol.addDeclaration(functionDeclaration); + functionTypeSymbol.addDeclaration(functionDeclaration); + + this.semanticInfoChain.setSymbolForAST(funcDeclAST.identifier, functionSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, functionSymbol); + + if (parent && !parentHadSymbol) { + if (isExported) { + parent.addMember(functionSymbol); + } else { + parent.addEnclosedNonMember(functionSymbol); + } + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(functionDeclaration); + functionDeclaration.setSignatureSymbol(signature); + + if (TypeScript.lastParameterIsRest(funcDeclAST.callSignature.parameterList)) { + signature.hasVarArgs = true; + } + + var funcDecl = this.semanticInfoChain.getASTForDecl(functionDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.callSignature.parameterList), functionTypeSymbol, signature); + + var typeParameters = functionDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + functionTypeSymbol.addCallSignature(signature); + + var otherDecls = this.findDeclsInContext(functionDeclaration, functionDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindFunctionExpressionToPullSymbol = function (functionExpressionDeclaration) { + var declKind = functionExpressionDeclaration.kind; + var declFlags = functionExpressionDeclaration.flags; + var ast = this.semanticInfoChain.getASTForDecl(functionExpressionDeclaration); + + var parameters = ast.kind() === 219 /* SimpleArrowFunctionExpression */ ? TypeScript.Parameters.fromIdentifier(ast.identifier) : TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(ast)); + var funcExpAST = ast; + + var functionName = declKind == 131072 /* FunctionExpression */ ? functionExpressionDeclaration.getFunctionExpressionName() : functionExpressionDeclaration.name; + var functionSymbol = new TypeScript.PullSymbol(functionName, declKind); + var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + functionTypeSymbol.setFunctionSymbol(functionSymbol); + + functionSymbol.type = functionTypeSymbol; + + functionExpressionDeclaration.setSymbol(functionSymbol); + functionSymbol.addDeclaration(functionExpressionDeclaration); + functionTypeSymbol.addDeclaration(functionExpressionDeclaration); + + var name = funcExpAST.kind() === 222 /* FunctionExpression */ ? funcExpAST.identifier : funcExpAST.kind() === 241 /* FunctionPropertyAssignment */ ? funcExpAST.propertyName : null; + if (name) { + this.semanticInfoChain.setSymbolForAST(name, functionSymbol); + } + + this.semanticInfoChain.setSymbolForAST(funcExpAST, functionSymbol); + + var signature = new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + if (parameters.lastParameterIsRest()) { + signature.hasVarArgs = true; + } + + var typeParameters = functionExpressionDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(functionExpressionDeclaration); + functionExpressionDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcExpAST, parameters, functionTypeSymbol, signature); + + functionTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindFunctionTypeDeclarationToPullSymbol = function (functionTypeDeclaration) { + var declKind = functionTypeDeclaration.kind; + var declFlags = functionTypeDeclaration.flags; + var funcTypeAST = this.semanticInfoChain.getASTForDecl(functionTypeDeclaration); + + var functionTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + + functionTypeDeclaration.setSymbol(functionTypeSymbol); + functionTypeSymbol.addDeclaration(functionTypeDeclaration); + this.semanticInfoChain.setSymbolForAST(funcTypeAST, functionTypeSymbol); + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + if (TypeScript.lastParameterIsRest(funcTypeAST.parameterList)) { + signature.hasVarArgs = true; + } + + var typeParameters = functionTypeDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = signature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + signature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.name]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(functionTypeDeclaration); + functionTypeDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcTypeAST, TypeScript.Parameters.fromParameterList(funcTypeAST.parameterList), functionTypeSymbol, signature); + + functionTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindMethodDeclarationToPullSymbol = function (methodDeclaration) { + var declKind = methodDeclaration.kind; + var declFlags = methodDeclaration.flags; + var methodAST = this.semanticInfoChain.getASTForDecl(methodDeclaration); + + var isPrivate = (declFlags & 2 /* Private */) !== 0; + var isStatic = (declFlags & 16 /* Static */) !== 0; + var isOptional = (declFlags & 128 /* Optional */) !== 0; + + var methodName = methodDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(methodDeclaration, true); + var parentHadSymbol = false; + + var methodSymbol = null; + var methodTypeSymbol = null; + + if (parent.isClass() && isStatic) { + parent = parent.getConstructorMethod().type; + } + + methodSymbol = parent.findMember(methodName, false); + + if (methodSymbol && (methodSymbol.kind !== 65536 /* Method */ || (!isSignature && !methodSymbol.allDeclsHaveFlag(2048 /* Signature */)))) { + this.semanticInfoChain.addDiagnosticFromAST(methodAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [methodDeclaration.getDisplayName()]); + methodSymbol = null; + } + + if (methodSymbol) { + methodTypeSymbol = methodSymbol.type; + parentHadSymbol = true; + } + + if (!methodSymbol) { + methodSymbol = new TypeScript.PullSymbol(methodName, 65536 /* Method */); + } + + if (!methodTypeSymbol) { + methodTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + methodSymbol.type = methodTypeSymbol; + methodTypeSymbol.setFunctionSymbol(methodSymbol); + } + + methodDeclaration.setSymbol(methodSymbol); + methodSymbol.addDeclaration(methodDeclaration); + methodTypeSymbol.addDeclaration(methodDeclaration); + + var nameAST = methodAST.kind() === 135 /* MemberFunctionDeclaration */ ? methodAST.propertyName : methodAST.propertyName; + + TypeScript.Debug.assert(nameAST); + + this.semanticInfoChain.setSymbolForAST(nameAST, methodSymbol); + this.semanticInfoChain.setSymbolForAST(methodAST, methodSymbol); + + if (isOptional) { + methodSymbol.isOptional = true; + } + + if (!parentHadSymbol) { + parent.addMember(methodSymbol); + } + + var sigKind = 1048576 /* CallSignature */; + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(sigKind) : new TypeScript.PullDefinitionSignatureSymbol(sigKind); + + var parameterList = TypeScript.getParameterList(methodAST); + if (TypeScript.lastParameterIsRest(parameterList)) { + signature.hasVarArgs = true; + } + + var typeParameters = methodDeclaration.getTypeParameters(); + var typeParameter; + var typeParameterName; + var typeParameterAST; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterName = typeParameters[i].name; + typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameters[i]); + + typeParameter = signature.findTypeParameter(typeParameterName); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameterName, true); + signature.addTypeParameter(typeParameter); + } else { + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + signature.addDeclaration(methodDeclaration); + methodDeclaration.setSignatureSymbol(signature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(methodDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(funcDecl)), methodTypeSymbol, signature); + + methodTypeSymbol.addCallSignature(signature); + + var otherDecls = this.findDeclsInContext(methodDeclaration, methodDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + }; + + PullSymbolBinder.prototype.bindStaticPrototypePropertyOfClass = function (classTypeSymbol, constructorTypeSymbol) { + var prototypeStr = "prototype"; + + var prototypeSymbol = constructorTypeSymbol.findMember(prototypeStr, false); + if (prototypeSymbol && !prototypeSymbol.getIsSynthesized()) { + this.semanticInfoChain.addDiagnostic(TypeScript.diagnosticFromDecl(prototypeSymbol.getDeclarations()[0], TypeScript.DiagnosticCode.Duplicate_identifier_0, [prototypeSymbol.getDisplayName()])); + } + + if (!prototypeSymbol || !prototypeSymbol.getIsSynthesized()) { + var prototypeDecl = new TypeScript.PullSynthesizedDecl(prototypeStr, prototypeStr, 4096 /* Property */, 4 /* Public */ | 16 /* Static */, constructorTypeSymbol.getDeclarations()[0], classTypeSymbol.getDeclarations()[0].getSpan(), this.semanticInfoChain); + + prototypeSymbol = new TypeScript.PullSymbol(prototypeStr, 4096 /* Property */); + prototypeSymbol.setIsSynthesized(); + prototypeSymbol.addDeclaration(prototypeDecl); + prototypeSymbol.type = classTypeSymbol; + constructorTypeSymbol.addMember(prototypeSymbol); + + if (prototypeSymbol.type && prototypeSymbol.type.isGeneric()) { + var resolver = this.semanticInfoChain.getResolver(); + prototypeSymbol.type = resolver.instantiateTypeToAny(prototypeSymbol.type, new TypeScript.PullTypeResolutionContext(resolver)); + } + prototypeSymbol.setResolved(); + } + }; + + PullSymbolBinder.prototype.bindConstructorDeclarationToPullSymbol = function (constructorDeclaration) { + var declKind = constructorDeclaration.kind; + var declFlags = constructorDeclaration.flags; + var constructorAST = this.semanticInfoChain.getASTForDecl(constructorDeclaration); + + var constructorName = constructorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + + var parent = this.getParent(constructorDeclaration, true); + + var parentHadSymbol = false; + + var constructorSymbol = parent.getConstructorMethod(); + var constructorTypeSymbol = null; + + if (constructorSymbol && (constructorSymbol.kind !== 32768 /* ConstructorMethod */ || (!isSignature && constructorSymbol.type && constructorSymbol.type.hasOwnConstructSignatures()))) { + var hasDefinitionSignature = false; + var constructorSigs = constructorSymbol.type.getConstructSignatures(); + + for (var i = 0; i < constructorSigs.length; i++) { + if (!constructorSigs[i].anyDeclHasFlag(2048 /* Signature */)) { + hasDefinitionSignature = true; + break; + } + } + + if (hasDefinitionSignature) { + this.semanticInfoChain.addDiagnosticFromAST(constructorAST, TypeScript.DiagnosticCode.Multiple_constructor_implementations_are_not_allowed); + + constructorSymbol = null; + } + } + + if (constructorSymbol) { + constructorTypeSymbol = constructorSymbol.type; + } else { + constructorSymbol = new TypeScript.PullSymbol(constructorName, 32768 /* ConstructorMethod */); + constructorTypeSymbol = new TypeScript.PullTypeSymbol("", 33554432 /* ConstructorType */); + } + + parent.setConstructorMethod(constructorSymbol); + constructorSymbol.type = constructorTypeSymbol; + + constructorDeclaration.setSymbol(constructorSymbol); + constructorSymbol.addDeclaration(constructorDeclaration); + constructorTypeSymbol.addDeclaration(constructorDeclaration); + constructorSymbol.setIsSynthesized(false); + this.semanticInfoChain.setSymbolForAST(constructorAST, constructorSymbol); + + var constructSignature = isSignature ? new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */) : new TypeScript.PullDefinitionSignatureSymbol(2097152 /* ConstructSignature */); + + constructSignature.returnType = parent; + + constructSignature.addDeclaration(constructorDeclaration); + constructorDeclaration.setSignatureSymbol(constructSignature); + + this.bindParameterSymbols(constructorAST, TypeScript.Parameters.fromParameterList(constructorAST.parameterList), constructorTypeSymbol, constructSignature); + + var typeParameters = constructorTypeSymbol.getTypeParameters(); + + for (var i = 0; i < typeParameters.length; i++) { + constructSignature.addTypeParameter(typeParameters[i]); + } + + if (TypeScript.lastParameterIsRest(constructorAST.parameterList)) { + constructSignature.hasVarArgs = true; + } + + constructorTypeSymbol.addConstructSignature(constructSignature); + + var otherDecls = this.findDeclsInContext(constructorDeclaration, constructorDeclaration.kind, false); + + if (otherDecls && otherDecls.length) { + for (var i = 0; i < otherDecls.length; i++) { + otherDecls[i].ensureSymbolIsBound(); + } + } + + this.bindStaticPrototypePropertyOfClass(parent, constructorTypeSymbol); + }; + + PullSymbolBinder.prototype.bindConstructSignatureDeclarationToPullSymbol = function (constructSignatureDeclaration) { + var parent = this.getParent(constructSignatureDeclaration, true); + var constructorAST = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration); + + var constructSignature = new TypeScript.PullSignatureSymbol(2097152 /* ConstructSignature */); + + if (TypeScript.lastParameterIsRest(constructorAST.callSignature.parameterList)) { + constructSignature.hasVarArgs = true; + } + + var typeParameters = constructSignatureDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = constructSignature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + constructSignature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + constructSignature.addDeclaration(constructSignatureDeclaration); + constructSignatureDeclaration.setSignatureSymbol(constructSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(TypeScript.getParameterList(funcDecl)), null, constructSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(constructSignatureDeclaration), constructSignature); + + parent.addConstructSignature(constructSignature); + }; + + PullSymbolBinder.prototype.bindCallSignatureDeclarationToPullSymbol = function (callSignatureDeclaration) { + var parent = this.getParent(callSignatureDeclaration, true); + var callSignatureAST = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration); + + var callSignature = new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */); + + if (TypeScript.lastParameterIsRest(callSignatureAST.parameterList)) { + callSignature.hasVarArgs = true; + } + + var typeParameters = callSignatureDeclaration.getTypeParameters(); + var typeParameter; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameter = callSignature.findTypeParameter(typeParameters[i].name); + + if (!typeParameter) { + typeParameter = new TypeScript.PullTypeParameterSymbol(typeParameters[i].name, true); + + callSignature.addTypeParameter(typeParameter); + } else { + var typeParameterAST = this.semanticInfoChain.getASTForDecl(typeParameter.getDeclarations()[0]); + this.semanticInfoChain.addDiagnosticFromAST(typeParameterAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [typeParameter.getName()]); + } + + typeParameter.addDeclaration(typeParameters[i]); + typeParameters[i].setSymbol(typeParameter); + } + + callSignature.addDeclaration(callSignatureDeclaration); + callSignatureDeclaration.setSignatureSymbol(callSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(callSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameterList(funcDecl.parameterList), null, callSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(callSignatureDeclaration), callSignature); + + parent.addCallSignature(callSignature); + }; + + PullSymbolBinder.prototype.bindIndexSignatureDeclarationToPullSymbol = function (indexSignatureDeclaration) { + var indexSignature = new TypeScript.PullSignatureSymbol(4194304 /* IndexSignature */); + + indexSignature.addDeclaration(indexSignatureDeclaration); + indexSignatureDeclaration.setSignatureSymbol(indexSignature); + + var funcDecl = this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration); + this.bindParameterSymbols(funcDecl, TypeScript.Parameters.fromParameter(funcDecl.parameter), null, indexSignature); + + this.semanticInfoChain.setSymbolForAST(this.semanticInfoChain.getASTForDecl(indexSignatureDeclaration), indexSignature); + + var parent = this.getParent(indexSignatureDeclaration); + parent.addIndexSignature(indexSignature); + indexSignature.setContainer(parent); + }; + + PullSymbolBinder.prototype.bindGetAccessorDeclarationToPullSymbol = function (getAccessorDeclaration) { + var declKind = getAccessorDeclaration.kind; + var declFlags = getAccessorDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(getAccessorDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = getAccessorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var isStatic = false; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + var parent = this.getParent(getAccessorDeclaration, true); + var parentHadSymbol = false; + + var accessorSymbol = null; + var getterSymbol = null; + var getterTypeSymbol = null; + + if (isStatic) { + parent = parent.getConstructorMethod().type; + } + + accessorSymbol = parent.findMember(funcName, false); + + if (accessorSymbol) { + if (!accessorSymbol.isAccessor()) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [getAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + } else { + getterSymbol = accessorSymbol.getGetter(); + + if (getterSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Getter_0_already_declared, [getAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + getterSymbol = null; + } + } + } + + if (accessorSymbol) { + parentHadSymbol = true; + } + + if (accessorSymbol && getterSymbol) { + getterTypeSymbol = getterSymbol.type; + } + + if (!accessorSymbol) { + accessorSymbol = new TypeScript.PullAccessorSymbol(funcName); + } + + if (!getterSymbol) { + getterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + getterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + getterTypeSymbol.setFunctionSymbol(getterSymbol); + + getterSymbol.type = getterTypeSymbol; + + accessorSymbol.setGetter(getterSymbol); + } + + getAccessorDeclaration.setSymbol(accessorSymbol); + accessorSymbol.addDeclaration(getAccessorDeclaration); + getterSymbol.addDeclaration(getAccessorDeclaration); + + var nameAST = funcDeclAST.propertyName; + this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, getterSymbol); + + if (!parentHadSymbol) { + parent.addMember(accessorSymbol); + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(getAccessorDeclaration); + getAccessorDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDeclAST, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), getterTypeSymbol, signature); + + getterTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindSetAccessorDeclarationToPullSymbol = function (setAccessorDeclaration) { + var declKind = setAccessorDeclaration.kind; + var declFlags = setAccessorDeclaration.flags; + var funcDeclAST = this.semanticInfoChain.getASTForDecl(setAccessorDeclaration); + + var isExported = (declFlags & 1 /* Exported */) !== 0; + + var funcName = setAccessorDeclaration.name; + + var isSignature = (declFlags & 2048 /* Signature */) !== 0; + var isStatic = false; + + if (TypeScript.hasFlag(declFlags, 16 /* Static */)) { + isStatic = true; + } + + var parent = this.getParent(setAccessorDeclaration, true); + var parentHadSymbol = false; + + var accessorSymbol = null; + var setterSymbol = null; + var setterTypeSymbol = null; + + if (isStatic) { + parent = parent.getConstructorMethod().type; + } + + accessorSymbol = parent.findMember(funcName, false); + + if (accessorSymbol) { + if (!accessorSymbol.isAccessor()) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Duplicate_identifier_0, [setAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + } else { + setterSymbol = accessorSymbol.getSetter(); + + if (setterSymbol) { + this.semanticInfoChain.addDiagnosticFromAST(funcDeclAST, TypeScript.DiagnosticCode.Setter_0_already_declared, [setAccessorDeclaration.getDisplayName()]); + accessorSymbol = null; + setterSymbol = null; + } + } + } + + if (accessorSymbol) { + parentHadSymbol = true; + + if (setterSymbol) { + setterTypeSymbol = setterSymbol.type; + } + } + + if (!accessorSymbol) { + accessorSymbol = new TypeScript.PullAccessorSymbol(funcName); + } + + if (!setterSymbol) { + setterSymbol = new TypeScript.PullSymbol(funcName, 16384 /* Function */); + setterTypeSymbol = new TypeScript.PullTypeSymbol("", 16777216 /* FunctionType */); + setterTypeSymbol.setFunctionSymbol(setterSymbol); + + setterSymbol.type = setterTypeSymbol; + + accessorSymbol.setSetter(setterSymbol); + } + + setAccessorDeclaration.setSymbol(accessorSymbol); + accessorSymbol.addDeclaration(setAccessorDeclaration); + setterSymbol.addDeclaration(setAccessorDeclaration); + + var nameAST = funcDeclAST.propertyName; + this.semanticInfoChain.setSymbolForAST(nameAST, accessorSymbol); + this.semanticInfoChain.setSymbolForAST(funcDeclAST, setterSymbol); + + if (!parentHadSymbol) { + parent.addMember(accessorSymbol); + } + + var signature = isSignature ? new TypeScript.PullSignatureSymbol(1048576 /* CallSignature */) : new TypeScript.PullDefinitionSignatureSymbol(1048576 /* CallSignature */); + + signature.addDeclaration(setAccessorDeclaration); + setAccessorDeclaration.setSignatureSymbol(signature); + + this.bindParameterSymbols(funcDeclAST, TypeScript.Parameters.fromParameterList(funcDeclAST.parameterList), setterTypeSymbol, signature); + + setterTypeSymbol.addCallSignature(signature); + }; + + PullSymbolBinder.prototype.bindDeclToPullSymbol = function (decl) { + if (decl.hasBeenBound()) { + return; + } + + if (this.declsBeingBound.indexOf(decl.declID) >= 0) { + return; + } + + this.declsBeingBound.push(decl.declID); + + switch (decl.kind) { + case 1 /* Script */: + var childDecls = decl.getChildDecls(); + for (var i = 0; i < childDecls.length; i++) { + this.bindDeclToPullSymbol(childDecls[i]); + } + break; + + case 64 /* Enum */: + this.bindEnumDeclarationToPullSymbol(decl); + break; + + case 32 /* DynamicModule */: + case 4 /* Container */: + this.bindModuleDeclarationToPullSymbol(decl); + break; + + case 16 /* Interface */: + this.bindInterfaceDeclarationToPullSymbol(decl); + break; + + case 8 /* Class */: + this.bindClassDeclarationToPullSymbol(decl); + break; + + case 16384 /* Function */: + this.bindFunctionDeclarationToPullSymbol(decl); + break; + + case 512 /* Variable */: + this.bindVariableDeclarationToPullSymbol(decl); + break; + + case 1024 /* CatchVariable */: + this.bindCatchVariableToPullSymbol(decl); + break; + + case 67108864 /* EnumMember */: + this.bindEnumMemberDeclarationToPullSymbol(decl); + break; + + case 4096 /* Property */: + this.bindPropertyDeclarationToPullSymbol(decl); + break; + + case 65536 /* Method */: + this.bindMethodDeclarationToPullSymbol(decl); + break; + + case 32768 /* ConstructorMethod */: + this.bindConstructorDeclarationToPullSymbol(decl); + break; + + case 1048576 /* CallSignature */: + this.bindCallSignatureDeclarationToPullSymbol(decl); + break; + + case 2097152 /* ConstructSignature */: + this.bindConstructSignatureDeclarationToPullSymbol(decl); + break; + + case 4194304 /* IndexSignature */: + this.bindIndexSignatureDeclarationToPullSymbol(decl); + break; + + case 262144 /* GetAccessor */: + this.bindGetAccessorDeclarationToPullSymbol(decl); + break; + + case 524288 /* SetAccessor */: + this.bindSetAccessorDeclarationToPullSymbol(decl); + break; + + case 8388608 /* ObjectType */: + this.bindObjectTypeDeclarationToPullSymbol(decl); + break; + + case 16777216 /* FunctionType */: + this.bindFunctionTypeDeclarationToPullSymbol(decl); + break; + + case 33554432 /* ConstructorType */: + this.bindConstructorTypeDeclarationToPullSymbol(decl); + break; + + case 131072 /* FunctionExpression */: + this.bindFunctionExpressionToPullSymbol(decl); + break; + + case 128 /* TypeAlias */: + this.bindImportDeclaration(decl); + break; + + case 2048 /* Parameter */: + case 8192 /* TypeParameter */: + decl.getParentDecl().getSymbol(); + break; + + case 268435456 /* CatchBlock */: + case 134217728 /* WithBlock */: + break; + + default: + TypeScript.CompilerDiagnostics.assert(false, "Unrecognized type declaration"); + } + + TypeScript.Debug.assert(TypeScript.ArrayUtilities.last(this.declsBeingBound) === decl.declID); + this.declsBeingBound.pop(); + }; + return PullSymbolBinder; + })(); + TypeScript.PullSymbolBinder = PullSymbolBinder; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (PullHelpers) { + function getSignatureForFuncDecl(functionDecl) { + var funcDecl = functionDecl.ast(); + var funcSymbol = functionDecl.getSymbol(); + + if (!funcSymbol) { + funcSymbol = functionDecl.getSignatureSymbol(); + } + + var functionSignature = null; + var typeSymbolWithAllSignatures = null; + if (funcSymbol.isSignature()) { + functionSignature = funcSymbol; + var parent = functionDecl.getParentDecl(); + typeSymbolWithAllSignatures = parent.getSymbol().type; + } else { + functionSignature = functionDecl.getSignatureSymbol(); + typeSymbolWithAllSignatures = funcSymbol.type; + } + var signatures; + + if (funcDecl.kind() === 137 /* ConstructorDeclaration */ || functionDecl.kind === 2097152 /* ConstructSignature */) { + signatures = typeSymbolWithAllSignatures.getConstructSignatures(); + } else if (functionDecl.kind === 4194304 /* IndexSignature */) { + signatures = typeSymbolWithAllSignatures.getIndexSignatures(); + } else { + signatures = typeSymbolWithAllSignatures.getCallSignatures(); + } + + return { + signature: functionSignature, + allSignatures: signatures + }; + } + PullHelpers.getSignatureForFuncDecl = getSignatureForFuncDecl; + + function getAccessorSymbol(getterOrSetter, semanticInfoChain) { + var functionDecl = semanticInfoChain.getDeclForAST(getterOrSetter); + var getterOrSetterSymbol = functionDecl.getSymbol(); + + return getterOrSetterSymbol; + } + PullHelpers.getAccessorSymbol = getAccessorSymbol; + + function getGetterAndSetterFunction(funcDecl, semanticInfoChain) { + var accessorSymbol = PullHelpers.getAccessorSymbol(funcDecl, semanticInfoChain); + var result = { + getter: null, + setter: null + }; + var getter = accessorSymbol.getGetter(); + if (getter) { + var getterDecl = getter.getDeclarations()[0]; + result.getter = semanticInfoChain.getASTForDecl(getterDecl); + } + var setter = accessorSymbol.getSetter(); + if (setter) { + var setterDecl = setter.getDeclarations()[0]; + result.setter = semanticInfoChain.getASTForDecl(setterDecl); + } + + return result; + } + PullHelpers.getGetterAndSetterFunction = getGetterAndSetterFunction; + + function symbolIsEnum(source) { + return source && (source.kind & (64 /* Enum */ | 67108864 /* EnumMember */)) !== 0; + } + PullHelpers.symbolIsEnum = symbolIsEnum; + + function symbolIsModule(symbol) { + return symbol && (symbol.kind == 4 /* Container */ || isOneDeclarationOfKind(symbol, 4 /* Container */)); + } + PullHelpers.symbolIsModule = symbolIsModule; + + function isOneDeclarationOfKind(symbol, kind) { + var decls = symbol.getDeclarations(); + for (var i = 0; i < decls.length; i++) { + if (decls[i].kind === kind) { + return true; + } + } + + return false; + } + + function isNameNumeric(name) { + return isFinite(+name); + } + PullHelpers.isNameNumeric = isNameNumeric; + + function typeSymbolsAreIdentical(a, b) { + if (a.isTypeReference() && !a.getIsSpecialized()) { + a = a.referencedTypeSymbol; + } + + if (b.isTypeReference() && !b.getIsSpecialized()) { + b = b.referencedTypeSymbol; + } + + return a == b; + } + PullHelpers.typeSymbolsAreIdentical = typeSymbolsAreIdentical; + + function getRootType(type) { + var rootType = type.getRootSymbol(); + + while (true) { + if (type == rootType) { + return type; + } + + type = rootType; + rootType = type.getRootSymbol(); + } + } + PullHelpers.getRootType = getRootType; + + function isSymbolLocal(symbol) { + var container = symbol.getContainer(); + if (container) { + var containerKind = container.kind; + if (containerKind & (1032192 /* SomeFunction */ | 16777216 /* FunctionType */)) { + return true; + } + + if (containerKind == 33554432 /* ConstructorType */ && !symbol.anyDeclHasFlag(16 /* Static */)) { + return true; + } + } + + return false; + } + PullHelpers.isSymbolLocal = isSymbolLocal; + })(TypeScript.PullHelpers || (TypeScript.PullHelpers = {})); + var PullHelpers = TypeScript.PullHelpers; +})(TypeScript || (TypeScript = {})); +if (Error) + Error.stackTraceLimit = 1000; + +var TypeScript; +(function (TypeScript) { + TypeScript.fileResolutionTime = 0; + TypeScript.fileResolutionIOTime = 0; + TypeScript.fileResolutionScanImportsTime = 0; + TypeScript.fileResolutionImportFileSearchTime = 0; + TypeScript.fileResolutionGetDefaultLibraryTime = 0; + TypeScript.sourceCharactersCompiled = 0; + TypeScript.syntaxTreeParseTime = 0; + TypeScript.syntaxDiagnosticsTime = 0; + TypeScript.astTranslationTime = 0; + TypeScript.typeCheckTime = 0; + + TypeScript.compilerResolvePathTime = 0; + TypeScript.compilerDirectoryNameTime = 0; + TypeScript.compilerDirectoryExistsTime = 0; + TypeScript.compilerFileExistsTime = 0; + + TypeScript.emitTime = 0; + TypeScript.emitWriteFileTime = 0; + + TypeScript.declarationEmitTime = 0; + TypeScript.declarationEmitIsExternallyVisibleTime = 0; + TypeScript.declarationEmitTypeSignatureTime = 0; + TypeScript.declarationEmitGetBoundDeclTypeTime = 0; + TypeScript.declarationEmitIsOverloadedCallSignatureTime = 0; + TypeScript.declarationEmitFunctionDeclarationGetSymbolTime = 0; + TypeScript.declarationEmitGetBaseTypeTime = 0; + TypeScript.declarationEmitGetAccessorFunctionTime = 0; + TypeScript.declarationEmitGetTypeParameterSymbolTime = 0; + TypeScript.declarationEmitGetImportDeclarationSymbolTime = 0; + + TypeScript.ioHostResolvePathTime = 0; + TypeScript.ioHostDirectoryNameTime = 0; + TypeScript.ioHostCreateDirectoryStructureTime = 0; + TypeScript.ioHostWriteFileTime = 0; + + var EmitOutput = (function () { + function EmitOutput() { + this.outputFiles = []; + this.diagnostics = []; + } + return EmitOutput; + })(); + TypeScript.EmitOutput = EmitOutput; + + (function (OutputFileType) { + OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript"; + OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap"; + OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration"; + })(TypeScript.OutputFileType || (TypeScript.OutputFileType = {})); + var OutputFileType = TypeScript.OutputFileType; + + var OutputFile = (function () { + function OutputFile(name, writeByteOrderMark, text, fileType, sourceMapEntries) { + if (typeof sourceMapEntries === "undefined") { sourceMapEntries = []; } + this.name = name; + this.writeByteOrderMark = writeByteOrderMark; + this.text = text; + this.fileType = fileType; + this.sourceMapEntries = sourceMapEntries; + } + return OutputFile; + })(); + TypeScript.OutputFile = OutputFile; + + var CompileResult = (function () { + function CompileResult() { + this.diagnostics = []; + this.outputFiles = []; + } + CompileResult.fromDiagnostics = function (diagnostics) { + var result = new CompileResult(); + result.diagnostics = diagnostics; + return result; + }; + + CompileResult.fromOutputFiles = function (outputFiles) { + var result = new CompileResult(); + result.outputFiles = outputFiles; + return result; + }; + return CompileResult; + })(); + TypeScript.CompileResult = CompileResult; + + var TypeScriptCompiler = (function () { + function TypeScriptCompiler(logger, _settings) { + if (typeof logger === "undefined") { logger = new TypeScript.NullLogger(); } + if (typeof _settings === "undefined") { _settings = TypeScript.ImmutableCompilationSettings.defaultSettings(); } + this.logger = logger; + this._settings = _settings; + this.semanticInfoChain = null; + this.semanticInfoChain = new TypeScript.SemanticInfoChain(this, logger); + } + TypeScriptCompiler.prototype.compilationSettings = function () { + return this._settings; + }; + + TypeScriptCompiler.prototype.setCompilationSettings = function (newSettings) { + var oldSettings = this._settings; + this._settings = newSettings; + + if (!compareDataObjects(oldSettings, newSettings)) { + this.semanticInfoChain.invalidate(oldSettings, newSettings); + } + }; + + TypeScriptCompiler.prototype.getDocument = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + return this.semanticInfoChain.getDocument(fileName); + }; + + TypeScriptCompiler.prototype.cleanupSemanticCache = function () { + this.semanticInfoChain.invalidate(); + }; + + TypeScriptCompiler.prototype.addFile = function (fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles) { + if (typeof referencedFiles === "undefined") { referencedFiles = []; } + fileName = TypeScript.switchToForwardSlashes(fileName); + + TypeScript.sourceCharactersCompiled += scriptSnapshot.getLength(); + + var document = TypeScript.Document.create(this, this.semanticInfoChain, fileName, scriptSnapshot, byteOrderMark, version, isOpen, referencedFiles); + + this.semanticInfoChain.addDocument(document); + }; + + TypeScriptCompiler.prototype.updateFile = function (fileName, scriptSnapshot, version, isOpen, textChangeRange) { + fileName = TypeScript.switchToForwardSlashes(fileName); + + var document = this.getDocument(fileName); + var updatedDocument = document.update(scriptSnapshot, version, isOpen, textChangeRange); + + this.semanticInfoChain.addDocument(updatedDocument); + }; + + TypeScriptCompiler.prototype.removeFile = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + this.semanticInfoChain.removeDocument(fileName); + }; + + TypeScriptCompiler.prototype._isDynamicModuleCompilation = function () { + var fileNames = this.fileNames(); + for (var i = 0, n = fileNames.length; i < n; i++) { + var document = this.getDocument(fileNames[i]); + if (!document.isDeclareFile() && document.isExternalModule()) { + return true; + } + } + return false; + }; + + TypeScriptCompiler.prototype.mapOutputFileName = function (document, emitOptions, extensionChanger) { + if (document.emitToOwnOutputFile()) { + var updatedFileName = document.fileName; + if (emitOptions.outputDirectory() !== "") { + updatedFileName = document.fileName.replace(emitOptions.commonDirectoryPath(), ""); + updatedFileName = emitOptions.outputDirectory() + updatedFileName; + } + return extensionChanger(updatedFileName, false); + } else { + return extensionChanger(emitOptions.sharedOutputFile(), true); + } + }; + + TypeScriptCompiler.prototype.writeByteOrderMarkForDocument = function (document) { + var printReason = false; + + if (document.emitToOwnOutputFile()) { + var result = document.byteOrderMark !== 0 /* None */; + if (printReason) { + TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName); + } + return result; + } else { + var fileNames = this.fileNames(); + + var result = false; + for (var i = 0, n = fileNames.length; i < n; i++) { + var document = this.getDocument(fileNames[i]); + + if (document.isExternalModule()) { + continue; + } + + if (document.byteOrderMark !== 0 /* None */) { + if (printReason) { + TypeScript.Environment.standardOut.WriteLine("Emitting byte order mark because of: " + document.fileName); + result = true; + } else { + return true; + } + } + } + + return result; + } + }; + + TypeScriptCompiler.mapToDTSFileName = function (fileName, wholeFileNameReplaced) { + return TypeScript.getDeclareFilePath(fileName); + }; + + TypeScriptCompiler.prototype._shouldEmit = function (document) { + return !document.isDeclareFile(); + }; + + TypeScriptCompiler.prototype._shouldEmitDeclarations = function (document) { + if (!this.compilationSettings().generateDeclarationFiles()) { + return false; + } + + return this._shouldEmit(document); + }; + + TypeScriptCompiler.prototype.emitDocumentDeclarationsWorker = function (document, emitOptions, declarationEmitter) { + var sourceUnit = document.sourceUnit(); + TypeScript.Debug.assert(this._shouldEmitDeclarations(document)); + + if (declarationEmitter) { + declarationEmitter.document = document; + } else { + var declareFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToDTSFileName); + declarationEmitter = new TypeScript.DeclarationEmitter(declareFileName, document, this, emitOptions, this.semanticInfoChain); + } + + declarationEmitter.emitDeclarations(sourceUnit); + return declarationEmitter; + }; + + TypeScriptCompiler.prototype._emitDocumentDeclarations = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) { + if (this._shouldEmitDeclarations(document)) { + if (document.emitToOwnOutputFile()) { + var singleEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions); + if (singleEmitter) { + onSingleFileEmitComplete(singleEmitter.getOutputFile()); + } + } else { + sharedEmitter = this.emitDocumentDeclarationsWorker(document, emitOptions, sharedEmitter); + } + } + + return sharedEmitter; + }; + + TypeScriptCompiler.prototype.emitAllDeclarations = function (resolvePath) { + var start = new Date().getTime(); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var sharedEmitter = null; + var fileNames = this.fileNames(); + + for (var i = 0, n = fileNames.length; i < n; i++) { + var fileName = fileNames[i]; + + var document = this.getDocument(fileNames[i]); + + sharedEmitter = this._emitDocumentDeclarations(document, emitOptions, function (file) { + return emitOutput.outputFiles.push(file); + }, sharedEmitter); + } + + if (sharedEmitter) { + emitOutput.outputFiles.push(sharedEmitter.getOutputFile()); + } + + TypeScript.declarationEmitTime += new Date().getTime() - start; + + return emitOutput; + }; + + TypeScriptCompiler.prototype.emitDeclarations = function (fileName, resolvePath) { + fileName = TypeScript.switchToForwardSlashes(fileName); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var document = this.getDocument(fileName); + + if (document.emitToOwnOutputFile()) { + this._emitDocumentDeclarations(document, emitOptions, function (file) { + return emitOutput.outputFiles.push(file); + }, null); + return emitOutput; + } else { + return this.emitAllDeclarations(resolvePath); + } + }; + + TypeScriptCompiler.mapToFileNameExtension = function (extension, fileName, wholeFileNameReplaced) { + if (wholeFileNameReplaced) { + return fileName; + } else { + var splitFname = fileName.split("."); + splitFname.pop(); + return splitFname.join(".") + extension; + } + }; + + TypeScriptCompiler.mapToJSFileName = function (fileName, wholeFileNameReplaced) { + return TypeScriptCompiler.mapToFileNameExtension(".js", fileName, wholeFileNameReplaced); + }; + + TypeScriptCompiler.prototype.emitDocumentWorker = function (document, emitOptions, emitter) { + var sourceUnit = document.sourceUnit(); + TypeScript.Debug.assert(this._shouldEmit(document)); + + var typeScriptFileName = document.fileName; + if (!emitter) { + var javaScriptFileName = this.mapOutputFileName(document, emitOptions, TypeScriptCompiler.mapToJSFileName); + var outFile = new TypeScript.TextWriter(javaScriptFileName, this.writeByteOrderMarkForDocument(document), 0 /* JavaScript */); + + emitter = new TypeScript.Emitter(javaScriptFileName, outFile, emitOptions, this.semanticInfoChain); + + if (this.compilationSettings().mapSourceFiles()) { + var sourceMapFile = new TypeScript.TextWriter(javaScriptFileName + TypeScript.SourceMapper.MapFileExtension, false, 1 /* SourceMap */); + emitter.createSourceMapper(document, javaScriptFileName, outFile, sourceMapFile, emitOptions.resolvePath); + } + } else if (this.compilationSettings().mapSourceFiles()) { + emitter.setSourceMapperNewSourceFile(document); + } + + emitter.setDocument(document); + emitter.emitJavascript(sourceUnit, false); + + return emitter; + }; + + TypeScriptCompiler.prototype._emitDocument = function (document, emitOptions, onSingleFileEmitComplete, sharedEmitter) { + if (this._shouldEmit(document)) { + if (document.emitToOwnOutputFile()) { + var singleEmitter = this.emitDocumentWorker(document, emitOptions); + if (singleEmitter) { + onSingleFileEmitComplete(singleEmitter.getOutputFiles()); + } + } else { + sharedEmitter = this.emitDocumentWorker(document, emitOptions, sharedEmitter); + } + } + + return sharedEmitter; + }; + + TypeScriptCompiler.prototype.emitAll = function (resolvePath) { + var start = new Date().getTime(); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var fileNames = this.fileNames(); + var sharedEmitter = null; + + for (var i = 0, n = fileNames.length; i < n; i++) { + var fileName = fileNames[i]; + + var document = this.getDocument(fileName); + + sharedEmitter = this._emitDocument(document, emitOptions, function (files) { + return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files); + }, sharedEmitter); + } + + if (sharedEmitter) { + emitOutput.outputFiles.push.apply(emitOutput.outputFiles, sharedEmitter.getOutputFiles()); + } + + TypeScript.emitTime += new Date().getTime() - start; + return emitOutput; + }; + + TypeScriptCompiler.prototype.emit = function (fileName, resolvePath) { + fileName = TypeScript.switchToForwardSlashes(fileName); + var emitOutput = new EmitOutput(); + + var emitOptions = new TypeScript.EmitOptions(this, resolvePath); + if (emitOptions.diagnostic()) { + emitOutput.diagnostics.push(emitOptions.diagnostic()); + return emitOutput; + } + + var document = this.getDocument(fileName); + + if (document.emitToOwnOutputFile()) { + this._emitDocument(document, emitOptions, function (files) { + return emitOutput.outputFiles.push.apply(emitOutput.outputFiles, files); + }, null); + return emitOutput; + } else { + return this.emitAll(resolvePath); + } + }; + + TypeScriptCompiler.prototype.compile = function (resolvePath, continueOnDiagnostics) { + if (typeof continueOnDiagnostics === "undefined") { continueOnDiagnostics = false; } + return new CompilerIterator(this, resolvePath, continueOnDiagnostics); + }; + + TypeScriptCompiler.prototype.getSyntacticDiagnostics = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + return this.getDocument(fileName).diagnostics(); + }; + + TypeScriptCompiler.prototype.getSyntaxTree = function (fileName) { + return this.getDocument(fileName).syntaxTree(); + }; + + TypeScriptCompiler.prototype.getSourceUnit = function (fileName) { + return this.getDocument(fileName).sourceUnit(); + }; + + TypeScriptCompiler.prototype.getSemanticDiagnostics = function (fileName) { + fileName = TypeScript.switchToForwardSlashes(fileName); + + var document = this.getDocument(fileName); + + var startTime = (new Date()).getTime(); + TypeScript.PullTypeResolver.typeCheck(this.compilationSettings(), this.semanticInfoChain, document); + var endTime = (new Date()).getTime(); + + TypeScript.typeCheckTime += endTime - startTime; + + var errors = this.semanticInfoChain.getDiagnostics(fileName); + + errors = TypeScript.ArrayUtilities.distinct(errors, TypeScript.Diagnostic.equals); + errors.sort(function (d1, d2) { + if (d1.fileName() < d2.fileName()) { + return -1; + } else if (d1.fileName() > d2.fileName()) { + return 1; + } + + if (d1.start() < d2.start()) { + return -1; + } else if (d1.start() > d2.start()) { + return 1; + } + + var code1 = TypeScript.diagnosticInformationMap[d1.diagnosticKey()].code; + var code2 = TypeScript.diagnosticInformationMap[d2.diagnosticKey()].code; + if (code1 < code2) { + return -1; + } else if (code1 > code2) { + return 1; + } + + return 0; + }); + + return errors; + }; + + TypeScriptCompiler.prototype.resolveAllFiles = function () { + var fileNames = this.fileNames(); + for (var i = 0, n = fileNames.length; i < n; i++) { + this.getSemanticDiagnostics(fileNames[i]); + } + }; + + TypeScriptCompiler.prototype.getSymbolOfDeclaration = function (decl) { + if (!decl) { + return null; + } + + var resolver = this.semanticInfoChain.getResolver(); + var ast = this.semanticInfoChain.getASTForDecl(decl); + if (!ast) { + return null; + } + + var enclosingDecl = resolver.getEnclosingDecl(decl); + if (ast.kind() === 139 /* GetAccessor */ || ast.kind() === 140 /* SetAccessor */) { + return this.getSymbolOfDeclaration(enclosingDecl); + } + + return resolver.resolveAST(ast, false, new TypeScript.PullTypeResolutionContext(resolver)); + }; + + TypeScriptCompiler.prototype.extractResolutionContextFromAST = function (resolver, ast, document, propagateContextualTypes) { + var scriptName = document.fileName; + + var enclosingDecl = null; + var enclosingDeclAST = null; + var inContextuallyTypedAssignment = false; + var inWithBlock = false; + + var resolutionContext = new TypeScript.PullTypeResolutionContext(resolver); + + if (!ast) { + return null; + } + + var path = this.getASTPath(ast); + + for (var i = 0, n = path.length; i < n; i++) { + var current = path[i]; + + switch (current.kind()) { + case 222 /* FunctionExpression */: + case 219 /* SimpleArrowFunctionExpression */: + case 218 /* ParenthesizedArrowFunctionExpression */: + if (propagateContextualTypes) { + resolver.resolveAST(current, true, resolutionContext); + } + break; + + case 136 /* MemberVariableDeclaration */: + var memberVariable = current; + inContextuallyTypedAssignment = memberVariable.variableDeclarator.typeAnnotation !== null; + + this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, memberVariable, memberVariable.variableDeclarator.equalsValueClause); + break; + + case 225 /* VariableDeclarator */: + var variableDeclarator = current; + inContextuallyTypedAssignment = variableDeclarator.typeAnnotation !== null; + + this.extractResolutionContextForVariable(inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, variableDeclarator, variableDeclarator.equalsValueClause); + break; + + case 213 /* InvocationExpression */: + case 216 /* ObjectCreationExpression */: + if (propagateContextualTypes) { + var isNew = current.kind() === 216 /* ObjectCreationExpression */; + var callExpression = current; + var contextualType = null; + + if ((i + 2 < n) && callExpression.argumentList === path[i + 1] && callExpression.argumentList.arguments === path[i + 2]) { + var arguments = callExpression.argumentList.arguments; + + var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData(); + if (isNew) { + resolver.resolveObjectCreationExpression(callExpression, resolutionContext, callResolutionResults); + } else { + resolver.resolveInvocationExpression(callExpression, resolutionContext, callResolutionResults); + } + + if (callResolutionResults.actualParametersContextTypeSymbols) { + var argExpression = path[i + 3]; + if (argExpression) { + for (var j = 0, m = callExpression.argumentList.arguments.nonSeparatorCount(); j < m; j++) { + if (callExpression.argumentList.arguments.nonSeparatorAt(j) === argExpression) { + var callContextualType = callResolutionResults.actualParametersContextTypeSymbols[j]; + if (callContextualType) { + contextualType = callContextualType; + break; + } + } + } + } + } + } else { + if (isNew) { + resolver.resolveObjectCreationExpression(callExpression, resolutionContext); + } else { + resolver.resolveInvocationExpression(callExpression, resolutionContext); + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 214 /* ArrayLiteralExpression */: + if (propagateContextualTypes) { + var contextualType = null; + var currentContextualType = resolutionContext.getContextualType(); + if (currentContextualType && currentContextualType.isArrayNamedTypeReference()) { + contextualType = currentContextualType.getElementType(); + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 215 /* ObjectLiteralExpression */: + if (propagateContextualTypes) { + var objectLiteralExpression = current; + var objectLiteralResolutionContext = new TypeScript.PullAdditionalObjectLiteralResolutionData(); + resolver.resolveObjectLiteralExpression(objectLiteralExpression, inContextuallyTypedAssignment, resolutionContext, objectLiteralResolutionContext); + + var memeberAST = (path[i + 1] && path[i + 1].kind() === 2 /* SeparatedList */) ? path[i + 2] : path[i + 1]; + if (memeberAST) { + var contextualType = null; + var memberDecls = objectLiteralExpression.propertyAssignments; + if (memberDecls && objectLiteralResolutionContext.membersContextTypeSymbols) { + for (var j = 0, m = memberDecls.nonSeparatorCount(); j < m; j++) { + if (memberDecls.nonSeparatorAt(j) === memeberAST) { + var memberContextualType = objectLiteralResolutionContext.membersContextTypeSymbols[j]; + if (memberContextualType) { + contextualType = memberContextualType; + break; + } + } + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + } + + break; + + case 174 /* AssignmentExpression */: + if (propagateContextualTypes) { + var assignmentExpression = current; + var contextualType = null; + + if (path[i + 1] && path[i + 1] === assignmentExpression.right) { + var leftType = resolver.resolveAST(assignmentExpression.left, inContextuallyTypedAssignment, resolutionContext).type; + if (leftType) { + inContextuallyTypedAssignment = true; + contextualType = leftType; + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 150 /* ReturnStatement */: + if (propagateContextualTypes) { + var returnStatement = current; + var contextualType = null; + + if (enclosingDecl && (enclosingDecl.kind & 1032192 /* SomeFunction */)) { + var typeAnnotation = TypeScript.getType(enclosingDeclAST); + if (typeAnnotation) { + var returnTypeSymbol = resolver.resolveTypeReference(typeAnnotation, resolutionContext); + if (returnTypeSymbol) { + inContextuallyTypedAssignment = true; + contextualType = returnTypeSymbol; + } + } else { + var currentContextualType = resolutionContext.getContextualType(); + if (currentContextualType && currentContextualType.isFunction()) { + var currentContextualTypeSignatureSymbol = currentContextualType.getDeclarations()[0].getSignatureSymbol(); + var currentContextualTypeReturnTypeSymbol = currentContextualTypeSignatureSymbol.returnType; + if (currentContextualTypeReturnTypeSymbol) { + inContextuallyTypedAssignment = true; + contextualType = currentContextualTypeReturnTypeSymbol; + } + } + } + } + + resolutionContext.pushContextualType(contextualType, false, null); + } + + break; + + case 122 /* ObjectType */: + if (propagateContextualTypes && TypeScript.isTypesOnlyLocation(current)) { + resolver.resolveAST(current, false, resolutionContext); + } + + break; + + case 163 /* WithStatement */: + inWithBlock = true; + break; + } + + var decl = this.semanticInfoChain.getDeclForAST(current); + if (decl) { + enclosingDecl = decl; + enclosingDeclAST = current; + } + } + + if (ast && ast.parent && ast.kind() === 11 /* IdentifierName */) { + if (ast.parent.kind() === 212 /* MemberAccessExpression */) { + if (ast.parent.name === ast) { + ast = ast.parent; + } + } else if (ast.parent.kind() === 121 /* QualifiedName */) { + if (ast.parent.right === ast) { + ast = ast.parent; + } + } + } + + return { + ast: ast, + enclosingDecl: enclosingDecl, + resolutionContext: resolutionContext, + inContextuallyTypedAssignment: inContextuallyTypedAssignment, + inWithBlock: inWithBlock + }; + }; + + TypeScriptCompiler.prototype.extractResolutionContextForVariable = function (inContextuallyTypedAssignment, propagateContextualTypes, resolver, resolutionContext, enclosingDecl, assigningAST, init) { + if (inContextuallyTypedAssignment) { + if (propagateContextualTypes) { + resolver.resolveAST(assigningAST, false, resolutionContext); + var varSymbol = this.semanticInfoChain.getSymbolForAST(assigningAST); + + var contextualType = null; + if (varSymbol && inContextuallyTypedAssignment) { + contextualType = varSymbol.type; + } + + resolutionContext.pushContextualType(contextualType, false, null); + + if (init) { + resolver.resolveAST(init, inContextuallyTypedAssignment, resolutionContext); + } + } + } + }; + + TypeScriptCompiler.prototype.getASTPath = function (ast) { + var result = []; + + while (ast) { + result.unshift(ast); + ast = ast.parent; + } + + return result; + }; + + TypeScriptCompiler.prototype.pullGetSymbolInformationFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + ast = context.ast; + var symbol = resolver.resolveAST(ast, context.inContextuallyTypedAssignment, context.resolutionContext); + + if (!symbol) { + TypeScript.Debug.assert(ast.kind() == 120 /* SourceUnit */, "No symbol was found for ast and ast was not source unit. Ast Kind: " + TypeScript.SyntaxKind[ast.kind()]); + return null; + } + + if (symbol.isTypeReference()) { + symbol = symbol.getReferencedTypeSymbol(); + } + + var aliasSymbol = this.semanticInfoChain.getAliasSymbolForAST(ast); + + return { + symbol: symbol, + aliasSymbol: aliasSymbol, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetCallInformationFromAST = function (ast, document) { + if (ast.kind() !== 213 /* InvocationExpression */ && ast.kind() !== 216 /* ObjectCreationExpression */) { + return null; + } + + var isNew = ast.kind() === 216 /* ObjectCreationExpression */; + + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var callResolutionResults = new TypeScript.PullAdditionalCallResolutionData(); + + if (isNew) { + resolver.resolveObjectCreationExpression(ast, context.resolutionContext, callResolutionResults); + } else { + resolver.resolveInvocationExpression(ast, context.resolutionContext, callResolutionResults); + } + + return { + targetSymbol: callResolutionResults.targetSymbol, + resolvedSignatures: callResolutionResults.resolvedSignatures, + candidateSignature: callResolutionResults.candidateSignature, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl), + isConstructorCall: isNew + }; + }; + + TypeScriptCompiler.prototype.pullGetVisibleMemberSymbolsFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var symbols = resolver.getVisibleMembersFromExpression(ast, context.enclosingDecl, context.resolutionContext); + if (!symbols) { + return null; + } + + return { + symbols: symbols, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetVisibleDeclsFromAST = function (ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, false); + if (!context || context.inWithBlock) { + return null; + } + + return resolver.getVisibleDecls(context.enclosingDecl); + }; + + TypeScriptCompiler.prototype.pullGetContextualMembersFromAST = function (ast, document) { + if (ast.kind() !== 215 /* ObjectLiteralExpression */) { + return null; + } + + var resolver = this.semanticInfoChain.getResolver(); + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var members = resolver.getVisibleContextSymbols(context.enclosingDecl, context.resolutionContext); + + return { + symbols: members, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.pullGetDeclInformation = function (decl, ast, document) { + var resolver = this.semanticInfoChain.getResolver(); + + var context = this.extractResolutionContextFromAST(resolver, ast, document, true); + if (!context || context.inWithBlock) { + return null; + } + + var astForDecl = decl.ast(); + if (!astForDecl) { + return null; + } + + var astForDeclContext = this.extractResolutionContextFromAST(resolver, astForDecl, this.getDocument(astForDecl.fileName()), true); + if (!astForDeclContext) { + return null; + } + + var symbol = decl.getSymbol(); + resolver.resolveDeclaredSymbol(symbol, context.resolutionContext); + symbol.setUnresolved(); + + return { + symbol: symbol, + aliasSymbol: null, + ast: ast, + enclosingScopeSymbol: this.getSymbolOfDeclaration(context.enclosingDecl) + }; + }; + + TypeScriptCompiler.prototype.topLevelDeclaration = function (fileName) { + return this.semanticInfoChain.topLevelDecl(fileName); + }; + + TypeScriptCompiler.prototype.getDeclForAST = function (ast) { + return this.semanticInfoChain.getDeclForAST(ast); + }; + + TypeScriptCompiler.prototype.fileNames = function () { + return this.semanticInfoChain.fileNames(); + }; + + TypeScriptCompiler.prototype.topLevelDecl = function (fileName) { + return this.semanticInfoChain.topLevelDecl(fileName); + }; + return TypeScriptCompiler; + })(); + TypeScript.TypeScriptCompiler = TypeScriptCompiler; + + var CompilerPhase; + (function (CompilerPhase) { + CompilerPhase[CompilerPhase["Syntax"] = 0] = "Syntax"; + CompilerPhase[CompilerPhase["Semantics"] = 1] = "Semantics"; + CompilerPhase[CompilerPhase["EmitOptionsValidation"] = 2] = "EmitOptionsValidation"; + CompilerPhase[CompilerPhase["Emit"] = 3] = "Emit"; + CompilerPhase[CompilerPhase["DeclarationEmit"] = 4] = "DeclarationEmit"; + })(CompilerPhase || (CompilerPhase = {})); + + var CompilerIterator = (function () { + function CompilerIterator(compiler, resolvePath, continueOnDiagnostics, startingPhase) { + if (typeof startingPhase === "undefined") { startingPhase = 0 /* Syntax */; } + this.compiler = compiler; + this.resolvePath = resolvePath; + this.continueOnDiagnostics = continueOnDiagnostics; + this.index = -1; + this.fileNames = null; + this._current = null; + this._emitOptions = null; + this._sharedEmitter = null; + this._sharedDeclarationEmitter = null; + this.hadSyntacticDiagnostics = false; + this.hadSemanticDiagnostics = false; + this.hadEmitDiagnostics = false; + this.fileNames = compiler.fileNames(); + this.compilerPhase = startingPhase; + } + CompilerIterator.prototype.current = function () { + return this._current; + }; + + CompilerIterator.prototype.moveNext = function () { + this._current = null; + + while (this.moveNextInternal()) { + if (this._current) { + return true; + } + } + + return false; + }; + + CompilerIterator.prototype.moveNextInternal = function () { + this.index++; + + while (this.shouldMoveToNextPhase()) { + this.index = 0; + this.compilerPhase++; + } + + if (this.compilerPhase > 4 /* DeclarationEmit */) { + return false; + } + + switch (this.compilerPhase) { + case 0 /* Syntax */: + return this.moveNextSyntaxPhase(); + case 1 /* Semantics */: + return this.moveNextSemanticsPhase(); + case 2 /* EmitOptionsValidation */: + return this.moveNextEmitOptionsValidationPhase(); + case 3 /* Emit */: + return this.moveNextEmitPhase(); + case 4 /* DeclarationEmit */: + return this.moveNextDeclarationEmitPhase(); + } + }; + + CompilerIterator.prototype.shouldMoveToNextPhase = function () { + switch (this.compilerPhase) { + case 2 /* EmitOptionsValidation */: + return this.index === 1; + + case 0 /* Syntax */: + case 1 /* Semantics */: + return this.index == this.fileNames.length; + + case 3 /* Emit */: + case 4 /* DeclarationEmit */: + return this.index == (this.fileNames.length + 1); + } + + return false; + }; + + CompilerIterator.prototype.moveNextSyntaxPhase = function () { + TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length); + var fileName = this.fileNames[this.index]; + + var diagnostics = this.compiler.getSyntacticDiagnostics(fileName); + if (diagnostics.length) { + if (!this.continueOnDiagnostics) { + this.hadSyntacticDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics(diagnostics); + } + + return true; + }; + + CompilerIterator.prototype.moveNextSemanticsPhase = function () { + if (this.hadSyntacticDiagnostics) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index < this.fileNames.length); + var fileName = this.fileNames[this.index]; + var diagnostics = this.compiler.getSemanticDiagnostics(fileName); + if (diagnostics.length) { + if (!this.continueOnDiagnostics) { + this.hadSemanticDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics(diagnostics); + } + + return true; + }; + + CompilerIterator.prototype.moveNextEmitOptionsValidationPhase = function () { + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + + if (!this._emitOptions) { + this._emitOptions = new TypeScript.EmitOptions(this.compiler, this.resolvePath); + } + + if (this._emitOptions.diagnostic()) { + if (!this.continueOnDiagnostics) { + this.hadEmitDiagnostics = true; + } + + this._current = CompileResult.fromDiagnostics([this._emitOptions.diagnostic()]); + } + + return true; + }; + + CompilerIterator.prototype.moveNextEmitPhase = function () { + var _this = this; + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + TypeScript.Debug.assert(this._emitOptions); + + if (this.hadEmitDiagnostics) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length); + if (this.index < this.fileNames.length) { + var fileName = this.fileNames[this.index]; + var document = this.compiler.getDocument(fileName); + + this._sharedEmitter = this.compiler._emitDocument(document, this._emitOptions, function (outputFiles) { + _this._current = CompileResult.fromOutputFiles(outputFiles); + }, this._sharedEmitter); + return true; + } + + if (this.index === this.fileNames.length && this._sharedEmitter) { + this._current = CompileResult.fromOutputFiles(this._sharedEmitter.getOutputFiles()); + } + + return true; + }; + + CompilerIterator.prototype.moveNextDeclarationEmitPhase = function () { + var _this = this; + TypeScript.Debug.assert(!this.hadSyntacticDiagnostics); + TypeScript.Debug.assert(!this.hadEmitDiagnostics); + if (this.hadSemanticDiagnostics) { + return false; + } + + if (!this.compiler.compilationSettings().generateDeclarationFiles()) { + return false; + } + + TypeScript.Debug.assert(this.index >= 0 && this.index <= this.fileNames.length); + if (this.index < this.fileNames.length) { + var fileName = this.fileNames[this.index]; + var document = this.compiler.getDocument(fileName); + + this._sharedDeclarationEmitter = this.compiler._emitDocumentDeclarations(document, this._emitOptions, function (file) { + _this._current = CompileResult.fromOutputFiles([file]); + }, this._sharedDeclarationEmitter); + return true; + } + + if (this.index === this.fileNames.length && this._sharedDeclarationEmitter) { + this._current = CompileResult.fromOutputFiles([this._sharedDeclarationEmitter.getOutputFile()]); + } + + return true; + }; + return CompilerIterator; + })(); + + function compareDataObjects(dst, src) { + for (var e in dst) { + if (typeof dst[e] == "object") { + if (!compareDataObjects(dst[e], src[e])) + return false; + } else if (typeof dst[e] != "function") { + if (dst[e] !== src[e]) + return false; + } + } + return true; + } + TypeScript.compareDataObjects = compareDataObjects; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + (function (GenerativeTypeClassification) { + GenerativeTypeClassification[GenerativeTypeClassification["Unknown"] = 0] = "Unknown"; + GenerativeTypeClassification[GenerativeTypeClassification["Open"] = 1] = "Open"; + GenerativeTypeClassification[GenerativeTypeClassification["Closed"] = 2] = "Closed"; + GenerativeTypeClassification[GenerativeTypeClassification["InfinitelyExpanding"] = 3] = "InfinitelyExpanding"; + })(TypeScript.GenerativeTypeClassification || (TypeScript.GenerativeTypeClassification = {})); + var GenerativeTypeClassification = TypeScript.GenerativeTypeClassification; + + var PullTypeReferenceSymbol = (function (_super) { + __extends(PullTypeReferenceSymbol, _super); + function PullTypeReferenceSymbol(referencedTypeSymbol) { + _super.call(this, referencedTypeSymbol.name, referencedTypeSymbol.kind); + this.referencedTypeSymbol = referencedTypeSymbol; + this.isResolved = true; + + TypeScript.Debug.assert(referencedTypeSymbol != null, "Type root symbol may not be null"); + + this.setRootSymbol(referencedTypeSymbol); + + this.typeReference = this; + } + PullTypeReferenceSymbol.createTypeReference = function (type) { + if (type.isTypeReference()) { + return type; + } + + var typeReference = type.typeReference; + + if (!typeReference) { + typeReference = new PullTypeReferenceSymbol(type); + type.typeReference = typeReference; + } + + return typeReference; + }; + + PullTypeReferenceSymbol.prototype.isTypeReference = function () { + return true; + }; + + PullTypeReferenceSymbol.prototype.setResolved = function () { + }; + + PullTypeReferenceSymbol.prototype.setUnresolved = function () { + }; + PullTypeReferenceSymbol.prototype.invalidate = function () { + }; + + PullTypeReferenceSymbol.prototype.ensureReferencedTypeIsResolved = function () { + this._getResolver().resolveDeclaredSymbol(this.referencedTypeSymbol); + }; + + PullTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol; + }; + + PullTypeReferenceSymbol.prototype._getResolver = function () { + return this.referencedTypeSymbol._getResolver(); + }; + + PullTypeReferenceSymbol.prototype.hasMembers = function () { + return this.referencedTypeSymbol.hasMembers(); + }; + + PullTypeReferenceSymbol.prototype.setAssociatedContainerType = function (type) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setAssociatedContainerType"); + }; + + PullTypeReferenceSymbol.prototype.getAssociatedContainerType = function () { + return this.referencedTypeSymbol.getAssociatedContainerType(); + }; + + PullTypeReferenceSymbol.prototype.getFunctionSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getFunctionSymbol(); + }; + PullTypeReferenceSymbol.prototype.setFunctionSymbol = function (symbol) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setFunctionSymbol"); + }; + + PullTypeReferenceSymbol.prototype.addContainedNonMember = function (nonMember) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addContainedNonMember"); + }; + PullTypeReferenceSymbol.prototype.findContainedNonMemberContainer = function (containerName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.findContainedNonMemberContainer(containerName, kind); + }; + + PullTypeReferenceSymbol.prototype.addMember = function (memberSymbol) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addMember"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedMemberType = function (enclosedType) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberType"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedMemberContainer = function (enclosedContainer) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedMemberContainer"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMember = function (enclosedNonMember) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMember"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMemberType = function (enclosedNonMemberType) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberType"); + }; + PullTypeReferenceSymbol.prototype.addEnclosedNonMemberContainer = function (enclosedNonMemberContainer) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addEnclosedNonMemberContainer"); + }; + PullTypeReferenceSymbol.prototype.addTypeParameter = function (typeParameter) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addTypeParameter"); + }; + PullTypeReferenceSymbol.prototype.addConstructorTypeParameter = function (typeParameter) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructorTypeParameter"); + }; + + PullTypeReferenceSymbol.prototype.findContainedNonMember = function (name) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findContainedNonMember(name); + }; + + PullTypeReferenceSymbol.prototype.findContainedNonMemberType = function (typeName, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findContainedNonMemberType(typeName, kind); + }; + + PullTypeReferenceSymbol.prototype.getMembers = function () { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getMembers(); + }; + + PullTypeReferenceSymbol.prototype.setHasDefaultConstructor = function (hasOne) { + if (typeof hasOne === "undefined") { hasOne = true; } + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ":setHasDefaultConstructor"); + }; + PullTypeReferenceSymbol.prototype.getHasDefaultConstructor = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getHasDefaultConstructor(); + }; + PullTypeReferenceSymbol.prototype.getConstructorMethod = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getConstructorMethod(); + }; + PullTypeReferenceSymbol.prototype.setConstructorMethod = function (constructorMethod) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": setConstructorMethod"); + }; + PullTypeReferenceSymbol.prototype.getTypeParameters = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeParameters(); + }; + + PullTypeReferenceSymbol.prototype.isGeneric = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.isGeneric(); + }; + + PullTypeReferenceSymbol.prototype.addSpecialization = function (specializedVersionOfThisType, substitutingTypes) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.addSpecialization(specializedVersionOfThisType, substitutingTypes); + }; + PullTypeReferenceSymbol.prototype.getSpecialization = function (substitutingTypes) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getSpecialization(substitutingTypes); + }; + PullTypeReferenceSymbol.prototype.getKnownSpecializations = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getKnownSpecializations(); + }; + PullTypeReferenceSymbol.prototype.getTypeArguments = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeArguments(); + }; + PullTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypeArgumentsOrTypeParameters(); + }; + + PullTypeReferenceSymbol.prototype.addCallSignature = function (callSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addCallSignature"); + }; + PullTypeReferenceSymbol.prototype.addConstructSignature = function (constructSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addConstructSignature"); + }; + PullTypeReferenceSymbol.prototype.addIndexSignature = function (indexSignature) { + TypeScript.Debug.fail("Reference symbol " + this.pullSymbolID + ": addIndexSignature"); + }; + + PullTypeReferenceSymbol.prototype.hasOwnCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnCallSignatures(); + }; + PullTypeReferenceSymbol.prototype.getCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getCallSignatures(); + }; + PullTypeReferenceSymbol.prototype.hasOwnConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnConstructSignatures(); + }; + PullTypeReferenceSymbol.prototype.getConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getConstructSignatures(); + }; + PullTypeReferenceSymbol.prototype.hasOwnIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasOwnIndexSignatures(); + }; + PullTypeReferenceSymbol.prototype.getIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getIndexSignatures(); + }; + + PullTypeReferenceSymbol.prototype.addImplementedType = function (implementedType) { + this.referencedTypeSymbol.addImplementedType(implementedType); + }; + PullTypeReferenceSymbol.prototype.getImplementedTypes = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getImplementedTypes(); + }; + PullTypeReferenceSymbol.prototype.addExtendedType = function (extendedType) { + this.referencedTypeSymbol.addExtendedType(extendedType); + }; + PullTypeReferenceSymbol.prototype.getExtendedTypes = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getExtendedTypes(); + }; + PullTypeReferenceSymbol.prototype.addTypeThatExtendsThisType = function (type) { + this.referencedTypeSymbol.addTypeThatExtendsThisType(type); + }; + PullTypeReferenceSymbol.prototype.getTypesThatExtendThisType = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypesThatExtendThisType(); + }; + PullTypeReferenceSymbol.prototype.addTypeThatExplicitlyImplementsThisType = function (type) { + this.referencedTypeSymbol.addTypeThatExplicitlyImplementsThisType(type); + }; + PullTypeReferenceSymbol.prototype.getTypesThatExplicitlyImplementThisType = function () { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.getTypesThatExplicitlyImplementThisType(); + }; + + PullTypeReferenceSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.hasBase(potentialBase, visited); + }; + PullTypeReferenceSymbol.prototype.isValidBaseKind = function (baseType, isExtendedType) { + this.ensureReferencedTypeIsResolved(); + return this.referencedTypeSymbol.isValidBaseKind(baseType, isExtendedType); + }; + + PullTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) { + if (typeof lookInParent === "undefined") { lookInParent = true; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findMember(name, lookInParent); + }; + PullTypeReferenceSymbol.prototype.findNestedType = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findNestedType(name, kind); + }; + PullTypeReferenceSymbol.prototype.findNestedContainer = function (name, kind) { + if (typeof kind === "undefined") { kind = 0 /* None */; } + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findNestedContainer(name, kind); + }; + PullTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + }; + + PullTypeReferenceSymbol.prototype.findTypeParameter = function (name) { + this.ensureReferencedTypeIsResolved(); + + return this.referencedTypeSymbol.findTypeParameter(name); + }; + + PullTypeReferenceSymbol.prototype.hasOnlyOverloadCallSignatures = function () { + return this.referencedTypeSymbol.hasOnlyOverloadCallSignatures(); + }; + return PullTypeReferenceSymbol; + })(TypeScript.PullTypeSymbol); + TypeScript.PullTypeReferenceSymbol = PullTypeReferenceSymbol; + + TypeScript.nSpecializationsCreated = 0; + TypeScript.nSpecializedSignaturesCreated = 0; + + var PullInstantiatedTypeReferenceSymbol = (function (_super) { + __extends(PullInstantiatedTypeReferenceSymbol, _super); + function PullInstantiatedTypeReferenceSymbol(referencedTypeSymbol, _typeParameterArgumentMap) { + _super.call(this, referencedTypeSymbol); + this.referencedTypeSymbol = referencedTypeSymbol; + this._typeParameterArgumentMap = _typeParameterArgumentMap; + this._instantiatedMembers = null; + this._allInstantiatedMemberNameCache = null; + this._instantiatedMemberNameCache = TypeScript.createIntrinsicsObject(); + this._instantiatedCallSignatures = null; + this._instantiatedConstructSignatures = null; + this._instantiatedIndexSignatures = null; + this._typeArgumentReferences = null; + this._instantiatedConstructorMethod = null; + this._instantiatedAssociatedContainerType = null; + this._isArray = undefined; + this.isInstanceReferenceType = false; + this._generativeTypeClassification = 0 /* Unknown */; + + TypeScript.nSpecializationsCreated++; + } + PullInstantiatedTypeReferenceSymbol.prototype.getIsSpecialized = function () { + return !this.isInstanceReferenceType; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getGenerativeTypeClassification = function (enclosingType) { + if (this._generativeTypeClassification == 0 /* Unknown */) { + var typeParameters = enclosingType.getTypeParameters(); + var typeReferenceTypeArguments = this.getRootSymbol().getTypeArguments(); + var referenceTypeArgument = null; + + if (!typeReferenceTypeArguments) { + var typeParametersMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParametersMap[typeParameters[i].pullSymbolID] = typeParameters[i]; + } + + var rootThis = TypeScript.PullHelpers.getRootType(this); + var wrapsSomeTypeParameters = rootThis.wrapsSomeTypeParameter(typeParametersMap); + + if (wrapsSomeTypeParameters && this.wrapsSomeNestedTypeIntoInfiniteExpansion(enclosingType)) { + this._generativeTypeClassification = 3 /* InfinitelyExpanding */; + } else if (wrapsSomeTypeParameters) { + this._generativeTypeClassification = 1 /* Open */; + } else { + this._generativeTypeClassification = 2 /* Closed */; + } + } else { + var i = 0; + + while (i < typeReferenceTypeArguments.length) { + referenceTypeArgument = typeReferenceTypeArguments[i].getRootSymbol(); + + if (referenceTypeArgument.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + break; + } + + i++; + } + + if (i == typeParameters.length) { + this._generativeTypeClassification = 2 /* Closed */; + } + + if (this._generativeTypeClassification == 0 /* Unknown */) { + var i = 0; + + while ((this._generativeTypeClassification == 0 /* Unknown */) && (i < typeReferenceTypeArguments.length)) { + for (var j = 0; j < typeParameters.length; j++) { + if (typeParameters[j] == typeReferenceTypeArguments[i]) { + this._generativeTypeClassification = 1 /* Open */; + break; + } + } + + i++; + } + + if (this._generativeTypeClassification != 1 /* Open */) { + this._generativeTypeClassification = 3 /* InfinitelyExpanding */; + } + } + } + } + + return this._generativeTypeClassification; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.isArrayNamedTypeReference = function () { + if (this._isArray === undefined) { + this._isArray = this.getRootSymbol().isArrayNamedTypeReference() || (this.getRootSymbol() == this._getResolver().getArrayNamedType()); + } + return this._isArray; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getElementType = function () { + if (!this.isArrayNamedTypeReference()) { + return null; + } + + var typeArguments = this.getTypeArguments(); + + if (typeArguments != null) { + return typeArguments[0]; + } + + return null; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getReferencedTypeSymbol = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.getIsSpecialized()) { + return this; + } + + return this.referencedTypeSymbol; + }; + + PullInstantiatedTypeReferenceSymbol.create = function (resolver, type, typeParameterArgumentMap, instantiateFunctionTypeParameters) { + if (typeof instantiateFunctionTypeParameters === "undefined") { instantiateFunctionTypeParameters = false; } + TypeScript.Debug.assert(resolver); + + var rootType = type.getRootSymbol(); + + var reconstructedTypeArgumentList = []; + var typeArguments = type.getTypeArguments(); + var typeParameters = rootType.getTypeParameters(); + + if (type.getIsSpecialized() && typeArguments && typeArguments.length) { + for (var i = 0; i < typeArguments.length; i++) { + reconstructedTypeArgumentList[reconstructedTypeArgumentList.length] = resolver.instantiateType(typeArguments[i], typeParameterArgumentMap, instantiateFunctionTypeParameters); + } + + for (var i = 0; i < typeArguments.length; i++) { + typeParameterArgumentMap[typeArguments[i].pullSymbolID] = reconstructedTypeArgumentList[i]; + } + } else { + var tyArg = null; + + for (var typeParameterID in typeParameterArgumentMap) { + if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) { + tyArg = typeParameterArgumentMap[typeParameterID]; + + if (tyArg) { + reconstructedTypeArgumentList[reconstructedTypeArgumentList.length] = tyArg; + } + } + } + } + + if (!instantiateFunctionTypeParameters) { + var instantiation = rootType.getSpecialization(reconstructedTypeArgumentList); + + if (instantiation) { + return instantiation; + } + } + + var isReferencedType = (type.kind & 8216 /* SomeInstantiatableType */) != 0; + + if (isReferencedType) { + if (typeParameters && reconstructedTypeArgumentList) { + if (typeParameters.length == reconstructedTypeArgumentList.length) { + for (var i = 0; i < typeParameters.length; i++) { + if (!TypeScript.PullHelpers.typeSymbolsAreIdentical(typeParameters[i], reconstructedTypeArgumentList[i])) { + isReferencedType = false; + break; + } + } + + if (isReferencedType) { + typeParameterArgumentMap = []; + } + } else { + isReferencedType = false; + } + } + } + + var instantiateRoot = isReferencedType; + + if (type.isTypeReference() && type.isGeneric()) { + var initializationMap = []; + + for (var typeParameterID in typeParameterArgumentMap) { + if (typeParameterArgumentMap.hasOwnProperty(typeParameterID)) { + initializationMap[typeParameterID] = typeParameterArgumentMap[typeParameterID]; + } + } + + var oldMap = typeParameterArgumentMap; + + var outerTypeMap = type._typeParameterArgumentMap; + var innerSubstitution = null; + var outerSubstitution = null; + var canRelatePreInstantiatedTypeParametersToRootTypeParameters = true; + + for (var typeParameterID in outerTypeMap) { + if (outerTypeMap.hasOwnProperty(typeParameterID)) { + outerSubstitution = outerTypeMap[typeParameterID]; + innerSubstitution = typeParameterArgumentMap[outerSubstitution.pullSymbolID]; + + if (innerSubstitution && (!outerSubstitution.isTypeParameter() || !outerTypeMap[innerSubstitution.pullSymbolID] || !outerTypeMap[outerTypeMap[typeParameterID].pullSymbolID] || (outerTypeMap[outerTypeMap[typeParameterID].pullSymbolID] == outerSubstitution))) { + initializationMap[typeParameterID] = typeParameterArgumentMap[outerTypeMap[typeParameterID].pullSymbolID]; + + if (!outerSubstitution.isTypeParameter()) { + canRelatePreInstantiatedTypeParametersToRootTypeParameters = false; + } + } else { + canRelatePreInstantiatedTypeParametersToRootTypeParameters = false; + } + } + } + + if (canRelatePreInstantiatedTypeParametersToRootTypeParameters && typeParameters.length) { + typeParameterArgumentMap = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeParameterArgumentMap[typeParameters[i].pullSymbolID] = initializationMap[typeParameters[i].pullSymbolID]; + } + + instantiateRoot = true; + } else { + typeParameterArgumentMap = initializationMap; + } + } + + instantiation = new PullInstantiatedTypeReferenceSymbol(instantiateRoot ? rootType : type, typeParameterArgumentMap); + + if (!instantiateFunctionTypeParameters) { + rootType.addSpecialization(instantiation, reconstructedTypeArgumentList); + } + + if (isReferencedType) { + instantiation.isInstanceReferenceType = true; + } + + return instantiation; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.isGeneric = function () { + return !!this.referencedTypeSymbol.getTypeParameters().length; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeParameterArgumentMap = function () { + return this._typeParameterArgumentMap; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeArguments = function () { + if (this.isInstanceReferenceType) { + return this.getTypeParameters(); + } + + if (!this._typeArgumentReferences) { + var typeParameters = this.referencedTypeSymbol.getTypeParameters(); + + if (typeParameters.length) { + var typeArgument = null; + var typeArguments = []; + + for (var i = 0; i < typeParameters.length; i++) { + typeArgument = this._typeParameterArgumentMap[typeParameters[i].pullSymbolID]; + + if (!typeArgument) { + TypeScript.Debug.fail("type argument count mismatch"); + } + + if (typeArgument) { + typeArguments[typeArguments.length] = typeArgument; + } + } + + this._typeArgumentReferences = typeArguments; + } + } + + return this._typeArgumentReferences; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getTypeArgumentsOrTypeParameters = function () { + return this.getTypeArguments(); + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getMembers = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getMembers(); + } + + if (!this._instantiatedMembers) { + var referencedMembers = this.referencedTypeSymbol.getMembers(); + var referencedMember = null; + var instantiatedMember = null; + + this._instantiatedMembers = []; + + for (var i = 0; i < referencedMembers.length; i++) { + referencedMember = referencedMembers[i]; + + this._getResolver().resolveDeclaredSymbol(referencedMember); + + if (!this._instantiatedMemberNameCache[referencedMember.name]) { + if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + instantiatedMember = referencedMember; + } else { + instantiatedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind); + instantiatedMember.setRootSymbol(referencedMember); + instantiatedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap); + instantiatedMember.isOptional = referencedMember.isOptional; + } + + this._instantiatedMemberNameCache[instantiatedMember.name] = instantiatedMember; + } else { + instantiatedMember = this._instantiatedMemberNameCache[referencedMember.name]; + } + + this._instantiatedMembers[this._instantiatedMembers.length] = instantiatedMember; + } + } + + return this._instantiatedMembers; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.findMember = function (name, lookInParent) { + if (typeof lookInParent === "undefined") { lookInParent = true; } + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.findMember(name, lookInParent); + } + + var memberSymbol = this._instantiatedMemberNameCache[name]; + + if (!memberSymbol) { + var referencedMemberSymbol = this.referencedTypeSymbol.findMember(name, lookInParent); + + if (referencedMemberSymbol) { + memberSymbol = new TypeScript.PullSymbol(referencedMemberSymbol.name, referencedMemberSymbol.kind); + memberSymbol.setRootSymbol(referencedMemberSymbol); + + this._getResolver().resolveDeclaredSymbol(referencedMemberSymbol); + + memberSymbol.type = this._getResolver().instantiateType(referencedMemberSymbol.type, this._typeParameterArgumentMap); + + memberSymbol.isOptional = referencedMemberSymbol.isOptional; + + this._instantiatedMemberNameCache[memberSymbol.name] = memberSymbol; + } else { + memberSymbol = null; + } + } + + return memberSymbol; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getAllMembers = function (searchDeclKind, memberVisiblity) { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + } + + var requestedMembers = []; + var allReferencedMembers = this.referencedTypeSymbol.getAllMembers(searchDeclKind, memberVisiblity); + + if (!this._allInstantiatedMemberNameCache) { + this._allInstantiatedMemberNameCache = TypeScript.createIntrinsicsObject(); + + var members = this.getMembers(); + + for (var i = 0; i < members.length; i++) { + this._allInstantiatedMemberNameCache[members[i].name] = members[i]; + } + } + + var referencedMember = null; + var requestedMember = null; + + for (var i = 0; i < allReferencedMembers.length; i++) { + referencedMember = allReferencedMembers[i]; + + this._getResolver().resolveDeclaredSymbol(referencedMember); + + if (this._allInstantiatedMemberNameCache[referencedMember.name]) { + requestedMembers[requestedMembers.length] = this._allInstantiatedMemberNameCache[referencedMember.name]; + } else { + if (!referencedMember.type.wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._allInstantiatedMemberNameCache[referencedMember.name] = referencedMember; + requestedMembers[requestedMembers.length] = referencedMember; + } else { + requestedMember = new TypeScript.PullSymbol(referencedMember.name, referencedMember.kind); + requestedMember.setRootSymbol(referencedMember); + + requestedMember.type = this._getResolver().instantiateType(referencedMember.type, this._typeParameterArgumentMap); + requestedMember.isOptional = referencedMember.isOptional; + + this._allInstantiatedMemberNameCache[requestedMember.name] = requestedMember; + requestedMembers[requestedMembers.length] = requestedMember; + } + } + } + + return requestedMembers; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getConstructorMethod = function () { + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getConstructorMethod(); + } + + if (!this._instantiatedConstructorMethod) { + var referencedConstructorMethod = this.referencedTypeSymbol.getConstructorMethod(); + this._instantiatedConstructorMethod = new TypeScript.PullSymbol(referencedConstructorMethod.name, referencedConstructorMethod.kind); + this._instantiatedConstructorMethod.type = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedConstructorMethod.type, this._typeParameterArgumentMap); + } + + return this._instantiatedConstructorMethod; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getAssociatedContainerType = function () { + if (!this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getAssociatedContainerType(); + } + + if (!this._instantiatedAssociatedContainerType) { + var referencedAssociatedContainerType = this.referencedTypeSymbol.getAssociatedContainerType(); + + if (referencedAssociatedContainerType) { + this._instantiatedAssociatedContainerType = PullInstantiatedTypeReferenceSymbol.create(this._getResolver(), referencedAssociatedContainerType, this._typeParameterArgumentMap); + } + } + + return this._instantiatedAssociatedContainerType; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getCallSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getCallSignatures(); + } + + if (this._instantiatedCallSignatures) { + return this._instantiatedCallSignatures; + } + + var referencedCallSignatures = this.referencedTypeSymbol.getCallSignatures(); + this._instantiatedCallSignatures = []; + + for (var i = 0; i < referencedCallSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedCallSignatures[i]); + + if (!referencedCallSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = referencedCallSignatures[i]; + } else { + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length] = this._getResolver().instantiateSignature(referencedCallSignatures[i], this._typeParameterArgumentMap); + this._instantiatedCallSignatures[this._instantiatedCallSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedCallSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getConstructSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getConstructSignatures(); + } + + if (this._instantiatedConstructSignatures) { + return this._instantiatedConstructSignatures; + } + + var referencedConstructSignatures = this.referencedTypeSymbol.getConstructSignatures(); + this._instantiatedConstructSignatures = []; + + for (var i = 0; i < referencedConstructSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedConstructSignatures[i]); + + if (!referencedConstructSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = referencedConstructSignatures[i]; + } else { + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length] = this._getResolver().instantiateSignature(referencedConstructSignatures[i], this._typeParameterArgumentMap); + this._instantiatedConstructSignatures[this._instantiatedConstructSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedConstructSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.getIndexSignatures = function () { + this.ensureReferencedTypeIsResolved(); + + if (this.isInstanceReferenceType) { + return this.referencedTypeSymbol.getIndexSignatures(); + } + + if (this._instantiatedIndexSignatures) { + return this._instantiatedIndexSignatures; + } + + var referencedIndexSignatures = this.referencedTypeSymbol.getIndexSignatures(); + this._instantiatedIndexSignatures = []; + + for (var i = 0; i < referencedIndexSignatures.length; i++) { + this._getResolver().resolveDeclaredSymbol(referencedIndexSignatures[i]); + + if (!referencedIndexSignatures[i].wrapsSomeTypeParameter(this._typeParameterArgumentMap)) { + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = referencedIndexSignatures[i]; + } else { + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length] = this._getResolver().instantiateSignature(referencedIndexSignatures[i], this._typeParameterArgumentMap); + this._instantiatedIndexSignatures[this._instantiatedIndexSignatures.length - 1].functionType = this; + } + } + + return this._instantiatedIndexSignatures; + }; + + PullInstantiatedTypeReferenceSymbol.prototype.hasBase = function (potentialBase, visited) { + if (typeof visited === "undefined") { visited = []; } + return this.referencedTypeSymbol.hasBase(potentialBase, visited); + }; + return PullInstantiatedTypeReferenceSymbol; + })(PullTypeReferenceSymbol); + TypeScript.PullInstantiatedTypeReferenceSymbol = PullInstantiatedTypeReferenceSymbol; +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var SyntaxTreeToAstVisitor = (function () { + function SyntaxTreeToAstVisitor(fileName, lineMap, compilationSettings) { + this.fileName = fileName; + this.lineMap = lineMap; + this.compilationSettings = compilationSettings; + this.position = 0; + this.previousTokenTrailingComments = null; + } + SyntaxTreeToAstVisitor.visit = function (syntaxTree, fileName, compilationSettings, incrementalAST) { + var visitor = incrementalAST ? new SyntaxTreeToIncrementalAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings) : new SyntaxTreeToAstVisitor(fileName, syntaxTree.lineMap(), compilationSettings); + return syntaxTree.sourceUnit().accept(visitor); + }; + + SyntaxTreeToAstVisitor.prototype.movePast = function (element) { + if (element !== null) { + this.position += element.fullWidth(); + } + }; + + SyntaxTreeToAstVisitor.prototype.moveTo = function (element1, element2) { + if (element2 !== null) { + this.position += TypeScript.Syntax.childOffset(element1, element2); + } + }; + + SyntaxTreeToAstVisitor.prototype.setCommentsAndSpan = function (ast, fullStart, node) { + var firstToken = node.firstToken(); + var lastToken = node.lastToken(); + + this.setSpan(ast, fullStart, node, firstToken, lastToken); + ast.setPreComments(this.convertTokenLeadingComments(firstToken, fullStart)); + ast.setPostComments(this.convertNodeTrailingComments(node, lastToken, fullStart)); + }; + + SyntaxTreeToAstVisitor.prototype.createTokenSpan = function (fullStart, element) { + if (element === null) { + return null; + } + + if (element.fullWidth() === 0) { + return new TypeScript.ASTSpan(-1, -1); + } + + var leadingTriviaWidth = element.leadingTriviaWidth(); + var trailingTriviaWidth = element.trailingTriviaWidth(); + + var start = fullStart + leadingTriviaWidth; + var end = fullStart + element.fullWidth() - trailingTriviaWidth; + + return new TypeScript.ASTSpan(start, end); + }; + + SyntaxTreeToAstVisitor.prototype.setSpan = function (span, fullStart, element, firstToken, lastToken) { + if (typeof firstToken === "undefined") { firstToken = element.firstToken(); } + if (typeof lastToken === "undefined") { lastToken = element.lastToken(); } + var leadingTriviaWidth = firstToken ? firstToken.leadingTriviaWidth() : 0; + var trailingTriviaWidth = lastToken ? lastToken.trailingTriviaWidth() : 0; + + var desiredMinChar = fullStart + leadingTriviaWidth; + var desiredLimChar = fullStart + element.fullWidth() - trailingTriviaWidth; + + this.setSpanExplicit(span, desiredMinChar, desiredLimChar); + + span._trailingTriviaWidth = trailingTriviaWidth; + }; + + SyntaxTreeToAstVisitor.prototype.setSpanExplicit = function (span, start, end) { + span._start = start; + span._end = end; + }; + + SyntaxTreeToAstVisitor.prototype.visitSyntaxList = function (node) { + var start = this.position; + var array = new Array(node.childCount()); + + for (var i = 0, n = node.childCount(); i < n; i++) { + array[i] = node.childAt(i).accept(this); + } + + var result = new TypeScript.ISyntaxList2(this.fileName, array); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSeparatedSyntaxList = function (list) { + var start = this.position; + var array = new Array(list.nonSeparatorCount()); + + for (var i = 0, n = list.childCount(); i < n; i++) { + if (i % 2 === 0) { + array[i / 2] = list.childAt(i).accept(this); + this.previousTokenTrailingComments = null; + } else { + var separatorToken = list.childAt(i); + this.previousTokenTrailingComments = this.convertTokenTrailingComments(separatorToken, this.position + separatorToken.leadingTriviaWidth() + separatorToken.width()); + this.movePast(separatorToken); + } + } + + var result = new TypeScript.ISeparatedSyntaxList2(this.fileName, array, list.separatorCount()); + this.setSpan(result, start, list); + + result.setPostComments(this.previousTokenTrailingComments); + this.previousTokenTrailingComments = null; + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.convertComment = function (trivia, commentStartPosition, hasTrailingNewLine) { + var comment = new TypeScript.Comment(trivia, hasTrailingNewLine, commentStartPosition, commentStartPosition + trivia.fullWidth()); + + return comment; + }; + + SyntaxTreeToAstVisitor.prototype.convertComments = function (triviaList, commentStartPosition) { + var result = []; + + for (var i = 0, n = triviaList.count(); i < n; i++) { + var trivia = triviaList.syntaxTriviaAt(i); + + if (trivia.isComment()) { + var hasTrailingNewLine = ((i + 1) < n) && triviaList.syntaxTriviaAt(i + 1).isNewLine(); + result.push(this.convertComment(trivia, commentStartPosition, hasTrailingNewLine)); + } + + commentStartPosition += trivia.fullWidth(); + } + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.mergeComments = function (comments1, comments2) { + if (comments1 === null) { + return comments2; + } + + if (comments2 === null) { + return comments1; + } + + return comments1.concat(comments2); + }; + + SyntaxTreeToAstVisitor.prototype.convertTokenLeadingComments = function (token, commentStartPosition) { + if (token === null) { + return null; + } + + var preComments = token.hasLeadingComment() ? this.convertComments(token.leadingTrivia(), commentStartPosition) : null; + + var previousTokenTrailingComments = this.previousTokenTrailingComments; + this.previousTokenTrailingComments = null; + + return this.mergeComments(previousTokenTrailingComments, preComments); + }; + + SyntaxTreeToAstVisitor.prototype.convertTokenTrailingComments = function (token, commentStartPosition) { + if (token === null || !token.hasTrailingComment() || token.hasTrailingNewLine()) { + return null; + } + + return this.convertComments(token.trailingTrivia(), commentStartPosition); + }; + + SyntaxTreeToAstVisitor.prototype.convertNodeTrailingComments = function (node, lastToken, nodeStart) { + if (lastToken === null || !lastToken.hasTrailingComment() || lastToken.hasTrailingNewLine()) { + return null; + } + + return this.convertComments(lastToken.trailingTrivia(), nodeStart + node.fullWidth() - lastToken.trailingTriviaWidth()); + }; + + SyntaxTreeToAstVisitor.prototype.visitIdentifier = function (token) { + return this.visitToken(token); + }; + + SyntaxTreeToAstVisitor.prototype.visitToken = function (token) { + var fullStart = this.position; + + var result = this.visitTokenWorker(token); + + this.movePast(token); + + var start = fullStart + token.leadingTriviaWidth(); + this.setSpanExplicit(result, start, start + token.width()); + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTokenWorker = function (token) { + switch (token.tokenKind) { + case 60 /* AnyKeyword */: + return new TypeScript.BuiltInType(60 /* AnyKeyword */, token.text(), token.valueText()); + case 61 /* BooleanKeyword */: + return new TypeScript.BuiltInType(61 /* BooleanKeyword */, token.text(), token.valueText()); + case 67 /* NumberKeyword */: + return new TypeScript.BuiltInType(67 /* NumberKeyword */, token.text(), token.valueText()); + case 69 /* StringKeyword */: + return new TypeScript.BuiltInType(69 /* StringKeyword */, token.text(), token.valueText()); + case 41 /* VoidKeyword */: + return new TypeScript.BuiltInType(41 /* VoidKeyword */, token.text(), token.valueText()); + case 35 /* ThisKeyword */: + return new TypeScript.ThisExpression(token.text(), token.valueText()); + case 50 /* SuperKeyword */: + return new TypeScript.SuperExpression(token.text(), token.valueText()); + case 37 /* TrueKeyword */: + return new TypeScript.LiteralExpression(37 /* TrueKeyword */, token.text(), token.valueText()); + case 24 /* FalseKeyword */: + return new TypeScript.LiteralExpression(24 /* FalseKeyword */, token.text(), token.valueText()); + case 32 /* NullKeyword */: + return new TypeScript.LiteralExpression(32 /* NullKeyword */, token.text(), token.valueText()); + case 14 /* StringLiteral */: + return new TypeScript.StringLiteral(token.text(), token.valueText()); + case 12 /* RegularExpressionLiteral */: + return new TypeScript.RegularExpressionLiteral(token.text(), token.valueText()); + case 13 /* NumericLiteral */: + var fullStart = this.position; + var preComments = this.convertTokenLeadingComments(token, fullStart); + + var result = new TypeScript.NumericLiteral(token.value(), token.text(), token.valueText()); + + result.setPreComments(preComments); + return result; + case 11 /* IdentifierName */: + return new TypeScript.Identifier(token.text()); + default: + throw TypeScript.Errors.invalidOperation(); + } + }; + + SyntaxTreeToAstVisitor.prototype.visitSourceUnit = function (node) { + var start = this.position; + TypeScript.Debug.assert(start === 0); + + var bod = this.visitSyntaxList(node.moduleElements); + + var result = new TypeScript.SourceUnit(bod, this.fileName); + this.setSpanExplicit(result, start, start + node.fullWidth()); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExternalModuleReference = function (node) { + var start = this.position; + + this.moveTo(node, node.stringLiteral); + var stringLiteral = node.stringLiteral.accept(this); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ExternalModuleReference(stringLiteral); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModuleNameModuleReference = function (node) { + var start = this.position; + var moduleName = node.moduleName.accept(this); + + var result = new TypeScript.ModuleNameModuleReference(moduleName); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitClassDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null; + + this.movePast(node.openBraceToken); + var members = this.visitSyntaxList(node.classElements); + + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members, closeBraceToken); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModifiers = function (modifiers) { + var result = null; + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 47 /* ExportKeyword */)) { + result = result || []; + result.push(1 /* Exported */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 63 /* DeclareKeyword */)) { + result = result || []; + result.push(8 /* Ambient */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 58 /* StaticKeyword */)) { + result = result || []; + result.push(16 /* Static */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 57 /* PublicKeyword */)) { + result = result || []; + result.push(4 /* Public */); + } + + if (TypeScript.SyntaxUtilities.containsToken(modifiers, 55 /* PrivateKeyword */)) { + result = result || []; + result.push(2 /* Private */); + } + + return result || TypeScript.sentinelEmptyArray; + }; + + SyntaxTreeToAstVisitor.prototype.visitInterfaceDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var heritageClauses = node.heritageClauses ? this.visitSyntaxList(node.heritageClauses) : null; + + var body = this.visitObjectType(node.body); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, body); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitHeritageClause = function (node) { + var start = this.position; + + this.movePast(node.extendsOrImplementsKeyword); + var typeNames = this.visitSeparatedSyntaxList(node.typeNames); + + var result = new TypeScript.HeritageClause(node.extendsOrImplementsKeyword.tokenKind === 48 /* ExtendsKeyword */ ? 230 /* ExtendsHeritageClause */ : 231 /* ImplementsHeritageClause */, typeNames); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitModuleDeclaration = function (node) { + var start = this.position; + + var modifiers = this.visitModifiers(node.modifiers); + + this.moveTo(node, node.moduleKeyword); + this.movePast(node.moduleKeyword); + + var moduleName = node.name ? node.name.accept(this) : null; + var stringLiteral = node.stringLiteral ? node.stringLiteral.accept(this) : null; + + this.movePast(node.openBraceToken); + + var moduleElements = this.visitSyntaxList(node.moduleElements); + + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ModuleDeclaration(modifiers, moduleName, stringLiteral, moduleElements, closeBraceToken); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? this.visitBlock(node.block) : null; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.FunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEnumDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var identifier = this.visitIdentifier(node.identifier); + + this.movePast(node.openBraceToken); + + var enumElements = this.visitSeparatedSyntaxList(node.enumElements); + + this.movePast(node.closeBraceToken); + + var result = new TypeScript.EnumDeclaration(this.visitModifiers(node.modifiers), identifier, enumElements); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEnumElement = function (node) { + var start = this.position; + + var memberName = this.visitToken(node.propertyName); + + var value = node.equalsValueClause !== null ? this.visitEqualsValueClause(node.equalsValueClause) : null; + + var result = new TypeScript.EnumElement(memberName, value); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitImportDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + this.movePast(node.equalsToken); + var alias = node.moduleReference.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.ImportDeclaration(modifiers, name, alias); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExportAssignment = function (node) { + var start = this.position; + + this.moveTo(node, node.identifier); + var name = this.visitIdentifier(node.identifier); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ExportAssignment(name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclaration); + + var declaration = node.variableDeclaration.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + + var result = new TypeScript.VariableStatement(modifiers, declaration); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclarators); + var variableDecls = this.visitSeparatedSyntaxList(node.variableDeclarators); + + var result = new TypeScript.VariableDeclaration(variableDecls); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVariableDeclarator = function (node) { + var start = this.position; + var propertyName = this.visitToken(node.propertyName); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + var init = node.equalsValueClause ? this.visitEqualsValueClause(node.equalsValueClause) : null; + + var result = new TypeScript.VariableDeclarator(propertyName, typeExpr, init); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEqualsValueClause = function (node) { + var start = this.position; + var afterEqualsComments = this.convertTokenTrailingComments(node.equalsToken, this.position + node.equalsToken.leadingTriviaWidth() + node.equalsToken.width()); + + this.movePast(node.equalsToken); + var value = node.value.accept(this); + value.setPreComments(this.mergeComments(afterEqualsComments, value.preComments())); + + var result = new TypeScript.EqualsValueClause(value); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPrefixUnaryExpression = function (node) { + var start = this.position; + + this.movePast(node.operatorToken); + var operand = node.operand.accept(this); + + var result = new TypeScript.PrefixUnaryExpression(node.kind(), operand); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArrayLiteralExpression = function (node) { + var start = this.position; + var openStart = this.position + node.openBracketToken.leadingTriviaWidth(); + this.movePast(node.openBracketToken); + + var expressions = this.visitSeparatedSyntaxList(node.expressions); + + var closeStart = this.position + node.closeBracketToken.leadingTriviaWidth(); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ArrayLiteralExpression(expressions); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitOmittedExpression = function (node) { + var start = this.position; + + var result = new TypeScript.OmittedExpression(); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParenthesizedExpression = function (node) { + var start = this.position; + + var openParenToken = node.openParenToken; + var openParenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width()); + + this.movePast(openParenToken); + + var expr = node.expression.accept(this); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ParenthesizedExpression(openParenTrailingComments, expr); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + var start = this.position; + + var identifier = node.identifier.accept(this); + this.movePast(node.equalsGreaterThanToken); + + var block = node.block ? this.visitBlock(node.block) : null; + var expression = node.expression ? node.expression.accept(this) : null; + + var result = new TypeScript.SimpleArrowFunctionExpression(identifier, block, expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + var start = this.position; + + var callSignature = this.visitCallSignature(node.callSignature); + this.movePast(node.equalsGreaterThanToken); + + var block = node.block ? this.visitBlock(node.block) : null; + var expression = node.expression ? node.expression.accept(this) : null; + + var result = new TypeScript.ParenthesizedArrowFunctionExpression(callSignature, block, expression); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitType = function (type) { + return type ? type.accept(this) : null; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeQuery = function (node) { + var start = this.position; + this.movePast(node.typeOfKeyword); + var name = node.name.accept(this); + + var result = new TypeScript.TypeQuery(name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitQualifiedName = function (node) { + var start = this.position; + var left = this.visitType(node.left); + this.movePast(node.dotToken); + var right = this.visitIdentifier(node.right); + + var result = new TypeScript.QualifiedName(left, right); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeArgumentList = function (node) { + if (node === null) { + return null; + } + + var start = this.position; + this.movePast(node.lessThanToken); + var typeArguments = this.visitSeparatedSyntaxList(node.typeArguments); + this.movePast(node.greaterThanToken); + + var result = new TypeScript.TypeArgumentList(typeArguments); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructorType = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + this.movePast(node.equalsGreaterThanToken); + var returnType = this.visitType(node.type); + + var result = new TypeScript.ConstructorType(typeParameters, parameters, returnType); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionType = function (node) { + var start = this.position; + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + this.movePast(node.equalsGreaterThanToken); + var returnType = this.visitType(node.type); + + var result = new TypeScript.FunctionType(typeParameters, parameters, returnType); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectType = function (node) { + var start = this.position; + + this.movePast(node.openBraceToken); + var typeMembers = this.visitSeparatedSyntaxList(node.typeMembers); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ObjectType(typeMembers); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArrayType = function (node) { + var start = this.position; + + var underlying = this.visitType(node.type); + this.movePast(node.openBracketToken); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ArrayType(underlying); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitGenericType = function (node) { + var start = this.position; + + var underlying = this.visitType(node.name); + var typeArguments = this.visitTypeArgumentList(node.typeArgumentList); + + var result = new TypeScript.GenericType(underlying, typeArguments); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeAnnotation = function (node) { + if (!node) { + return null; + } + + var start = this.position; + this.movePast(node.colonToken); + var type = this.visitType(node.type); + + var result = new TypeScript.TypeAnnotation(type); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBlock = function (node) { + if (!node) { + return null; + } + + var start = this.position; + + this.movePast(node.openBraceToken); + var statements = this.visitSyntaxList(node.statements); + var closeBracePosition = this.position; + + var closeBraceLeadingComments = this.convertTokenLeadingComments(node.closeBraceToken, this.position); + var closeBraceToken = this.createTokenSpan(this.position, node.closeBraceToken); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.Block(statements, closeBraceLeadingComments, closeBraceToken); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParameter = function (node) { + var start = this.position; + + var dotDotDotToken = this.createTokenSpan(this.position, node.dotDotDotToken); + + this.moveTo(node, node.identifier); + var identifier = this.visitIdentifier(node.identifier); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + var init = node.equalsValueClause ? node.equalsValueClause.accept(this) : null; + + var modifiers = this.visitModifiers(node.modifiers); + + var result = new TypeScript.Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeExpr, init); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberAccessExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + this.movePast(node.dotToken); + var name = this.visitIdentifier(node.name); + + var result = new TypeScript.MemberAccessExpression(expression, name); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPostfixUnaryExpression = function (node) { + var start = this.position; + + var operand = node.operand.accept(this); + this.movePast(node.operatorToken); + + var result = new TypeScript.PostfixUnaryExpression(node.kind() === 210 /* PostIncrementExpression */ ? 210 /* PostIncrementExpression */ : 211 /* PostDecrementExpression */, operand); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitElementAccessExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + this.movePast(node.openBracketToken); + var argumentExpression = node.argumentExpression.accept(this); + this.movePast(node.closeBracketToken); + + var result = new TypeScript.ElementAccessExpression(expression, argumentExpression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitInvocationExpression = function (node) { + var start = this.position; + + var expression = node.expression.accept(this); + var argumentList = this.visitArgumentList(node.argumentList); + + var result = new TypeScript.InvocationExpression(expression, argumentList); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitArgumentList = function (node) { + if (node === null) { + return null; + } + + var start = this.position; + + var typeArguments = this.visitTypeArgumentList(node.typeArgumentList); + + this.movePast(node.openParenToken); + + var arguments = this.visitSeparatedSyntaxList(node.arguments); + + if (node.arguments.fullWidth() === 0 && node.closeParenToken.fullWidth() === 0) { + var openParenTokenEnd = start + node.openParenToken.leadingTriviaWidth() + node.openParenToken.width(); + this.setSpanExplicit(arguments, openParenTokenEnd, openParenTokenEnd + node.openParenToken.trailingTriviaWidth()); + } + + var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ArgumentList(typeArguments, arguments, closeParenToken); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBinaryExpression = function (node) { + var start = this.position; + + var left = node.left.accept(this); + this.movePast(node.operatorToken); + var right = node.right.accept(this); + + var result = new TypeScript.BinaryExpression(node.kind(), left, right); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConditionalExpression = function (node) { + var start = this.position; + + var condition = node.condition.accept(this); + this.movePast(node.questionToken); + var whenTrue = node.whenTrue.accept(this); + this.movePast(node.colonToken); + var whenFalse = node.whenFalse.accept(this); + + var result = new TypeScript.ConditionalExpression(condition, whenTrue, whenFalse); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructSignature = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var callSignature = this.visitCallSignature(node.callSignature); + + var result = new TypeScript.ConstructSignature(callSignature); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMethodSignature = function (node) { + var start = this.position; + + var name = this.visitToken(node.propertyName); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + + var callSignature = this.visitCallSignature(node.callSignature); + + var result = new TypeScript.MethodSignature(name, questionToken, callSignature); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIndexSignature = function (node) { + var start = this.position; + + this.movePast(node.openBracketToken); + + var parameter = node.parameter.accept(this); + + this.movePast(node.closeBracketToken); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.IndexSignature(parameter, returnType); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitPropertySignature = function (node) { + var start = this.position; + + var name = this.visitToken(node.propertyName); + + var questionToken = this.createTokenSpan(this.position, node.questionToken); + this.movePast(node.questionToken); + var typeExpr = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.PropertySignature(name, questionToken, typeExpr); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitParameterList = function (node) { + if (!node) { + return null; + } + + var start = this.position; + + var openParenToken = node.openParenToken; + + this.previousTokenTrailingComments = this.convertTokenTrailingComments(openParenToken, start + openParenToken.leadingTriviaWidth() + openParenToken.width()); + var openParenTrailingComments = null; + if (node.parameters.childCount() === 0) { + openParenTrailingComments = this.previousTokenTrailingComments; + this.previousTokenTrailingComments = null; + } + + this.movePast(node.openParenToken); + var parameters = this.visitSeparatedSyntaxList(node.parameters); + this.movePast(node.closeParenToken); + + var result = new TypeScript.ParameterList(openParenTrailingComments, parameters); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCallSignature = function (node) { + var start = this.position; + + var typeParameters = this.visitTypeParameterList(node.typeParameterList); + var parameters = this.visitParameterList(node.parameterList); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var result = new TypeScript.CallSignature(typeParameters, parameters, returnType); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeParameterList = function (node) { + if (!node) { + return null; + } + + var start = this.position; + this.movePast(node.lessThanToken); + var typeParameters = this.visitSeparatedSyntaxList(node.typeParameters); + this.movePast(node.greaterThanToken); + + var result = new TypeScript.TypeParameterList(typeParameters); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeParameter = function (node) { + var start = this.position; + + var identifier = this.visitIdentifier(node.identifier); + var constraint = node.constraint ? node.constraint.accept(this) : null; + + var result = new TypeScript.TypeParameter(identifier, constraint); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstraint = function (node) { + var start = this.position; + this.movePast(node.extendsKeyword); + var type = this.visitType(node.type); + + var result = new TypeScript.Constraint(type); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIfStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var thenBod = node.statement.accept(this); + var elseBod = node.elseClause ? node.elseClause.accept(this) : null; + + var result = new TypeScript.IfStatement(condition, thenBod, elseBod); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitElseClause = function (node) { + var start = this.position; + + this.movePast(node.elseKeyword); + var statement = node.statement.accept(this); + + var result = new TypeScript.ElseClause(statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitExpressionStatement = function (node) { + var start = this.position; + + var preComments = this.convertTokenLeadingComments(node.firstToken(), start); + var expression = node.expression.accept(this); + + var semicolonPosition = this.position; + + var postComments = this.convertComments(node.semicolonToken.trailingTrivia(), this.position + node.semicolonToken.leadingTriviaWidth() + node.semicolonToken.width()); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ExpressionStatement(expression); + this.setSpan(result, start, node); + + result.setPreComments(preComments); + result.setPostComments(postComments); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitConstructorDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.parameterList); + var parameters = this.visitParameterList(node.parameterList); + + var block = node.block ? node.block.accept(this) : null; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.ConstructorDeclaration(parameters, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitIndexMemberDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.indexSignature); + var indexSignature = node.indexSignature.accept(this); + + this.movePast(node.semicolonToken); + + var result = new TypeScript.IndexMemberDeclaration(indexSignature); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? this.visitBlock(node.block) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.MemberFunctionDeclaration(this.visitModifiers(node.modifiers), name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitGetAccessor = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + var parameters = this.visitParameterList(node.parameterList); + var returnType = this.visitTypeAnnotation(node.typeAnnotation); + + var block = node.block ? node.block.accept(this) : null; + var result = new TypeScript.GetAccessor(this.visitModifiers(node.modifiers), name, parameters, returnType, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSetAccessor = function (node) { + var start = this.position; + + this.moveTo(node, node.propertyName); + var name = this.visitToken(node.propertyName); + var parameters = this.visitParameterList(node.parameterList); + var block = node.block ? node.block.accept(this) : null; + var result = new TypeScript.SetAccessor(this.visitModifiers(node.modifiers), name, parameters, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitMemberVariableDeclaration = function (node) { + var start = this.position; + + this.moveTo(node, node.variableDeclarator); + var variableDeclarator = node.variableDeclarator.accept(this); + this.movePast(node.semicolonToken); + + var modifiers = this.visitModifiers(node.modifiers); + var result = new TypeScript.MemberVariableDeclaration(modifiers, variableDeclarator); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitThrowStatement = function (node) { + var start = this.position; + + this.movePast(node.throwKeyword); + var expression = node.expression.accept(this); + this.movePast(node.semicolonToken); + + var result = new TypeScript.ThrowStatement(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitReturnStatement = function (node) { + var start = this.position; + + this.movePast(node.returnKeyword); + var expression = node.expression ? node.expression.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.ReturnStatement(expression); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectCreationExpression = function (node) { + var start = this.position; + + this.movePast(node.newKeyword); + var expression = node.expression.accept(this); + var argumentList = this.visitArgumentList(node.argumentList); + + var result = new TypeScript.ObjectCreationExpression(expression, argumentList); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSwitchStatement = function (node) { + var start = this.position; + + this.movePast(node.switchKeyword); + this.movePast(node.openParenToken); + var expression = node.expression.accept(this); + + var closeParenToken = this.createTokenSpan(this.position, node.closeParenToken); + this.movePast(node.closeParenToken); + this.movePast(node.openBraceToken); + var switchClauses = this.visitSyntaxList(node.switchClauses); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.SwitchStatement(expression, closeParenToken, switchClauses); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCaseSwitchClause = function (node) { + var start = this.position; + + this.movePast(node.caseKeyword); + var expression = node.expression.accept(this); + this.movePast(node.colonToken); + var statements = this.visitSyntaxList(node.statements); + + var result = new TypeScript.CaseSwitchClause(expression, statements); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDefaultSwitchClause = function (node) { + var start = this.position; + + this.movePast(node.defaultKeyword); + this.movePast(node.colonToken); + var statements = this.visitSyntaxList(node.statements); + + var result = new TypeScript.DefaultSwitchClause(statements); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitBreakStatement = function (node) { + var start = this.position; + + this.movePast(node.breakKeyword); + var identifier = node.identifier ? node.identifier.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.BreakStatement(identifier); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitContinueStatement = function (node) { + var start = this.position; + + this.movePast(node.continueKeyword); + var identifier = node.identifier ? node.identifier.accept(this) : null; + this.movePast(node.semicolonToken); + + var result = new TypeScript.ContinueStatement(identifier); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitForStatement = function (node) { + var start = this.position; + + this.movePast(node.forKeyword); + this.movePast(node.openParenToken); + var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null; + var initializer = node.initializer ? node.initializer.accept(this) : null; + + this.movePast(node.firstSemicolonToken); + var cond = node.condition ? node.condition.accept(this) : null; + this.movePast(node.secondSemicolonToken); + var incr = node.incrementor ? node.incrementor.accept(this) : null; + this.movePast(node.closeParenToken); + var body = node.statement.accept(this); + + var result = new TypeScript.ForStatement(variableDeclaration, initializer, cond, incr, body); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitForInStatement = function (node) { + var start = this.position; + + this.movePast(node.forKeyword); + this.movePast(node.openParenToken); + var variableDeclaration = node.variableDeclaration ? node.variableDeclaration.accept(this) : null; + var left = node.left ? node.left.accept(this) : null; + + this.movePast(node.inKeyword); + var expression = node.expression.accept(this); + this.movePast(node.closeParenToken); + var body = node.statement.accept(this); + + var result = new TypeScript.ForInStatement(variableDeclaration, left, expression, body); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitWhileStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.WhileStatement(condition, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitWithStatement = function (node) { + var start = this.position; + + this.moveTo(node, node.condition); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.WithStatement(condition, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCastExpression = function (node) { + var start = this.position; + + this.movePast(node.lessThanToken); + var castTerm = this.visitType(node.type); + this.movePast(node.greaterThanToken); + var expression = node.expression.accept(this); + + var result = new TypeScript.CastExpression(castTerm, expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitObjectLiteralExpression = function (node) { + var start = this.position; + + var openStart = this.position + node.openBraceToken.leadingTriviaWidth(); + this.movePast(node.openBraceToken); + + var propertyAssignments = this.visitSeparatedSyntaxList(node.propertyAssignments); + + var closeStart = this.position + node.closeBraceToken.leadingTriviaWidth(); + this.movePast(node.closeBraceToken); + + var result = new TypeScript.ObjectLiteralExpression(propertyAssignments); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitSimplePropertyAssignment = function (node) { + var start = this.position; + + var preComments = this.convertTokenLeadingComments(node.firstToken(), start); + var postComments = this.convertNodeTrailingComments(node, node.lastToken(), start); + + var propertyName = node.propertyName.accept(this); + + var afterColonComments = this.convertTokenTrailingComments(node.colonToken, this.position + node.colonToken.leadingTriviaWidth() + node.colonToken.width()); + + this.movePast(node.colonToken); + var expression = node.expression.accept(this); + expression.setPreComments(this.mergeComments(afterColonComments, expression.preComments())); + + var result = new TypeScript.SimplePropertyAssignment(propertyName, expression); + this.setSpan(result, start, node); + + result.setPreComments(preComments); + result.setPostComments(postComments); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + var start = this.position; + + var propertyName = node.propertyName.accept(this); + var callSignature = this.visitCallSignature(node.callSignature); + var block = this.visitBlock(node.block); + + var result = new TypeScript.FunctionPropertyAssignment(propertyName, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFunctionExpression = function (node) { + var start = this.position; + + this.movePast(node.functionKeyword); + var name = node.identifier === null ? null : this.visitIdentifier(node.identifier); + + var callSignature = this.visitCallSignature(node.callSignature); + var block = node.block ? node.block.accept(this) : null; + + var result = new TypeScript.FunctionExpression(name, callSignature, block); + this.setCommentsAndSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitEmptyStatement = function (node) { + var start = this.position; + + this.movePast(node.semicolonToken); + + var result = new TypeScript.EmptyStatement(); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTryStatement = function (node) { + var start = this.position; + + this.movePast(node.tryKeyword); + var tryBody = node.block.accept(this); + + var catchClause = null; + if (node.catchClause !== null) { + catchClause = node.catchClause.accept(this); + } + + var finallyBody = null; + if (node.finallyClause !== null) { + finallyBody = node.finallyClause.accept(this); + } + + var result = new TypeScript.TryStatement(tryBody, catchClause, finallyBody); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitCatchClause = function (node) { + var start = this.position; + + this.movePast(node.catchKeyword); + this.movePast(node.openParenToken); + var identifier = this.visitIdentifier(node.identifier); + var typeAnnotation = this.visitTypeAnnotation(node.typeAnnotation); + this.movePast(node.closeParenToken); + var block = node.block.accept(this); + + var result = new TypeScript.CatchClause(identifier, typeAnnotation, block); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitFinallyClause = function (node) { + var start = this.position; + this.movePast(node.finallyKeyword); + var block = node.block.accept(this); + + var result = new TypeScript.FinallyClause(block); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitLabeledStatement = function (node) { + var start = this.position; + + var identifier = this.visitIdentifier(node.identifier); + this.movePast(node.colonToken); + var statement = node.statement.accept(this); + + var result = new TypeScript.LabeledStatement(identifier, statement); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDoStatement = function (node) { + var start = this.position; + + this.movePast(node.doKeyword); + var statement = node.statement.accept(this); + var whileKeyword = this.createTokenSpan(this.position, node.whileKeyword); + + this.movePast(node.whileKeyword); + this.movePast(node.openParenToken); + var condition = node.condition.accept(this); + this.movePast(node.closeParenToken); + this.movePast(node.semicolonToken); + + var result = new TypeScript.DoStatement(statement, whileKeyword, condition); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitTypeOfExpression = function (node) { + var start = this.position; + + this.movePast(node.typeOfKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.TypeOfExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDeleteExpression = function (node) { + var start = this.position; + + this.movePast(node.deleteKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.DeleteExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitVoidExpression = function (node) { + var start = this.position; + + this.movePast(node.voidKeyword); + var expression = node.expression.accept(this); + + var result = new TypeScript.VoidExpression(expression); + this.setSpan(result, start, node); + + return result; + }; + + SyntaxTreeToAstVisitor.prototype.visitDebuggerStatement = function (node) { + var start = this.position; + + this.movePast(node.debuggerKeyword); + this.movePast(node.semicolonToken); + + var result = new TypeScript.DebuggerStatement(); + this.setSpan(result, start, node); + + return result; + }; + return SyntaxTreeToAstVisitor; + })(); + TypeScript.SyntaxTreeToAstVisitor = SyntaxTreeToAstVisitor; + + function applyDelta(ast, delta) { + if (ast) { + if (ast._start !== -1) { + ast._start += delta; + } + + if (ast._end !== -1) { + ast._end += delta; + } + } + } + + function applyDeltaToComments(comments, delta) { + if (comments && comments.length > 0) { + for (var i = 0; i < comments.length; i++) { + var comment = comments[i]; + applyDelta(comment, delta); + } + } + } + + var SyntaxTreeToIncrementalAstVisitor = (function (_super) { + __extends(SyntaxTreeToIncrementalAstVisitor, _super); + function SyntaxTreeToIncrementalAstVisitor() { + _super.apply(this, arguments); + } + SyntaxTreeToIncrementalAstVisitor.prototype.applyDelta = function (ast, delta) { + if (delta === 0) { + return; + } + + var pre = function (cur) { + applyDelta(cur, delta); + applyDeltaToComments(cur.preComments(), delta); + applyDeltaToComments(cur.postComments(), delta); + + switch (cur.kind()) { + case 146 /* Block */: + applyDelta(cur.closeBraceToken, delta); + break; + + case 226 /* ArgumentList */: + applyDelta(cur.closeParenToken, delta); + break; + + case 130 /* ModuleDeclaration */: + applyDelta(cur.endingToken, delta); + break; + + case 131 /* ClassDeclaration */: + applyDelta(cur.closeBraceToken, delta); + break; + + case 161 /* DoStatement */: + applyDelta(cur.whileKeyword, delta); + break; + + case 151 /* SwitchStatement */: + applyDelta(cur.closeParenToken, delta); + break; + } + }; + + TypeScript.getAstWalkerFactory().simpleWalk(ast, pre); + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.setSpanExplicit = function (span, start, end) { + if (span._start !== -1) { + var delta = start - span._start; + this.applyDelta(span, delta); + + span._end = end; + } else { + _super.prototype.setSpanExplicit.call(this, span, start, end); + } + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.getAndMovePastAST = function (element) { + if (this.previousTokenTrailingComments !== null) { + return null; + } + + var result = element._ast; + if (!result) { + return null; + } + + var start = this.position; + this.movePast(element); + this.setSpan(result, start, element); + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.setAST = function (element, ast) { + element._ast = ast; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSyntaxList = function (list) { + var result = this.getAndMovePastAST(list); + if (!result) { + result = _super.prototype.visitSyntaxList.call(this, list); + + if (list.childCount() > 0) { + this.setAST(list, result); + } + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSeparatedSyntaxList = function (list) { + var result = this.getAndMovePastAST(list); + if (!result) { + result = _super.prototype.visitSeparatedSyntaxList.call(this, list); + + if (list.childCount() > 0) { + this.setAST(list, result); + } + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitToken = function (token) { + var result = this.getAndMovePastAST(token); + + if (!result) { + result = _super.prototype.visitToken.call(this, token); + this.setAST(token, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitClassDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitClassDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitInterfaceDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitInterfaceDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitHeritageClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitHeritageClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitModuleDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitModuleDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitImportDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitImportDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitExportAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitExportAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPrefixUnaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPrefixUnaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayLiteralExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitArrayLiteralExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitOmittedExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitOmittedExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParenthesizedExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSimpleArrowFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSimpleArrowFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParenthesizedArrowFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParenthesizedArrowFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitQualifiedName = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + var result = _super.prototype.visitQualifiedName.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructorType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitArrayType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitArrayType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitGenericType = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitGenericType.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBlock = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBlock.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitParameter = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitParameter.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberAccessExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberAccessExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPostfixUnaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPostfixUnaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitElementAccessExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitElementAccessExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitInvocationExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitInvocationExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBinaryExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBinaryExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConditionalExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConditionalExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMethodSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMethodSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitIndexSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitIndexSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitPropertySignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitPropertySignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCallSignature = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCallSignature.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeParameter = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTypeParameter.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitIfStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitIfStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitExpressionStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitExpressionStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitConstructorDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitConstructorDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberFunctionDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberFunctionDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitGetAccessor = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitGetAccessor.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSetAccessor = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSetAccessor.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitMemberVariableDeclaration = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitMemberVariableDeclaration.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitThrowStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitThrowStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitReturnStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitReturnStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectCreationExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectCreationExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSwitchStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSwitchStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCaseSwitchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCaseSwitchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDefaultSwitchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDefaultSwitchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitBreakStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitBreakStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitContinueStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitContinueStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitForStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitForStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitForInStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitForInStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitWhileStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitWhileStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitWithStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitWithStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCastExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCastExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitObjectLiteralExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitObjectLiteralExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitSimplePropertyAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitSimplePropertyAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionPropertyAssignment = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionPropertyAssignment.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitFunctionExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitFunctionExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitEmptyStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitEmptyStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTryStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTryStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitCatchClause = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitCatchClause.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitLabeledStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitLabeledStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDoStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDoStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitTypeOfExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitTypeOfExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDeleteExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDeleteExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitVoidExpression = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitVoidExpression.call(this, node); + this.setAST(node, result); + } + + return result; + }; + + SyntaxTreeToIncrementalAstVisitor.prototype.visitDebuggerStatement = function (node) { + var result = this.getAndMovePastAST(node); + if (!result) { + result = _super.prototype.visitDebuggerStatement.call(this, node); + this.setAST(node, result); + } + + return result; + }; + return SyntaxTreeToIncrementalAstVisitor; + })(SyntaxTreeToAstVisitor); +})(TypeScript || (TypeScript = {})); +var TypeScript; +(function (TypeScript) { + var ASTSpan = (function () { + function ASTSpan(_start, _end) { + this._start = _start; + this._end = _end; + } + ASTSpan.prototype.start = function () { + return this._start; + }; + + ASTSpan.prototype.end = function () { + return this._end; + }; + return ASTSpan; + })(); + TypeScript.ASTSpan = ASTSpan; + + var astID = 0; + + function structuralEqualsNotIncludingPosition(ast1, ast2) { + return structuralEquals(ast1, ast2, false); + } + TypeScript.structuralEqualsNotIncludingPosition = structuralEqualsNotIncludingPosition; + + function structuralEqualsIncludingPosition(ast1, ast2) { + return structuralEquals(ast1, ast2, true); + } + TypeScript.structuralEqualsIncludingPosition = structuralEqualsIncludingPosition; + + function commentStructuralEqualsNotIncludingPosition(ast1, ast2) { + return commentStructuralEquals(ast1, ast2, false); + } + + function commentStructuralEqualsIncludingPosition(ast1, ast2) { + return commentStructuralEquals(ast1, ast2, true); + } + + function structuralEquals(ast1, ast2, includingPosition) { + if (ast1 === ast2) { + return true; + } + + return ast1 !== null && ast2 !== null && ast1.kind() === ast2.kind() && ast1.structuralEquals(ast2, includingPosition); + } + + function commentStructuralEquals(ast1, ast2, includingPosition) { + if (ast1 === ast2) { + return true; + } + + return ast1 !== null && ast2 !== null && ast1.structuralEquals(ast2, includingPosition); + } + + function astArrayStructuralEquals(array1, array2, includingPosition) { + return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? structuralEqualsIncludingPosition : structuralEqualsNotIncludingPosition); + } + + function commentArrayStructuralEquals(array1, array2, includingPosition) { + return TypeScript.ArrayUtilities.sequenceEquals(array1, array2, includingPosition ? commentStructuralEqualsIncludingPosition : commentStructuralEqualsNotIncludingPosition); + } + + var AST = (function () { + function AST() { + this.parent = null; + this._start = -1; + this._end = -1; + this._trailingTriviaWidth = 0; + this._astID = astID++; + this._preComments = null; + this._postComments = null; + } + AST.prototype.syntaxID = function () { + return this._astID; + }; + + AST.prototype.start = function () { + return this._start; + }; + + AST.prototype.end = function () { + return this._end; + }; + + AST.prototype.trailingTriviaWidth = function () { + return this._trailingTriviaWidth; + }; + + AST.prototype.fileName = function () { + return this.parent.fileName(); + }; + + AST.prototype.kind = function () { + throw TypeScript.Errors.abstract(); + }; + + AST.prototype.preComments = function () { + return this._preComments; + }; + + AST.prototype.postComments = function () { + return this._postComments; + }; + + AST.prototype.setPreComments = function (comments) { + if (comments && comments.length) { + this._preComments = comments; + } else if (this._preComments) { + this._preComments = null; + } + }; + + AST.prototype.setPostComments = function (comments) { + if (comments && comments.length) { + this._postComments = comments; + } else if (this._postComments) { + this._postComments = null; + } + }; + + AST.prototype.width = function () { + return this.end() - this.start(); + }; + + AST.prototype.structuralEquals = function (ast, includingPosition) { + if (includingPosition) { + if (this.start() !== ast.start() || this.end() !== ast.end()) { + return false; + } + } + + return commentArrayStructuralEquals(this.preComments(), ast.preComments(), includingPosition) && commentArrayStructuralEquals(this.postComments(), ast.postComments(), includingPosition); + }; + return AST; + })(); + TypeScript.AST = AST; + + var ISyntaxList2 = (function (_super) { + __extends(ISyntaxList2, _super); + function ISyntaxList2(_fileName, members) { + _super.call(this); + this._fileName = _fileName; + this.members = members; + + for (var i = 0, n = members.length; i < n; i++) { + members[i].parent = this; + } + } + ISyntaxList2.prototype.childCount = function () { + return this.members.length; + }; + + ISyntaxList2.prototype.childAt = function (index) { + return this.members[index]; + }; + + ISyntaxList2.prototype.fileName = function () { + return this._fileName; + }; + + ISyntaxList2.prototype.kind = function () { + return 1 /* List */; + }; + + ISyntaxList2.prototype.firstOrDefault = function (func) { + return TypeScript.ArrayUtilities.firstOrDefault(this.members, func); + }; + + ISyntaxList2.prototype.lastOrDefault = function (func) { + return TypeScript.ArrayUtilities.lastOrDefault(this.members, func); + }; + + ISyntaxList2.prototype.any = function (func) { + return TypeScript.ArrayUtilities.any(this.members, func); + }; + + ISyntaxList2.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition); + }; + return ISyntaxList2; + })(AST); + TypeScript.ISyntaxList2 = ISyntaxList2; + + var ISeparatedSyntaxList2 = (function (_super) { + __extends(ISeparatedSyntaxList2, _super); + function ISeparatedSyntaxList2(_fileName, members, _separatorCount) { + _super.call(this); + this._fileName = _fileName; + this.members = members; + this._separatorCount = _separatorCount; + + for (var i = 0, n = members.length; i < n; i++) { + members[i].parent = this; + } + } + ISeparatedSyntaxList2.prototype.nonSeparatorCount = function () { + return this.members.length; + }; + + ISeparatedSyntaxList2.prototype.separatorCount = function () { + return this._separatorCount; + }; + + ISeparatedSyntaxList2.prototype.nonSeparatorAt = function (index) { + return this.members[index]; + }; + + ISeparatedSyntaxList2.prototype.nonSeparatorIndexOf = function (ast) { + for (var i = 0, n = this.nonSeparatorCount(); i < n; i++) { + if (this.nonSeparatorAt(i) === ast) { + return i; + } + } + + return -1; + }; + + ISeparatedSyntaxList2.prototype.fileName = function () { + return this._fileName; + }; + + ISeparatedSyntaxList2.prototype.kind = function () { + return 2 /* SeparatedList */; + }; + + ISeparatedSyntaxList2.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && astArrayStructuralEquals(this.members, ast.members, includingPosition); + }; + return ISeparatedSyntaxList2; + })(AST); + TypeScript.ISeparatedSyntaxList2 = ISeparatedSyntaxList2; + + var SourceUnit = (function (_super) { + __extends(SourceUnit, _super); + function SourceUnit(moduleElements, _fileName) { + _super.call(this); + this.moduleElements = moduleElements; + this._fileName = _fileName; + moduleElements && (moduleElements.parent = this); + } + SourceUnit.prototype.fileName = function () { + return this._fileName; + }; + + SourceUnit.prototype.kind = function () { + return 120 /* SourceUnit */; + }; + + SourceUnit.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition); + }; + return SourceUnit; + })(AST); + TypeScript.SourceUnit = SourceUnit; + + var Identifier = (function (_super) { + __extends(Identifier, _super); + function Identifier(_text) { + _super.call(this); + this._text = _text; + this._valueText = null; + } + Identifier.prototype.text = function () { + return this._text; + }; + Identifier.prototype.valueText = function () { + if (!this._valueText) { + var text = this._text; + if (text === "__proto__") { + this._valueText = "#__proto__"; + } else { + this._valueText = TypeScript.Syntax.massageEscapes(text); + } + } + + return this._valueText; + }; + + Identifier.prototype.kind = function () { + return 11 /* IdentifierName */; + }; + + Identifier.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text; + }; + return Identifier; + })(AST); + TypeScript.Identifier = Identifier; + + var LiteralExpression = (function (_super) { + __extends(LiteralExpression, _super); + function LiteralExpression(_nodeType, _text, _valueText) { + _super.call(this); + this._nodeType = _nodeType; + this._text = _text; + this._valueText = _valueText; + } + LiteralExpression.prototype.text = function () { + return this._text; + }; + + LiteralExpression.prototype.valueText = function () { + return this._valueText; + }; + + LiteralExpression.prototype.kind = function () { + return this._nodeType; + }; + + LiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return LiteralExpression; + })(AST); + TypeScript.LiteralExpression = LiteralExpression; + + var ThisExpression = (function (_super) { + __extends(ThisExpression, _super); + function ThisExpression(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + ThisExpression.prototype.text = function () { + return this._text; + }; + + ThisExpression.prototype.valueText = function () { + return this._valueText; + }; + + ThisExpression.prototype.kind = function () { + return 35 /* ThisKeyword */; + }; + + ThisExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return ThisExpression; + })(AST); + TypeScript.ThisExpression = ThisExpression; + + var SuperExpression = (function (_super) { + __extends(SuperExpression, _super); + function SuperExpression(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + SuperExpression.prototype.text = function () { + return this._text; + }; + + SuperExpression.prototype.valueText = function () { + return this._valueText; + }; + + SuperExpression.prototype.kind = function () { + return 50 /* SuperKeyword */; + }; + + SuperExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return SuperExpression; + })(AST); + TypeScript.SuperExpression = SuperExpression; + + var NumericLiteral = (function (_super) { + __extends(NumericLiteral, _super); + function NumericLiteral(_value, _text, _valueText) { + _super.call(this); + this._value = _value; + this._text = _text; + this._valueText = _valueText; + } + NumericLiteral.prototype.text = function () { + return this._text; + }; + NumericLiteral.prototype.valueText = function () { + return this._valueText; + }; + NumericLiteral.prototype.value = function () { + return this._value; + }; + + NumericLiteral.prototype.kind = function () { + return 13 /* NumericLiteral */; + }; + + NumericLiteral.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && (this._value === ast._value || (isNaN(this._value) && isNaN(ast._value))) && this._text === ast._text; + }; + return NumericLiteral; + })(AST); + TypeScript.NumericLiteral = NumericLiteral; + + var RegularExpressionLiteral = (function (_super) { + __extends(RegularExpressionLiteral, _super); + function RegularExpressionLiteral(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + } + RegularExpressionLiteral.prototype.text = function () { + return this._text; + }; + + RegularExpressionLiteral.prototype.valueText = function () { + return this._valueText; + }; + + RegularExpressionLiteral.prototype.kind = function () { + return 12 /* RegularExpressionLiteral */; + }; + return RegularExpressionLiteral; + })(AST); + TypeScript.RegularExpressionLiteral = RegularExpressionLiteral; + + var StringLiteral = (function (_super) { + __extends(StringLiteral, _super); + function StringLiteral(_text, _valueText) { + _super.call(this); + this._text = _text; + this._valueText = _valueText; + this._valueText = _valueText === "__proto__" ? "#__proto__" : _valueText; + } + StringLiteral.prototype.text = function () { + return this._text; + }; + StringLiteral.prototype.valueText = function () { + return this._valueText; + }; + + StringLiteral.prototype.kind = function () { + return 14 /* StringLiteral */; + }; + + StringLiteral.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && this._text === ast._text; + }; + return StringLiteral; + })(AST); + TypeScript.StringLiteral = StringLiteral; + + var TypeAnnotation = (function (_super) { + __extends(TypeAnnotation, _super); + function TypeAnnotation(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + TypeAnnotation.prototype.kind = function () { + return 244 /* TypeAnnotation */; + }; + return TypeAnnotation; + })(AST); + TypeScript.TypeAnnotation = TypeAnnotation; + + var BuiltInType = (function (_super) { + __extends(BuiltInType, _super); + function BuiltInType(_nodeType, _text, _valueText) { + _super.call(this); + this._nodeType = _nodeType; + this._text = _text; + this._valueText = _valueText; + } + BuiltInType.prototype.text = function () { + return this._text; + }; + + BuiltInType.prototype.valueText = function () { + return this._valueText; + }; + + BuiltInType.prototype.kind = function () { + return this._nodeType; + }; + return BuiltInType; + })(AST); + TypeScript.BuiltInType = BuiltInType; + + var ExternalModuleReference = (function (_super) { + __extends(ExternalModuleReference, _super); + function ExternalModuleReference(stringLiteral) { + _super.call(this); + this.stringLiteral = stringLiteral; + stringLiteral && (stringLiteral.parent = this); + } + ExternalModuleReference.prototype.kind = function () { + return 245 /* ExternalModuleReference */; + }; + return ExternalModuleReference; + })(AST); + TypeScript.ExternalModuleReference = ExternalModuleReference; + + var ModuleNameModuleReference = (function (_super) { + __extends(ModuleNameModuleReference, _super); + function ModuleNameModuleReference(moduleName) { + _super.call(this); + this.moduleName = moduleName; + moduleName && (moduleName.parent = this); + } + ModuleNameModuleReference.prototype.kind = function () { + return 246 /* ModuleNameModuleReference */; + }; + return ModuleNameModuleReference; + })(AST); + TypeScript.ModuleNameModuleReference = ModuleNameModuleReference; + + var ImportDeclaration = (function (_super) { + __extends(ImportDeclaration, _super); + function ImportDeclaration(modifiers, identifier, moduleReference) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.moduleReference = moduleReference; + identifier && (identifier.parent = this); + moduleReference && (moduleReference.parent = this); + } + ImportDeclaration.prototype.kind = function () { + return 133 /* ImportDeclaration */; + }; + + ImportDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.moduleReference, ast.moduleReference, includingPosition); + }; + return ImportDeclaration; + })(AST); + TypeScript.ImportDeclaration = ImportDeclaration; + + var ExportAssignment = (function (_super) { + __extends(ExportAssignment, _super); + function ExportAssignment(identifier) { + _super.call(this); + this.identifier = identifier; + identifier && (identifier.parent = this); + } + ExportAssignment.prototype.kind = function () { + return 134 /* ExportAssignment */; + }; + + ExportAssignment.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition); + }; + return ExportAssignment; + })(AST); + TypeScript.ExportAssignment = ExportAssignment; + + var TypeParameterList = (function (_super) { + __extends(TypeParameterList, _super); + function TypeParameterList(typeParameters) { + _super.call(this); + this.typeParameters = typeParameters; + typeParameters && (typeParameters.parent = this); + } + TypeParameterList.prototype.kind = function () { + return 229 /* TypeParameterList */; + }; + return TypeParameterList; + })(AST); + TypeScript.TypeParameterList = TypeParameterList; + + var ClassDeclaration = (function (_super) { + __extends(ClassDeclaration, _super); + function ClassDeclaration(modifiers, identifier, typeParameterList, heritageClauses, classElements, closeBraceToken) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.classElements = classElements; + this.closeBraceToken = closeBraceToken; + identifier && (identifier.parent = this); + typeParameterList && (typeParameterList.parent = this); + heritageClauses && (heritageClauses.parent = this); + classElements && (classElements.parent = this); + } + ClassDeclaration.prototype.kind = function () { + return 131 /* ClassDeclaration */; + }; + + ClassDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.classElements, ast.classElements, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition); + }; + return ClassDeclaration; + })(AST); + TypeScript.ClassDeclaration = ClassDeclaration; + + var InterfaceDeclaration = (function (_super) { + __extends(InterfaceDeclaration, _super); + function InterfaceDeclaration(modifiers, identifier, typeParameterList, heritageClauses, body) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.typeParameterList = typeParameterList; + this.heritageClauses = heritageClauses; + this.body = body; + identifier && (identifier.parent = this); + typeParameterList && (typeParameterList.parent = this); + body && (body.parent = this); + heritageClauses && (heritageClauses.parent = this); + } + InterfaceDeclaration.prototype.kind = function () { + return 128 /* InterfaceDeclaration */; + }; + + InterfaceDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.body, ast.body, includingPosition) && structuralEquals(this.typeParameterList, ast.typeParameterList, includingPosition) && structuralEquals(this.heritageClauses, ast.heritageClauses, includingPosition); + }; + return InterfaceDeclaration; + })(AST); + TypeScript.InterfaceDeclaration = InterfaceDeclaration; + + var HeritageClause = (function (_super) { + __extends(HeritageClause, _super); + function HeritageClause(_nodeType, typeNames) { + _super.call(this); + this._nodeType = _nodeType; + this.typeNames = typeNames; + typeNames && (typeNames.parent = this); + } + HeritageClause.prototype.kind = function () { + return this._nodeType; + }; + + HeritageClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeNames, ast.typeNames, includingPosition); + }; + return HeritageClause; + })(AST); + TypeScript.HeritageClause = HeritageClause; + + var ModuleDeclaration = (function (_super) { + __extends(ModuleDeclaration, _super); + function ModuleDeclaration(modifiers, name, stringLiteral, moduleElements, endingToken) { + _super.call(this); + this.modifiers = modifiers; + this.name = name; + this.stringLiteral = stringLiteral; + this.moduleElements = moduleElements; + this.endingToken = endingToken; + name && (name.parent = this); + stringLiteral && (stringLiteral.parent = this); + moduleElements && (moduleElements.parent = this); + } + ModuleDeclaration.prototype.kind = function () { + return 130 /* ModuleDeclaration */; + }; + + ModuleDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.moduleElements, ast.moduleElements, includingPosition); + }; + return ModuleDeclaration; + })(AST); + TypeScript.ModuleDeclaration = ModuleDeclaration; + + var FunctionDeclaration = (function (_super) { + __extends(FunctionDeclaration, _super); + function FunctionDeclaration(modifiers, identifier, callSignature, block) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + identifier && (identifier.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionDeclaration.prototype.kind = function () { + return 129 /* FunctionDeclaration */; + }; + + FunctionDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.callSignature, ast.callSignature, includingPosition); + }; + return FunctionDeclaration; + })(AST); + TypeScript.FunctionDeclaration = FunctionDeclaration; + + var VariableStatement = (function (_super) { + __extends(VariableStatement, _super); + function VariableStatement(modifiers, declaration) { + _super.call(this); + this.modifiers = modifiers; + this.declaration = declaration; + declaration && (declaration.parent = this); + } + VariableStatement.prototype.kind = function () { + return 148 /* VariableStatement */; + }; + + VariableStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declaration, ast.declaration, includingPosition); + }; + return VariableStatement; + })(AST); + TypeScript.VariableStatement = VariableStatement; + + var VariableDeclaration = (function (_super) { + __extends(VariableDeclaration, _super); + function VariableDeclaration(declarators) { + _super.call(this); + this.declarators = declarators; + declarators && (declarators.parent = this); + } + VariableDeclaration.prototype.kind = function () { + return 224 /* VariableDeclaration */; + }; + + VariableDeclaration.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.declarators, ast.declarators, includingPosition); + }; + return VariableDeclaration; + })(AST); + TypeScript.VariableDeclaration = VariableDeclaration; + + var VariableDeclarator = (function (_super) { + __extends(VariableDeclarator, _super); + function VariableDeclarator(propertyName, typeAnnotation, equalsValueClause) { + _super.call(this); + this.propertyName = propertyName; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + propertyName && (propertyName.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + VariableDeclarator.prototype.kind = function () { + return 225 /* VariableDeclarator */; + }; + return VariableDeclarator; + })(AST); + TypeScript.VariableDeclarator = VariableDeclarator; + + var EqualsValueClause = (function (_super) { + __extends(EqualsValueClause, _super); + function EqualsValueClause(value) { + _super.call(this); + this.value = value; + value && (value.parent = this); + } + EqualsValueClause.prototype.kind = function () { + return 232 /* EqualsValueClause */; + }; + return EqualsValueClause; + })(AST); + TypeScript.EqualsValueClause = EqualsValueClause; + + var PrefixUnaryExpression = (function (_super) { + __extends(PrefixUnaryExpression, _super); + function PrefixUnaryExpression(_nodeType, operand) { + _super.call(this); + this._nodeType = _nodeType; + this.operand = operand; + operand && (operand.parent = this); + } + PrefixUnaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + PrefixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition); + }; + return PrefixUnaryExpression; + })(AST); + TypeScript.PrefixUnaryExpression = PrefixUnaryExpression; + + var ArrayLiteralExpression = (function (_super) { + __extends(ArrayLiteralExpression, _super); + function ArrayLiteralExpression(expressions) { + _super.call(this); + this.expressions = expressions; + expressions && (expressions.parent = this); + } + ArrayLiteralExpression.prototype.kind = function () { + return 214 /* ArrayLiteralExpression */; + }; + + ArrayLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expressions, ast.expressions, includingPosition); + }; + return ArrayLiteralExpression; + })(AST); + TypeScript.ArrayLiteralExpression = ArrayLiteralExpression; + + var OmittedExpression = (function (_super) { + __extends(OmittedExpression, _super); + function OmittedExpression() { + _super.apply(this, arguments); + } + OmittedExpression.prototype.kind = function () { + return 223 /* OmittedExpression */; + }; + + OmittedExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return OmittedExpression; + })(AST); + TypeScript.OmittedExpression = OmittedExpression; + + var ParenthesizedExpression = (function (_super) { + __extends(ParenthesizedExpression, _super); + function ParenthesizedExpression(openParenTrailingComments, expression) { + _super.call(this); + this.openParenTrailingComments = openParenTrailingComments; + this.expression = expression; + expression && (expression.parent = this); + } + ParenthesizedExpression.prototype.kind = function () { + return 217 /* ParenthesizedExpression */; + }; + + ParenthesizedExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ParenthesizedExpression; + })(AST); + TypeScript.ParenthesizedExpression = ParenthesizedExpression; + + var SimpleArrowFunctionExpression = (function (_super) { + __extends(SimpleArrowFunctionExpression, _super); + function SimpleArrowFunctionExpression(identifier, block, expression) { + _super.call(this); + this.identifier = identifier; + this.block = block; + this.expression = expression; + identifier && (identifier.parent = this); + block && (block.parent = this); + expression && (expression.parent = this); + } + SimpleArrowFunctionExpression.prototype.kind = function () { + return 219 /* SimpleArrowFunctionExpression */; + }; + return SimpleArrowFunctionExpression; + })(AST); + TypeScript.SimpleArrowFunctionExpression = SimpleArrowFunctionExpression; + + var ParenthesizedArrowFunctionExpression = (function (_super) { + __extends(ParenthesizedArrowFunctionExpression, _super); + function ParenthesizedArrowFunctionExpression(callSignature, block, expression) { + _super.call(this); + this.callSignature = callSignature; + this.block = block; + this.expression = expression; + callSignature && (callSignature.parent = this); + block && (block.parent = this); + expression && (expression.parent = this); + } + ParenthesizedArrowFunctionExpression.prototype.kind = function () { + return 218 /* ParenthesizedArrowFunctionExpression */; + }; + return ParenthesizedArrowFunctionExpression; + })(AST); + TypeScript.ParenthesizedArrowFunctionExpression = ParenthesizedArrowFunctionExpression; + + var QualifiedName = (function (_super) { + __extends(QualifiedName, _super); + function QualifiedName(left, right) { + _super.call(this); + this.left = left; + this.right = right; + left && (left.parent = this); + right && (right.parent = this); + } + QualifiedName.prototype.kind = function () { + return 121 /* QualifiedName */; + }; + + QualifiedName.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition); + }; + return QualifiedName; + })(AST); + TypeScript.QualifiedName = QualifiedName; + + var ParameterList = (function (_super) { + __extends(ParameterList, _super); + function ParameterList(openParenTrailingComments, parameters) { + _super.call(this); + this.openParenTrailingComments = openParenTrailingComments; + this.parameters = parameters; + parameters && (parameters.parent = this); + } + ParameterList.prototype.kind = function () { + return 227 /* ParameterList */; + }; + return ParameterList; + })(AST); + TypeScript.ParameterList = ParameterList; + + var ConstructorType = (function (_super) { + __extends(ConstructorType, _super); + function ConstructorType(typeParameterList, parameterList, type) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.type = type; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + type && (type.parent = this); + } + ConstructorType.prototype.kind = function () { + return 125 /* ConstructorType */; + }; + return ConstructorType; + })(AST); + TypeScript.ConstructorType = ConstructorType; + + var FunctionType = (function (_super) { + __extends(FunctionType, _super); + function FunctionType(typeParameterList, parameterList, type) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.type = type; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + type && (type.parent = this); + } + FunctionType.prototype.kind = function () { + return 123 /* FunctionType */; + }; + return FunctionType; + })(AST); + TypeScript.FunctionType = FunctionType; + + var ObjectType = (function (_super) { + __extends(ObjectType, _super); + function ObjectType(typeMembers) { + _super.call(this); + this.typeMembers = typeMembers; + typeMembers && (typeMembers.parent = this); + } + ObjectType.prototype.kind = function () { + return 122 /* ObjectType */; + }; + + ObjectType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.typeMembers, ast.typeMembers, includingPosition); + }; + return ObjectType; + })(AST); + TypeScript.ObjectType = ObjectType; + + var ArrayType = (function (_super) { + __extends(ArrayType, _super); + function ArrayType(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + ArrayType.prototype.kind = function () { + return 124 /* ArrayType */; + }; + + ArrayType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition); + }; + return ArrayType; + })(AST); + TypeScript.ArrayType = ArrayType; + + var TypeArgumentList = (function (_super) { + __extends(TypeArgumentList, _super); + function TypeArgumentList(typeArguments) { + _super.call(this); + this.typeArguments = typeArguments; + typeArguments && (typeArguments.parent = this); + } + TypeArgumentList.prototype.kind = function () { + return 228 /* TypeArgumentList */; + }; + return TypeArgumentList; + })(AST); + TypeScript.TypeArgumentList = TypeArgumentList; + + var GenericType = (function (_super) { + __extends(GenericType, _super); + function GenericType(name, typeArgumentList) { + _super.call(this); + this.name = name; + this.typeArgumentList = typeArgumentList; + name && (name.parent = this); + typeArgumentList && (typeArgumentList.parent = this); + } + GenericType.prototype.kind = function () { + return 126 /* GenericType */; + }; + + GenericType.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition) && structuralEquals(this.typeArgumentList, ast.typeArgumentList, includingPosition); + }; + return GenericType; + })(AST); + TypeScript.GenericType = GenericType; + + var TypeQuery = (function (_super) { + __extends(TypeQuery, _super); + function TypeQuery(name) { + _super.call(this); + this.name = name; + name && (name.parent = this); + } + TypeQuery.prototype.kind = function () { + return 127 /* TypeQuery */; + }; + + TypeQuery.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.name, ast.name, includingPosition); + }; + return TypeQuery; + })(AST); + TypeScript.TypeQuery = TypeQuery; + + var Block = (function (_super) { + __extends(Block, _super); + function Block(statements, closeBraceLeadingComments, closeBraceToken) { + _super.call(this); + this.statements = statements; + this.closeBraceLeadingComments = closeBraceLeadingComments; + this.closeBraceToken = closeBraceToken; + statements && (statements.parent = this); + } + Block.prototype.kind = function () { + return 146 /* Block */; + }; + + Block.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return Block; + })(AST); + TypeScript.Block = Block; + + var Parameter = (function (_super) { + __extends(Parameter, _super); + function Parameter(dotDotDotToken, modifiers, identifier, questionToken, typeAnnotation, equalsValueClause) { + _super.call(this); + this.dotDotDotToken = dotDotDotToken; + this.modifiers = modifiers; + this.identifier = identifier; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + this.equalsValueClause = equalsValueClause; + identifier && (identifier.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + Parameter.prototype.kind = function () { + return 242 /* Parameter */; + }; + return Parameter; + })(AST); + TypeScript.Parameter = Parameter; + + var MemberAccessExpression = (function (_super) { + __extends(MemberAccessExpression, _super); + function MemberAccessExpression(expression, name) { + _super.call(this); + this.expression = expression; + this.name = name; + expression && (expression.parent = this); + name && (name.parent = this); + } + MemberAccessExpression.prototype.kind = function () { + return 212 /* MemberAccessExpression */; + }; + + MemberAccessExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.name, ast.name, includingPosition); + }; + return MemberAccessExpression; + })(AST); + TypeScript.MemberAccessExpression = MemberAccessExpression; + + var PostfixUnaryExpression = (function (_super) { + __extends(PostfixUnaryExpression, _super); + function PostfixUnaryExpression(_nodeType, operand) { + _super.call(this); + this._nodeType = _nodeType; + this.operand = operand; + operand && (operand.parent = this); + } + PostfixUnaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + PostfixUnaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.operand, ast.operand, includingPosition); + }; + return PostfixUnaryExpression; + })(AST); + TypeScript.PostfixUnaryExpression = PostfixUnaryExpression; + + var ElementAccessExpression = (function (_super) { + __extends(ElementAccessExpression, _super); + function ElementAccessExpression(expression, argumentExpression) { + _super.call(this); + this.expression = expression; + this.argumentExpression = argumentExpression; + expression && (expression.parent = this); + argumentExpression && (argumentExpression.parent = this); + } + ElementAccessExpression.prototype.kind = function () { + return 221 /* ElementAccessExpression */; + }; + + ElementAccessExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentExpression, ast.argumentExpression, includingPosition); + }; + return ElementAccessExpression; + })(AST); + TypeScript.ElementAccessExpression = ElementAccessExpression; + + var InvocationExpression = (function (_super) { + __extends(InvocationExpression, _super); + function InvocationExpression(expression, argumentList) { + _super.call(this); + this.expression = expression; + this.argumentList = argumentList; + expression && (expression.parent = this); + argumentList && (argumentList.parent = this); + } + InvocationExpression.prototype.kind = function () { + return 213 /* InvocationExpression */; + }; + + InvocationExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition); + }; + return InvocationExpression; + })(AST); + TypeScript.InvocationExpression = InvocationExpression; + + var ArgumentList = (function (_super) { + __extends(ArgumentList, _super); + function ArgumentList(typeArgumentList, arguments, closeParenToken) { + _super.call(this); + this.typeArgumentList = typeArgumentList; + this.arguments = arguments; + this.closeParenToken = closeParenToken; + typeArgumentList && (typeArgumentList.parent = this); + arguments && (arguments.parent = this); + } + ArgumentList.prototype.kind = function () { + return 226 /* ArgumentList */; + }; + return ArgumentList; + })(AST); + TypeScript.ArgumentList = ArgumentList; + + var BinaryExpression = (function (_super) { + __extends(BinaryExpression, _super); + function BinaryExpression(_nodeType, left, right) { + _super.call(this); + this._nodeType = _nodeType; + this.left = left; + this.right = right; + left && (left.parent = this); + right && (right.parent = this); + } + BinaryExpression.prototype.kind = function () { + return this._nodeType; + }; + + BinaryExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.left, ast.left, includingPosition) && structuralEquals(this.right, ast.right, includingPosition); + }; + return BinaryExpression; + })(AST); + TypeScript.BinaryExpression = BinaryExpression; + + var ConditionalExpression = (function (_super) { + __extends(ConditionalExpression, _super); + function ConditionalExpression(condition, whenTrue, whenFalse) { + _super.call(this); + this.condition = condition; + this.whenTrue = whenTrue; + this.whenFalse = whenFalse; + condition && (condition.parent = this); + whenTrue && (whenTrue.parent = this); + whenFalse && (whenFalse.parent = this); + } + ConditionalExpression.prototype.kind = function () { + return 186 /* ConditionalExpression */; + }; + + ConditionalExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.whenTrue, ast.whenTrue, includingPosition) && structuralEquals(this.whenFalse, ast.whenFalse, includingPosition); + }; + return ConditionalExpression; + })(AST); + TypeScript.ConditionalExpression = ConditionalExpression; + + var ConstructSignature = (function (_super) { + __extends(ConstructSignature, _super); + function ConstructSignature(callSignature) { + _super.call(this); + this.callSignature = callSignature; + callSignature && (callSignature.parent = this); + } + ConstructSignature.prototype.kind = function () { + return 143 /* ConstructSignature */; + }; + return ConstructSignature; + })(AST); + TypeScript.ConstructSignature = ConstructSignature; + + var MethodSignature = (function (_super) { + __extends(MethodSignature, _super); + function MethodSignature(propertyName, questionToken, callSignature) { + _super.call(this); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.callSignature = callSignature; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + } + MethodSignature.prototype.kind = function () { + return 145 /* MethodSignature */; + }; + return MethodSignature; + })(AST); + TypeScript.MethodSignature = MethodSignature; + + var IndexSignature = (function (_super) { + __extends(IndexSignature, _super); + function IndexSignature(parameter, typeAnnotation) { + _super.call(this); + this.parameter = parameter; + this.typeAnnotation = typeAnnotation; + parameter && (parameter.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + IndexSignature.prototype.kind = function () { + return 144 /* IndexSignature */; + }; + return IndexSignature; + })(AST); + TypeScript.IndexSignature = IndexSignature; + + var PropertySignature = (function (_super) { + __extends(PropertySignature, _super); + function PropertySignature(propertyName, questionToken, typeAnnotation) { + _super.call(this); + this.propertyName = propertyName; + this.questionToken = questionToken; + this.typeAnnotation = typeAnnotation; + propertyName && (propertyName.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + PropertySignature.prototype.kind = function () { + return 141 /* PropertySignature */; + }; + return PropertySignature; + })(AST); + TypeScript.PropertySignature = PropertySignature; + + var CallSignature = (function (_super) { + __extends(CallSignature, _super); + function CallSignature(typeParameterList, parameterList, typeAnnotation) { + _super.call(this); + this.typeParameterList = typeParameterList; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + typeParameterList && (typeParameterList.parent = this); + parameterList && (parameterList.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + } + CallSignature.prototype.kind = function () { + return 142 /* CallSignature */; + }; + return CallSignature; + })(AST); + TypeScript.CallSignature = CallSignature; + + var TypeParameter = (function (_super) { + __extends(TypeParameter, _super); + function TypeParameter(identifier, constraint) { + _super.call(this); + this.identifier = identifier; + this.constraint = constraint; + identifier && (identifier.parent = this); + constraint && (constraint.parent = this); + } + TypeParameter.prototype.kind = function () { + return 238 /* TypeParameter */; + }; + + TypeParameter.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.constraint, ast.constraint, includingPosition); + }; + return TypeParameter; + })(AST); + TypeScript.TypeParameter = TypeParameter; + + var Constraint = (function (_super) { + __extends(Constraint, _super); + function Constraint(type) { + _super.call(this); + this.type = type; + type && (type.parent = this); + } + Constraint.prototype.kind = function () { + return 239 /* Constraint */; + }; + return Constraint; + })(AST); + TypeScript.Constraint = Constraint; + + var ElseClause = (function (_super) { + __extends(ElseClause, _super); + function ElseClause(statement) { + _super.call(this); + this.statement = statement; + statement && (statement.parent = this); + } + ElseClause.prototype.kind = function () { + return 235 /* ElseClause */; + }; + + ElseClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ElseClause; + })(AST); + TypeScript.ElseClause = ElseClause; + + var IfStatement = (function (_super) { + __extends(IfStatement, _super); + function IfStatement(condition, statement, elseClause) { + _super.call(this); + this.condition = condition; + this.statement = statement; + this.elseClause = elseClause; + condition && (condition.parent = this); + statement && (statement.parent = this); + elseClause && (elseClause.parent = this); + } + IfStatement.prototype.kind = function () { + return 147 /* IfStatement */; + }; + + IfStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.elseClause, ast.elseClause, includingPosition); + }; + return IfStatement; + })(AST); + TypeScript.IfStatement = IfStatement; + + var ExpressionStatement = (function (_super) { + __extends(ExpressionStatement, _super); + function ExpressionStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ExpressionStatement.prototype.kind = function () { + return 149 /* ExpressionStatement */; + }; + + ExpressionStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ExpressionStatement; + })(AST); + TypeScript.ExpressionStatement = ExpressionStatement; + + var ConstructorDeclaration = (function (_super) { + __extends(ConstructorDeclaration, _super); + function ConstructorDeclaration(parameterList, block) { + _super.call(this); + this.parameterList = parameterList; + this.block = block; + parameterList && (parameterList.parent = this); + block && (block.parent = this); + } + ConstructorDeclaration.prototype.kind = function () { + return 137 /* ConstructorDeclaration */; + }; + return ConstructorDeclaration; + })(AST); + TypeScript.ConstructorDeclaration = ConstructorDeclaration; + + var MemberFunctionDeclaration = (function (_super) { + __extends(MemberFunctionDeclaration, _super); + function MemberFunctionDeclaration(modifiers, propertyName, callSignature, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + MemberFunctionDeclaration.prototype.kind = function () { + return 135 /* MemberFunctionDeclaration */; + }; + return MemberFunctionDeclaration; + })(AST); + TypeScript.MemberFunctionDeclaration = MemberFunctionDeclaration; + + var GetAccessor = (function (_super) { + __extends(GetAccessor, _super); + function GetAccessor(modifiers, propertyName, parameterList, typeAnnotation, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.typeAnnotation = typeAnnotation; + this.block = block; + propertyName && (propertyName.parent = this); + parameterList && (parameterList.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + block && (block.parent = this); + } + GetAccessor.prototype.kind = function () { + return 139 /* GetAccessor */; + }; + return GetAccessor; + })(AST); + TypeScript.GetAccessor = GetAccessor; + + var SetAccessor = (function (_super) { + __extends(SetAccessor, _super); + function SetAccessor(modifiers, propertyName, parameterList, block) { + _super.call(this); + this.modifiers = modifiers; + this.propertyName = propertyName; + this.parameterList = parameterList; + this.block = block; + propertyName && (propertyName.parent = this); + parameterList && (parameterList.parent = this); + block && (block.parent = this); + } + SetAccessor.prototype.kind = function () { + return 140 /* SetAccessor */; + }; + return SetAccessor; + })(AST); + TypeScript.SetAccessor = SetAccessor; + + var MemberVariableDeclaration = (function (_super) { + __extends(MemberVariableDeclaration, _super); + function MemberVariableDeclaration(modifiers, variableDeclarator) { + _super.call(this); + this.modifiers = modifiers; + this.variableDeclarator = variableDeclarator; + variableDeclarator && (variableDeclarator.parent = this); + } + MemberVariableDeclaration.prototype.kind = function () { + return 136 /* MemberVariableDeclaration */; + }; + return MemberVariableDeclaration; + })(AST); + TypeScript.MemberVariableDeclaration = MemberVariableDeclaration; + + var IndexMemberDeclaration = (function (_super) { + __extends(IndexMemberDeclaration, _super); + function IndexMemberDeclaration(indexSignature) { + _super.call(this); + this.indexSignature = indexSignature; + indexSignature && (indexSignature.parent = this); + } + IndexMemberDeclaration.prototype.kind = function () { + return 138 /* IndexMemberDeclaration */; + }; + return IndexMemberDeclaration; + })(AST); + TypeScript.IndexMemberDeclaration = IndexMemberDeclaration; + + var ThrowStatement = (function (_super) { + __extends(ThrowStatement, _super); + function ThrowStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ThrowStatement.prototype.kind = function () { + return 157 /* ThrowStatement */; + }; + + ThrowStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ThrowStatement; + })(AST); + TypeScript.ThrowStatement = ThrowStatement; + + var ReturnStatement = (function (_super) { + __extends(ReturnStatement, _super); + function ReturnStatement(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + ReturnStatement.prototype.kind = function () { + return 150 /* ReturnStatement */; + }; + + ReturnStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return ReturnStatement; + })(AST); + TypeScript.ReturnStatement = ReturnStatement; + + var ObjectCreationExpression = (function (_super) { + __extends(ObjectCreationExpression, _super); + function ObjectCreationExpression(expression, argumentList) { + _super.call(this); + this.expression = expression; + this.argumentList = argumentList; + expression && (expression.parent = this); + argumentList && (argumentList.parent = this); + } + ObjectCreationExpression.prototype.kind = function () { + return 216 /* ObjectCreationExpression */; + }; + + ObjectCreationExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.argumentList, ast.argumentList, includingPosition); + }; + return ObjectCreationExpression; + })(AST); + TypeScript.ObjectCreationExpression = ObjectCreationExpression; + + var SwitchStatement = (function (_super) { + __extends(SwitchStatement, _super); + function SwitchStatement(expression, closeParenToken, switchClauses) { + _super.call(this); + this.expression = expression; + this.closeParenToken = closeParenToken; + this.switchClauses = switchClauses; + expression && (expression.parent = this); + switchClauses && (switchClauses.parent = this); + } + SwitchStatement.prototype.kind = function () { + return 151 /* SwitchStatement */; + }; + + SwitchStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.switchClauses, ast.switchClauses, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return SwitchStatement; + })(AST); + TypeScript.SwitchStatement = SwitchStatement; + + var CaseSwitchClause = (function (_super) { + __extends(CaseSwitchClause, _super); + function CaseSwitchClause(expression, statements) { + _super.call(this); + this.expression = expression; + this.statements = statements; + expression && (expression.parent = this); + statements && (statements.parent = this); + } + CaseSwitchClause.prototype.kind = function () { + return 233 /* CaseSwitchClause */; + }; + + CaseSwitchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return CaseSwitchClause; + })(AST); + TypeScript.CaseSwitchClause = CaseSwitchClause; + + var DefaultSwitchClause = (function (_super) { + __extends(DefaultSwitchClause, _super); + function DefaultSwitchClause(statements) { + _super.call(this); + this.statements = statements; + statements && (statements.parent = this); + } + DefaultSwitchClause.prototype.kind = function () { + return 234 /* DefaultSwitchClause */; + }; + + DefaultSwitchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statements, ast.statements, includingPosition); + }; + return DefaultSwitchClause; + })(AST); + TypeScript.DefaultSwitchClause = DefaultSwitchClause; + + var BreakStatement = (function (_super) { + __extends(BreakStatement, _super); + function BreakStatement(identifier) { + _super.call(this); + this.identifier = identifier; + } + BreakStatement.prototype.kind = function () { + return 152 /* BreakStatement */; + }; + + BreakStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return BreakStatement; + })(AST); + TypeScript.BreakStatement = BreakStatement; + + var ContinueStatement = (function (_super) { + __extends(ContinueStatement, _super); + function ContinueStatement(identifier) { + _super.call(this); + this.identifier = identifier; + } + ContinueStatement.prototype.kind = function () { + return 153 /* ContinueStatement */; + }; + + ContinueStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return ContinueStatement; + })(AST); + TypeScript.ContinueStatement = ContinueStatement; + + var ForStatement = (function (_super) { + __extends(ForStatement, _super); + function ForStatement(variableDeclaration, initializer, condition, incrementor, statement) { + _super.call(this); + this.variableDeclaration = variableDeclaration; + this.initializer = initializer; + this.condition = condition; + this.incrementor = incrementor; + this.statement = statement; + variableDeclaration && (variableDeclaration.parent = this); + initializer && (initializer.parent = this); + condition && (condition.parent = this); + incrementor && (incrementor.parent = this); + statement && (statement.parent = this); + } + ForStatement.prototype.kind = function () { + return 154 /* ForStatement */; + }; + + ForStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.initializer, ast.initializer, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.incrementor, ast.incrementor, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ForStatement; + })(AST); + TypeScript.ForStatement = ForStatement; + + var ForInStatement = (function (_super) { + __extends(ForInStatement, _super); + function ForInStatement(variableDeclaration, left, expression, statement) { + _super.call(this); + this.variableDeclaration = variableDeclaration; + this.left = left; + this.expression = expression; + this.statement = statement; + variableDeclaration && (variableDeclaration.parent = this); + left && (left.parent = this); + expression && (expression.parent = this); + statement && (statement.parent = this); + } + ForInStatement.prototype.kind = function () { + return 155 /* ForInStatement */; + }; + + ForInStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.variableDeclaration, ast.variableDeclaration, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return ForInStatement; + })(AST); + TypeScript.ForInStatement = ForInStatement; + + var WhileStatement = (function (_super) { + __extends(WhileStatement, _super); + function WhileStatement(condition, statement) { + _super.call(this); + this.condition = condition; + this.statement = statement; + condition && (condition.parent = this); + statement && (statement.parent = this); + } + WhileStatement.prototype.kind = function () { + return 158 /* WhileStatement */; + }; + + WhileStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return WhileStatement; + })(AST); + TypeScript.WhileStatement = WhileStatement; + + var WithStatement = (function (_super) { + __extends(WithStatement, _super); + function WithStatement(condition, statement) { + _super.call(this); + this.condition = condition; + this.statement = statement; + condition && (condition.parent = this); + statement && (statement.parent = this); + } + WithStatement.prototype.kind = function () { + return 163 /* WithStatement */; + }; + + WithStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return WithStatement; + })(AST); + TypeScript.WithStatement = WithStatement; + + var EnumDeclaration = (function (_super) { + __extends(EnumDeclaration, _super); + function EnumDeclaration(modifiers, identifier, enumElements) { + _super.call(this); + this.modifiers = modifiers; + this.identifier = identifier; + this.enumElements = enumElements; + identifier && (identifier.parent = this); + enumElements && (enumElements.parent = this); + } + EnumDeclaration.prototype.kind = function () { + return 132 /* EnumDeclaration */; + }; + return EnumDeclaration; + })(AST); + TypeScript.EnumDeclaration = EnumDeclaration; + + var EnumElement = (function (_super) { + __extends(EnumElement, _super); + function EnumElement(propertyName, equalsValueClause) { + _super.call(this); + this.propertyName = propertyName; + this.equalsValueClause = equalsValueClause; + propertyName && (propertyName.parent = this); + equalsValueClause && (equalsValueClause.parent = this); + } + EnumElement.prototype.kind = function () { + return 243 /* EnumElement */; + }; + return EnumElement; + })(AST); + TypeScript.EnumElement = EnumElement; + + var CastExpression = (function (_super) { + __extends(CastExpression, _super); + function CastExpression(type, expression) { + _super.call(this); + this.type = type; + this.expression = expression; + type && (type.parent = this); + expression && (expression.parent = this); + } + CastExpression.prototype.kind = function () { + return 220 /* CastExpression */; + }; + + CastExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.type, ast.type, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return CastExpression; + })(AST); + TypeScript.CastExpression = CastExpression; + + var ObjectLiteralExpression = (function (_super) { + __extends(ObjectLiteralExpression, _super); + function ObjectLiteralExpression(propertyAssignments) { + _super.call(this); + this.propertyAssignments = propertyAssignments; + propertyAssignments && (propertyAssignments.parent = this); + } + ObjectLiteralExpression.prototype.kind = function () { + return 215 /* ObjectLiteralExpression */; + }; + + ObjectLiteralExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.propertyAssignments, ast.propertyAssignments, includingPosition); + }; + return ObjectLiteralExpression; + })(AST); + TypeScript.ObjectLiteralExpression = ObjectLiteralExpression; + + var SimplePropertyAssignment = (function (_super) { + __extends(SimplePropertyAssignment, _super); + function SimplePropertyAssignment(propertyName, expression) { + _super.call(this); + this.propertyName = propertyName; + this.expression = expression; + propertyName && (propertyName.parent = this); + expression && (expression.parent = this); + } + SimplePropertyAssignment.prototype.kind = function () { + return 240 /* SimplePropertyAssignment */; + }; + return SimplePropertyAssignment; + })(AST); + TypeScript.SimplePropertyAssignment = SimplePropertyAssignment; + + var FunctionPropertyAssignment = (function (_super) { + __extends(FunctionPropertyAssignment, _super); + function FunctionPropertyAssignment(propertyName, callSignature, block) { + _super.call(this); + this.propertyName = propertyName; + this.callSignature = callSignature; + this.block = block; + propertyName && (propertyName.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionPropertyAssignment.prototype.kind = function () { + return 241 /* FunctionPropertyAssignment */; + }; + return FunctionPropertyAssignment; + })(AST); + TypeScript.FunctionPropertyAssignment = FunctionPropertyAssignment; + + var FunctionExpression = (function (_super) { + __extends(FunctionExpression, _super); + function FunctionExpression(identifier, callSignature, block) { + _super.call(this); + this.identifier = identifier; + this.callSignature = callSignature; + this.block = block; + identifier && (identifier.parent = this); + callSignature && (callSignature.parent = this); + block && (block.parent = this); + } + FunctionExpression.prototype.kind = function () { + return 222 /* FunctionExpression */; + }; + return FunctionExpression; + })(AST); + TypeScript.FunctionExpression = FunctionExpression; + + var EmptyStatement = (function (_super) { + __extends(EmptyStatement, _super); + function EmptyStatement() { + _super.apply(this, arguments); + } + EmptyStatement.prototype.kind = function () { + return 156 /* EmptyStatement */; + }; + + EmptyStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition); + }; + return EmptyStatement; + })(AST); + TypeScript.EmptyStatement = EmptyStatement; + + var TryStatement = (function (_super) { + __extends(TryStatement, _super); + function TryStatement(block, catchClause, finallyClause) { + _super.call(this); + this.block = block; + this.catchClause = catchClause; + this.finallyClause = finallyClause; + block && (block.parent = this); + catchClause && (catchClause.parent = this); + finallyClause && (finallyClause.parent = this); + } + TryStatement.prototype.kind = function () { + return 159 /* TryStatement */; + }; + + TryStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition) && structuralEquals(this.catchClause, ast.catchClause, includingPosition) && structuralEquals(this.finallyClause, ast.finallyClause, includingPosition); + }; + return TryStatement; + })(AST); + TypeScript.TryStatement = TryStatement; + + var CatchClause = (function (_super) { + __extends(CatchClause, _super); + function CatchClause(identifier, typeAnnotation, block) { + _super.call(this); + this.identifier = identifier; + this.typeAnnotation = typeAnnotation; + this.block = block; + identifier && (identifier.parent = this); + typeAnnotation && (typeAnnotation.parent = this); + block && (block.parent = this); + } + CatchClause.prototype.kind = function () { + return 236 /* CatchClause */; + }; + + CatchClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.typeAnnotation, ast.typeAnnotation, includingPosition) && structuralEquals(this.block, ast.block, includingPosition); + }; + return CatchClause; + })(AST); + TypeScript.CatchClause = CatchClause; + + var FinallyClause = (function (_super) { + __extends(FinallyClause, _super); + function FinallyClause(block) { + _super.call(this); + this.block = block; + block && (block.parent = this); + } + FinallyClause.prototype.kind = function () { + return 237 /* FinallyClause */; + }; + + FinallyClause.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.block, ast.block, includingPosition); + }; + return FinallyClause; + })(AST); + TypeScript.FinallyClause = FinallyClause; + + var LabeledStatement = (function (_super) { + __extends(LabeledStatement, _super); + function LabeledStatement(identifier, statement) { + _super.call(this); + this.identifier = identifier; + this.statement = statement; + identifier && (identifier.parent = this); + statement && (statement.parent = this); + } + LabeledStatement.prototype.kind = function () { + return 160 /* LabeledStatement */; + }; + + LabeledStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.identifier, ast.identifier, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition); + }; + return LabeledStatement; + })(AST); + TypeScript.LabeledStatement = LabeledStatement; + + var DoStatement = (function (_super) { + __extends(DoStatement, _super); + function DoStatement(statement, whileKeyword, condition) { + _super.call(this); + this.statement = statement; + this.whileKeyword = whileKeyword; + this.condition = condition; + statement && (statement.parent = this); + condition && (condition.parent = this); + } + DoStatement.prototype.kind = function () { + return 161 /* DoStatement */; + }; + + DoStatement.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.statement, ast.statement, includingPosition) && structuralEquals(this.condition, ast.condition, includingPosition); + }; + return DoStatement; + })(AST); + TypeScript.DoStatement = DoStatement; + + var TypeOfExpression = (function (_super) { + __extends(TypeOfExpression, _super); + function TypeOfExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + TypeOfExpression.prototype.kind = function () { + return 171 /* TypeOfExpression */; + }; + + TypeOfExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return TypeOfExpression; + })(AST); + TypeScript.TypeOfExpression = TypeOfExpression; + + var DeleteExpression = (function (_super) { + __extends(DeleteExpression, _super); + function DeleteExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + DeleteExpression.prototype.kind = function () { + return 170 /* DeleteExpression */; + }; + + DeleteExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return DeleteExpression; + })(AST); + TypeScript.DeleteExpression = DeleteExpression; + + var VoidExpression = (function (_super) { + __extends(VoidExpression, _super); + function VoidExpression(expression) { + _super.call(this); + this.expression = expression; + expression && (expression.parent = this); + } + VoidExpression.prototype.kind = function () { + return 172 /* VoidExpression */; + }; + + VoidExpression.prototype.structuralEquals = function (ast, includingPosition) { + return _super.prototype.structuralEquals.call(this, ast, includingPosition) && structuralEquals(this.expression, ast.expression, includingPosition); + }; + return VoidExpression; + })(AST); + TypeScript.VoidExpression = VoidExpression; + + var DebuggerStatement = (function (_super) { + __extends(DebuggerStatement, _super); + function DebuggerStatement() { + _super.apply(this, arguments); + } + DebuggerStatement.prototype.kind = function () { + return 162 /* DebuggerStatement */; + }; + return DebuggerStatement; + })(AST); + TypeScript.DebuggerStatement = DebuggerStatement; + + var Comment = (function () { + function Comment(_trivia, endsLine, _start, _end) { + this._trivia = _trivia; + this.endsLine = endsLine; + this._start = _start; + this._end = _end; + } + Comment.prototype.start = function () { + return this._start; + }; + + Comment.prototype.end = function () { + return this._end; + }; + + Comment.prototype.fullText = function () { + return this._trivia.fullText(); + }; + + Comment.prototype.kind = function () { + return this._trivia.kind(); + }; + + Comment.prototype.structuralEquals = function (ast, includingPosition) { + if (includingPosition) { + if (this.start() !== ast.start() || this.end() !== ast.end()) { + return false; + } + } + + return this._trivia.fullText() === ast._trivia.fullText() && this.endsLine === ast.endsLine; + }; + return Comment; + })(); + TypeScript.Comment = Comment; + + function diagnosticFromDecl(decl, diagnosticKey, arguments) { + if (typeof arguments === "undefined") { arguments = null; } + var span = decl.getSpan(); + return new TypeScript.Diagnostic(decl.fileName(), decl.semanticInfoChain().lineMap(decl.fileName()), span.start(), span.length(), diagnosticKey, arguments); + } + TypeScript.diagnosticFromDecl = diagnosticFromDecl; + + function min(a, b) { + return a <= b ? a : b; + } +})(TypeScript || (TypeScript = {})); diff --git a/angular-ui/angular-ui-router-tests.ts b/angular-ui/angular-ui-router-tests.ts index 3d7ce3b5c..38f8b5ca0 100644 --- a/angular-ui/angular-ui-router-tests.ts +++ b/angular-ui/angular-ui-router-tests.ts @@ -2,6 +2,10 @@ var myApp = angular.module('testModule'); +interface MyAppScope extends ng.IScope { + items: string[]; + things: string[]; +} myApp.config(( $stateProvider: ng.ui.IStateProvider, @@ -19,7 +23,7 @@ myApp.config(( .state('state1.list', { url: "/list", templateUrl: "partials/state1.list.html", - controller: function($scope) { + controller: function ($scope: MyAppScope) { $scope.items = ["A", "List", "Of", "Items"]; } }) @@ -30,7 +34,7 @@ myApp.config(( .state('state2.list', { url: "/list", templateUrl: "partials/state2.list.html", - controller: function($scope) { + controller: function ($scope: MyAppScope) { $scope.things = ["A", "Set", "Of", "Things"]; } }).state('index', { diff --git a/angularjs/angular-resource-tests.ts b/angularjs/angular-resource-tests.ts index b223b8171..2870b21ad 100644 --- a/angularjs/angular-resource-tests.ts +++ b/angularjs/angular-resource-tests.ts @@ -83,5 +83,5 @@ var resourceService: ng.resource.IResourceService; resourceClass = resourceServiceFactoryFunction(resourceService); -resourceServiceFactoryFunction = function (resourceService) { return resourceClass }; +resourceServiceFactoryFunction = function (resourceService: ng.resource.IResourceService) { return resourceClass; }; mod = mod.factory('factory name', resourceServiceFactoryFunction); diff --git a/angularjs/angular-tests.ts b/angularjs/angular-tests.ts index bcfe31d16..0b6843309 100644 --- a/angularjs/angular-tests.ts +++ b/angularjs/angular-tests.ts @@ -20,7 +20,7 @@ angular.module('http-auth-interceptor', []) * Required by HTTP interceptor. * Function is attached to provider to be invisible for regular users of this service. */ - this.pushToBuffer = function (config: ng.IRequestConfig, deferred: ng.IDeferred) { + this.pushToBuffer = function (config: ng.IRequestConfig, deferred: ng.IDeferred) { buffer.push({ config: config, deferred: deferred diff --git a/async/async-tests.ts b/async/async-tests.ts index fefc3fd2a..ae92bbff9 100644 --- a/async/async-tests.ts +++ b/async/async-tests.ts @@ -135,7 +135,7 @@ async.waterfall([ ], function (err, result) { }); -var q = async.queue(function (task, callback) { +var q = async.queue(function (task: any, callback) { console.log('hello ' + task.name); callback(); }, 2); diff --git a/azure-mobile-services-client/AzureMobileServicesClient-tests.ts b/azure-mobile-services-client/AzureMobileServicesClient-tests.ts index 4d1765b25..7a3b9b956 100644 --- a/azure-mobile-services-client/AzureMobileServicesClient-tests.ts +++ b/azure-mobile-services-client/AzureMobileServicesClient-tests.ts @@ -59,7 +59,7 @@ query.read().done(printOut); //Execute query remotly and return data filtered //testing more complicated Query in composition with previous using function Predicate and Projection var minlength = 15; //parameter value for filter Predicate -query.where(function (len: number) { return this.text != null && this.text.length > len }, minlength) +query.where(function (len?: number) { return this.text != null && this.text.length > len }, minlength) .orderByDescending('id').skip(2).take(3) //some other ordering and paging filters .select(function () { return { abc: this.text + '|' + this.id }; }) //Projection .read().done(printOut); //return 3 object {abd: 'ttttttttttttttt|ID'} diff --git a/bootstrap.datepicker/bootstrap.datepicker-tests.ts b/bootstrap.datepicker/bootstrap.datepicker-tests.ts index 3346ab5e2..0bbf2c650 100644 --- a/bootstrap.datepicker/bootstrap.datepicker-tests.ts +++ b/bootstrap.datepicker/bootstrap.datepicker-tests.ts @@ -1,5 +1,4 @@ -/// -/// +/// function tests_simple() { $('#datepicker').datepicker(); @@ -11,30 +10,32 @@ function tests_simple() { $('#datepicker').datepicker('setEndDate', '2012-12-31'); $('#date-end') .datepicker() - .on('changeDate', function (ev) { }); + .on('changeDate', function (ev) { ev; }); var startDate = new Date(2012, 1, 20); var endDate = new Date(2012, 1, 25); $('#date-start') .datepicker() - .on('changeDate', function (ev) { + //.on("changeDate", function (ev) { // bug https://typescript.codeplex.com/workitem/1976 + .on("changeDate", function (ev: DatepickerEventObject) { if (ev.date.valueOf() > endDate.valueOf()) { $('#alert').show().find('strong').text('The start date must be before the end date.'); } else { $('#alert').hide(); - startDate = new Date(ev.date); + startDate = ev.date; $('#date-start-display').text($('#date-start').data('date')); } $('#date-start').datepicker('hide'); }); $('#date-end') .datepicker() - .on('changeDate', function (ev) { + //.on('changeDate', function (ev) { // bug https://typescript.codeplex.com/workitem/1976 + .on('changeDate', function (ev: DatepickerEventObject) { if (ev.date.valueOf() < startDate.valueOf()) { $('#alert').show().find('strong').text('The end date must be after the start date.'); } else { $('#alert').hide(); - endDate = new Date(ev.date); + endDate = ev.date; $('#date-end-display').text($('#date-end').data('date')); } $('#date-end').datepicker('hide'); @@ -55,25 +56,27 @@ $(function () { var startDate = new Date(2012, 1, 20); var endDate = new Date(2012, 1, 25); $('#dp4').datepicker() - .on('changeDate', function (ev) { + //.on('changeDate', function (ev) { // bug https://typescript.codeplex.com/workitem/1976 + .on('changeDate', function (ev: DatepickerEventObject) { if (ev.date.valueOf() > endDate.valueOf()) { $('#alert').show().find('strong').text('The start date can not be greater then the end date'); } else { $('#alert').hide(); - startDate = new Date(ev.date); + startDate = ev.date; $('#startDate').text($('#dp4').data('date')); } $('#dp4').datepicker('hide'); }); $('#dp5').datepicker() - .on('changeDate', function (ev) { + //.on('changeDate', function (ev) { // bug https://typescript.codeplex.com/workitem/1976 + .on('changeDate', function (ev: DatepickerEventObject) { if (ev.date.valueOf() < startDate.valueOf()) { $('#alert').show().find('strong').text('The end date can not be less then the start date'); } else { $('#alert').hide(); - endDate = new Date(ev.date); + endDate = ev.date; $('#endDate').text($('#dp5').data('date')); } $('#dp5').datepicker('hide'); }); -}); \ No newline at end of file +}); diff --git a/bootstrap.datepicker/bootstrap.datepicker.d.ts b/bootstrap.datepicker/bootstrap.datepicker.d.ts index 4cf27ef19..0664b2aa0 100644 --- a/bootstrap.datepicker/bootstrap.datepicker.d.ts +++ b/bootstrap.datepicker/bootstrap.datepicker.d.ts @@ -3,7 +3,6 @@ // Definitions by: Boris Yankov // Definitions: https://github.com/borisyankov/DefinitelyTyped - /// interface DatepickerOptions { @@ -19,15 +18,21 @@ interface DatepickerOptions { language?: string; } +interface DatepickerEventObject extends JQueryEventObject { + date: Date; + format(format?: string): string; +} + interface JQuery { datepicker(): JQuery; datepicker(methodName: string): JQuery; datepicker(methodName: string, params: any): JQuery; datepicker(options: DatepickerOptions): JQuery; - off(events?: "changeDate", selector?: any, handler?: (eventObject: any) => any): JQuery; + off(events: "changeDate", selector?: string, handler?: (eventObject: DatepickerEventObject) => any): JQuery; + off(events: "changeDate", handler: (eventObject: DatepickerEventObject) => any): JQuery; - on(events: "changeDate", selector?: string, data?: any, handler?: (eventObject: any) => any): JQuery; - on(events: "changeDate", selector?: string, handler?: (eventObject: any) => any): JQuery; - on(events: "changeDate", handler?: (eventObject: any) => any): JQuery; + on(events: "changeDate", selector: string, data: any, handler?: (eventObject: DatepickerEventObject) => any): JQuery; + on(events: "changeDate", selector: string, handler: (eventObject: DatepickerEventObject) => any): JQuery; + on(events: 'changeDate', handler: (eventObject: DatepickerEventObject) => any): JQuery; } diff --git a/breeze/breeze-1.0-tests.ts b/breeze/breeze-1.0-tests.ts deleted file mode 100644 index 7dc1dc453..000000000 --- a/breeze/breeze-1.0-tests.ts +++ /dev/null @@ -1,787 +0,0 @@ -/// - -import breeze = Breeze; -import core = BreezeCore; - -function test_dataType() { - var typ = breeze.DataType.DateTime; - var nm = typ.getName(); - var isNumber = typ.isNumeric; - var dv = typ.defaultValue; - var symbs = breeze.DataType.getSymbols(); - var x = typ.parentEnum === breeze.DataType; - var isFalse = breeze.DataType.contains(breeze.DataType.Double); - var dt = breeze.DataType.fromName("Decimal"); -} - -function test_dataProperty() { - var lastNameProp = new breeze.DataProperty({ - name: "lastName", - dataType: breeze.DataType.String, - isNullable: true, - maxLength: 20 - }); - var personEntityType: breeze.EntityType; - personEntityType.addProperty(lastNameProp); -} - -function test_dataService() { - var ds = new breeze.DataService({ - serviceName: "api/NorthwindIBModel", - hasServerMetadata: true - }); - var em = new breeze.EntityManager({ - dataService: ds - }); -} - -function test_entityAspect() { - var order: breeze.Entity; - order.entityAspect.acceptChanges(); - var entityKey = order.entityAspect.getKey(); - var valErrors = order.entityAspect.getValidationErrors(); - var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate"); - var orderDateProperty = order.entityType.getProperty("OrderDate"); - var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty); - order.entityAspect.loadNavigationProperty("Orders").then(function (data) { - var orders = data.results; - }).fail(function (exception) { }); - order.entityAspect.rejectChanges(); - order.entityAspect.setDeleted(); - order.entityAspect.setModified(); - order.entityAspect.setUnchanged(); - var isOk = order.entityAspect.validateEntity(); - if (!isOk) { - var errors = order.entityAspect.getValidationErrors(); - } - var isOk = order.entityAspect.validateProperty("Order"); - var orderDateProperty = order.entityType.getProperty("OrderDate"); - //var isOk = order.entityAspect.validateProperty(OrderDateProperty); - order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) { - var entity = propertyChangedArgs.entity; - var propertyNameChanged = propertyChangedArgs.propertyName; - var oldValue = propertyChangedArgs.oldValue; - var newValue = propertyChangedArgs.newValue; - }); - order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) { - var entity = validationChangeArgs.entity; - var errorsAdded = validationChangeArgs.added; - var errorsCleared = validationChangeArgs.removed; - }); - -} - -function test_entityKey() { - var em1: breeze.EntityManager; - var employee1: breeze.Entity; - var empType = em1.metadataStore.getEntityType("Employee"); - var entityKey = new breeze.EntityKey( empType, 1); - var empKey = employee1.entityAspect.getKey(); - var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory"); - var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]); - var empType = em1.metadataStore.getEntityType("Employee"); - var empKey1 = new breeze.EntityKey( empType, 1); - var empKey2 = employee1.entityAspect.getKey(); - if (empKey1.equals(empKey2)) { } - if (breeze.EntityKey.equals(empKey1, empKey2)) { } -} - -function test_metadataStore() { - var ms = new breeze.MetadataStore(); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - metadataStore: ms - }); - var em1: breeze.EntityManager; - em1.setProperties({ metadataStore: ms }); - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = new breeze.MetadataStore(); - newMetadataStore.importMetadata(metadataFromStorage); - var ms = new breeze.MetadataStore(); - ms.fetchMetadata("api/NorthwindIBModel") - .then(function (rawMetadata) { }) - .fail(function (exception) { }); - var odType = em1.metadataStore.getEntityType("OrderDetail"); - var badType = em1.metadataStore.getEntityType("Foo", false); - var allTypes = em1.metadataStore.getEntityTypes(); - if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { } - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage); - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = new breeze.MetadataStore(); - newMetadataStore.importMetadata(metadataFromStorage); - if (em1.metadataStore.isEmpty()) { } - var Customer = function () { - this.miscData = "asdf"; - } - em1.metadataStore.registerEntityTypeCtor("Customer", Customer); -} - -function test_entityManager() { - var entityManager = new breeze.EntityManager("api/NorthwindIBModel"); - var entityManager = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - var metadataStore = new breeze.MetadataStore(); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - metadataStore: metadataStore - }); - return new breeze.QueryOptions({ - mergeStrategy: null, - fetchStrategy: this.fetchStrategy - }); - var queryOptions = new breeze.QueryOptions({ - mergeStrategy: breeze.MergeStrategy.OverwriteChanges, - fetchStrategy: breeze.FetchStrategy.FromServer - }); - var validationOptions = new breeze.ValidationOptions({ - validateOnAttach: true, - validateOnSave: true, - validateOnQuery: false - }); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - queryOptions: queryOptions, - validationOptions: validationOptions - }); - var custType = em1.metadataStore.getEntityType("Customer"); - var cust1 = custType.createEntity(); - em1.addEntity(cust1); - em1.attachEntity(cust1, breeze.EntityState.Added); - em1.clear(); - var em2 = em1.createEmptyCopy(); - em1.detachEntity(cust1); - var serviceName: string; - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query, - function (data) { - var orders = data.results; - }, - function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute() - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - var orders = em.executeQueryLocally(query); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var bundle = em1.exportEntities(); - window.localStorage.setItem("myEntityManager", bundle); - var bundleFromStorage = window.localStorage.getItem("myEntityManager"); - var em2 = new breeze.EntityManager({ - serviceName: em1.serviceName, - metadataStore: em1.metadataStore - }); - em2.importEntities(bundleFromStorage); - var entitiesToExport: breeze.Entity[]; - var bundle = em1.exportEntities(entitiesToExport); - em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); - var em1 = new breeze.EntityManager("api/NorthwindIBModel"); - em1.fetchMetadata() - .then(function () { - var metadataStore = em1.metadataStore; - }) - .fail(function (exception) { - }); - var employeeType = em1.metadataStore.getEntityType("Employee"); - var employeeKey = new breeze.EntityKey( employeeType, 1); - var employee = em1.fetchEntityByKey(employeeKey); - var emp2 = em1.fetchEntityByKey("Employee", 6); - var emp3 = em1.fetchEntityByKey("Entityee", [6]); - var custType = em1.metadataStore.getEntityType("Customer"); - var custumer = custType.createEntity(); - var customerId = em.generateTempKeyValue(custumer); - em1.saveChanges() - .then(function (data) { - var sameCust1 = data.results[0]; - }); - var changedEntities = em1.getChanges(); - var custType = em1.metadataStore.getEntityType("Customer"); - var changedCustomers = em1.getChanges(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var changedCustomersAndOrders = em1.getChanges([custType, orderType]); - var entities = em1.getEntities(); - var custType = em1.metadataStore.getEntityType("Customer"); - var customers = em1.getEntities(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var customersAndOrders = em1.getChanges([custType, orderType]); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added); - if (em1.hasChanges()) { } - var custType = em1.metadataStore.getEntityType("Customer"); - if (em1.hasChanges(custType)) { } - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - if (em1.hasChanges([custType, orderType])) { } - var bundle = em1.exportEntities(); - window.localStorage.setItem("myEntityManager", bundle); - var bundleFromStorage = window.localStorage.getItem("myEntityManager"); - var em2 = breeze.EntityManager.importEntities(bundleFromStorage); - var bundle = em1.exportEntities(); - var em2 = new breeze.EntityManager({ - serviceName: em1.serviceName, - metadataStore: em1.metadataStore - }); - em2.importEntities(bundle); - var bundle = em1.exportEntities(); - em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); - em.saveChanges().then(function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }).fail(function (e) { - }); - var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true }); - var entitiesToSave: breeze.Entity[]; - em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }).fail(function (e) { - }); - em.saveChanges(entitiesToSave, null, - function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }, function (e) { } - ); - em1.setProperties({ - serviceName: "api/foo", - }); - var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - em.entityChanged.subscribe(function (changeArgs) { - var action = changeArgs.entityAction; - var entity = changeArgs.entity; - }); - var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - em.hasChangesChanged.subscribe(function (args) { - var hasChangesChanged = args.hasChanges; - var entityManager = args.entityManager; - }); -} - -function test_entityQuery() { - var query = new breeze.EntityQuery("Customers"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .orderBy("Region"); - var serviceName: string; - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute() - .then(function (data) { }) - .fail(function (err) { }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute( - function (data) { - var orders = data.results; - }, - function (err) { }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var query = new breeze.EntityQuery("Orders").using(em); - var orders = query.executeLocally(); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .expand("Orders"); - var query = new breeze.EntityQuery("Orders") - .expand("Customer, Employee"); - var query = new breeze.EntityQuery("Orders") - .expand("Customer, OrderDetails, OrderDetails.Product"); - var query = breeze.EntityQuery.from("Customers"); - var query = new breeze.EntityQuery("Customers"); - var query = new breeze.EntityQuery().from("Customers"); - var customer: breeze.Entity; - var customers: breeze.Entity[]; - var customersQuery = breeze.EntityQuery.fromEntities(customers); - var customersQuery = breeze.EntityQuery.fromEntities(customers) - .where("Region", breeze.FilterQueryOp.NotEquals, null); - var customerQuery = breeze.EntityQuery.fromEntities(customer); - var metadataStore: breeze.MetadataStore; - var empType = metadataStore.getEntityType("Employee"); - var entityKey = new breeze.EntityKey( empType, 1); - var query = breeze.EntityQuery.fromEntityKey(entityKey); - var employee: breeze.Entity; - var entityKey = employee.entityAspect.getKey(); - var query = breeze.EntityQuery.fromEntityKey(entityKey); - var ordersNavProp = employee.entityType.getProperty("Orders"); - var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp); - var query = new breeze.EntityQuery("Customers") - .orderBy("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .orderBy("Region, CompanyName"); - var query = new breeze.EntityQuery("Products") - .orderBy("Category.CategoryName"); - var query = new breeze.EntityQuery("Customers") - .orderBy("CompanyName desc"); - var query = new breeze.EntityQuery("Customers") - .orderBy("Region desc, CompanyName desc"); - var query = new breeze.EntityQuery("Customers") - .orderByDesc("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("Orders"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("CompanyName, Orders"); - var query = new breeze.EntityQuery("Orders") - .where("Customer.CompanyName", "startsWith", "C") - .select("Customer.CompanyName, Customer, OrderDate"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .skip(5); - var query = new breeze.EntityQuery("Customers") - .take(5); - var query = new breeze.EntityQuery("Customers") - .top(5); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(em); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(breeze.MergeStrategy.PreserveChanges); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(breeze.FetchStrategy.FromLocalCache); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); - var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); - var query = new breeze.EntityQuery("Customers") - .where(pred); - var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null); - var query = new breeze.EntityQuery("Customers") - .where(pred); - var query = new breeze.EntityQuery("Products") - .where("Category.CategoryName", "startswith", "S"); - var query = new breeze.EntityQuery("Customers") - .where("toLower(CompanyName)", "startsWith", "c"); - var query = new breeze.EntityQuery("Customers") - .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM"); -} - -function test_entityState() { - var anEntity: breeze.Entity; - var es = anEntity.entityAspect.entityState; - return es.isAdded(); - return es === breeze.EntityState.Added; - var es = anEntity.entityAspect.entityState; - return es.isAddedModifiedOrDeleted(); - return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted; - var es = anEntity.entityAspect.entityState; - return es.isDeleted(); - return es === breeze.EntityState.Deleted; - var es = anEntity.entityAspect.entityState; - return es.isDetached(); - return es === breeze.EntityState.Detached; - var es = anEntity.entityAspect.entityState; - return es.isModified(); - return es === breeze.EntityState.Modified; - var es = anEntity.entityAspect.entityState; - return es.isUnchanged(); - return es === breeze.EntityState.Unchanged; - var es = anEntity.entityAspect.entityState; - return es.isUnchangedOrModified(); - - return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified; -} - -function test_entityType() { - var myMetadataStore: breeze.MetadataStore; - var myEntityType: breeze.EntityType; - var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty; - var em1: breeze.EntityManager; - var entityManager = new breeze.EntityType({ - metadataStore: myMetadataStore, - serviceName: "api/NorthwindIBModel", - name: "person", - namespace: "myAppNamespace" - }); - myEntityType.addProperty(dataProperty1); - myEntityType.addProperty(dataProperty2); - myEntityType.addProperty(navigationProperty1); - var custType = em1.metadataStore.getEntityType("Customer"); - var countryProp = custType.getProperty("Country"); - var valFn = function (v) { - if (v == null) return true; - return (v.substring(0,2) === "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, - { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" }); - custType.addValidator(countryValidator, countryProp); - countryProp.validators.push(countryValidator); - var someEntityLevelValidator: breeze.Validator; - custType.addValidator(someEntityLevelValidator); - custType.validators.push(someEntityLevelValidator); - var custType = em1.metadataStore.getEntityType("Customer"); - var cust1 = custType.createEntity(); - em1.addEntity(cust1); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerNameDataProp = custType.getDataProperty("CustomerName"); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerOrdersNavProp = custType.getDataProperty("Orders"); - var custType = em1.metadataStore.getEntityType("Customer"); - var arrayOfProps = custType.getProperties(); - var custType = em1.metadataStore.getEntityType("Customer"); - var companyNameProp = custType.getProperty("CompanyName"); - var orderDetailType = em1.metadataStore.getEntityType("OrderDetail"); - var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName"); - var custType = em1.metadataStore.getEntityType("Customer"); - var arrayOfPropNames = custType.getPropertyNames(); - var custType = em1.metadataStore.getEntityType("Customer"); - custType.setProperties({ - autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity, - defaultResourceName: "CustomersAndIncludedOrders" - }); -} - -//function test_enum() { -// var prototype = { -// nextDay: function () { -// var nextIndex = (this.dayIndex + 1) % 7; -// return DayOfWeek.getSymbols()[nextIndex]; -// } -// }; -// var DayOfWeek = new core.Enum("DayOfWeek", prototype); -// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); -// var symbol = DayOfWeek.Friday; -// if (DayOfWeek.contains(symbol)) { } -// var dayOfWeek = DayOfWeek.from("Thursday"); -// var symbols = DayOfWeek.getNames(); -// var symbols = DayOfWeek.getSymbols(); -// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { }; -// DayOfWeek.seal(); -// var name = DayOfWeek.Monday.getName(); -// var name = DayOfWeek.Monday.toString(); - - -// var prototype = { -// nextDay: function () { -// var nextIndex = (this.dayIndex + 1) % 7; -// return DayOfWeek.getSymbols()[nextIndex]; -// } -// }; -// var DayOfWeek = new core.Enum("DayOfWeek", prototype); -// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); -// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 }); -// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 }); -// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 }); -// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 }); -// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true }); -// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true }); -// DayOfWeek.seal(); -// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday; -// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday; -// DayOfWeek.Tuesday.isWeekend === undefined; -// DayOfWeek.Saturday.isWeekend == true; -// DayOfWeek instanceof core.Enum; -// core.Enum.isSymbol(DayOfWeek.Wednesday); -// DayOfWeek.contains(DayOfWeek.Thursday); -// DayOfWeek.Tuesday.parentEnum == DayOfWeek; -// DayOfWeek.getSymbols().length === 7; -// DayOfWeek.Friday.toString() === "Friday"; -//} - -function test_event() { - var myEntityManager: breeze.EntityManager; - var myEntity, person: breeze.Entity; - var salaryEvent = new core.Event("salaryEvent", person); - core.Event.enable("propertyChanged", myEntityManager, false); - core.Event.enable("propertyChanged", myEntityManager, true); - core.Event.enable("propertyChanged", myEntity.entityAspect, false); - core.Event.enable("propertyChanged", myEntity.entityAspect, null); - core.Event.enable("validationErrorsChanged", myEntityManager, function (em) { - return em.customTag === "blue"; - }); - core.Event.isEnabled("propertyChanged", myEntityManager); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { }); - salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }); - salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { }); - salaryEvent.subscribe(function (eventArgs) { - if (eventArgs.eventType === "payRaise") { } - }); - var order: breeze.Entity; - order.entityAspect.propertyChanged.subscribe(function (pcEvent) { - if (pcEvent.propertyName === "OrderDate") { } - }); - var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { }); - order.entityAspect.propertyChanged.unsubscribe(token); -} - -function test_localQueryComparisonOptions() { - var lqco = new breeze.LocalQueryComparisonOptions({ - name: "caseSensitive-nonSQL", - isCaseSensitive: true, - usesSql92CompliantStringComparison: false - }); - lqco.setAsDefault(); - var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco }); - var em = new breeze.EntityManager({ metadataStore: ms }); - var lqco = new breeze.LocalQueryComparisonOptions({ - isCaseSensitive: false, - usesSql92CompliantStringComparison: true - }); - lqco.setAsDefault(); -} - -function test_namingConventions() { - var namingConv = new breeze.NamingConvention({ - serverPropertyNameToClient: function (serverPropertyName) { - return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); - }, - clientPropertyNameToServer: function (clientPropertyName) { - return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); - } - }); - var nc = new breeze.NamingConvention({ - serverPropertyNameToClient: function (x) { - return "xxx"; - } - }); - var ms = new breeze.MetadataStore({ namingConvention: namingConv }); - var em = new breeze.EntityManager({ metadataStore: ms }); - var namingConv = new breeze.NamingConvention({ - serverPropertyNameToClient: function (serverPropertyName) { - return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); - }, - clientPropertyNameToServer: function (clientPropertyName) { - return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); - } - }); - namingConv.setAsDefault(); -} - -function test_navigationProperty() { - var homeAddressProp = new breeze.NavigationProperty({ - name: "homeAddress", - entityTypeName: "Address:#myNamespace", - isScalar: true, - associationName: "address_person", - foreignKeyNames: ["homeAddressId"] - }); - var homeAddressIdProp = new breeze.DataProperty({ - name: "homeAddressId", - dataType: breeze.DataType.Int32 - }); - var personEntityType: breeze.EntityType; - personEntityType.addProperty(homeAddressProp); - personEntityType.addProperty(homeAddressIdProp); -} - -function test_predicate() { - var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); - var p1a = breeze.Predicate.create("CompanyName", "==", "City"); - var p2a = p1a.and(p1a.not()); - var query = new breeze.EntityQuery("Customers").where(p1); - var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null); - var query = new breeze.EntityQuery("Customers").where(p2); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = p1.and(p2, p3); - var preds = [p2, p3]; - var newPred = p1.and(preds); - var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") - .and("Size", "gt", 2000); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = breeze.Predicate.and(p1, p2, p3); - var preds = [p1, p2, p3]; - var newPred = breeze.Predicate.and(preds); - var p1 = breeze.Predicate.create("Freight", "gt", 100); - var predArgs: any[] = ["Freight", "gt", 100]; - var p1 = breeze.Predicate.create(predArgs); - var p1 = new breeze.Predicate("Freight", "gt", 100); - var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); - if (breeze.Predicate.isPredicate(p1)) { } - var p1 = breeze.Predicate.create("Freight", "gt", 100); - var not_p1 = breeze.Predicate.not(p1); - var not_p1 = p1.not(); - var not_p1 = breeze.Predicate.create("Freight", "le", 100); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = breeze.Predicate.or(p1, p2, p3); - var preds = [p1, p2, p3]; - var newPred = breeze.Predicate.or(preds); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = p1.and(p2, p3); - var preds = [p2, p3]; - var newPred = p1.and(preds); - var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") - .or("Size", "gt", 2000); -} - -function test_queryOptions() { - var em1: breeze.EntityManager; - var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); - em1.setProperties({ queryOptions: newQo }); - var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); - newQo.setAsDefault(); - var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges); - var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache); - var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); -} - -function test_validationOptions() { - var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false }); - var em1: breeze.EntityManager; - em1.setProperties({ validationOptions: newVo }); - var validationOptions = new breeze.ValidationOptions() - var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); - newOptions.setAsDefault(); - var validationOptions = new breeze.ValidationOptions(); - var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); -} - -function test_validator() { - var valFn = function (v) { - if (v == null) return true; - return ( v.substr(0,2)=== "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, { - displayName: "Country", - messageTemplate: "'%displayName%' must start with 'US'" - }); - var metadataStore: breeze.MetadataStore; - var custType = metadataStore.getEntityType("Customer"); - var countryProp = custType.getProperty("Country"); - countryProp.validators.push(countryValidator); - function isValidZipCode(value) { - var re = /^\d{5}([\-]\d{4})?$/; - return (re.test(value)); - } - var valFn = function (v) { - if (v.getProperty("Country") === "USA") { - var postalCode = v.getProperty("PostalCode"); - return isValidZipCode(postalCode); - } - return true; - }; - var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn, - { messageTemplate: "For the US, this is not a valid PostalCode" }); - var em1: breeze.EntityManager; - var custType = em1.metadataStore.getEntityType("Customer"); - custType.validators.push(zipCodeValidator); - var numericRangeValidator = function (context) { - var valFn = function (v, ctx) { - if (v == null) return true; - if (typeof (v) !== "number") return false; - if (ctx.min != null && v < ctx.min) return false; - if (ctx.max != null && v > ctx.max) return false; - return true; - }; - return new breeze.Validator("numericRange", valFn, { - messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%", - min: context.min, - max: context.max - }); - }; - freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 })); - var productType = em1.metadataStore.getEntityType("Product"); - var discontinuedProperty = productType.getProperty("Discontinued"); - discontinuedProperty.validators.push(breeze.Validator.bool()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - regionProperty.validators.push(breeze.Validator.byte()); - var orderType = em1.metadataStore.getEntityType("Order"); - var orderDateProperty = orderType.getProperty("OrderDate"); - orderDateProperty.validators.push(breeze.Validator.date()); - var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); - v0.validate("adasdfasdf"); - var errMessage = v0.getMessage(); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerIdProperty = custType.getProperty("CustomerID"); - customerIdProperty.validators.push(breeze.Validator.guid()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int16()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int32()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int64()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 })); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.number()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.required()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.string()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 })); - var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); - var result = validator.validate("asdf"); - var ok = result === null; - result = validator.validate("adasdfasdf"); - var errMsg = result.errorMessage; - var context = result.context; - var sameValidator = result.validator; - var valFn = function (v) { - if (v == null) return true; - return (v.substr(0,2) === "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" }); - breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'"; -} - -function test_demo() { - - var manager = new breeze.EntityManager('api/northwind'); - - var query = new breeze.EntityQuery() - .from("Employees"); - - manager.executeQuery(query).then(function (data) { }); -} diff --git a/breeze/breeze-1.0-tests.ts.tscparams b/breeze/breeze-1.0-tests.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/breeze/breeze-1.0-tests.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/breeze/breeze-1.0.d.ts b/breeze/breeze-1.0.d.ts deleted file mode 100644 index 44fa2cca6..000000000 --- a/breeze/breeze-1.0.d.ts +++ /dev/null @@ -1,731 +0,0 @@ -// Type definitions for Breeze 1.0 -// Project: http://www.breezejs.com/ -// Definitions by: Boris Yankov -// Definitions: https://github.com/borisyankov/DefinitelyTyped - -// Updated Jan 14 2011 - Jay Traband (www.ideablade.com) - - -declare module BreezeCore { - - interface ErrorCallback { - (error: Error): void; - } - - interface IEnum { - contains(object: any): boolean; - fromName(name: string): EnumSymbol; - getNames(): string[]; - getSymbols(): EnumSymbol[]; - } - - class Enum implements IEnum { - constructor (name: string, methodObj?: any); - - addSymbol(propertiesObj?: any): EnumSymbol; - contains(object: any): boolean; - fromName(name: string): EnumSymbol; - getNames(): string[]; - getSymbols(): EnumSymbol[]; - static isSymbol(object: any): boolean; - seal(): void; - } - - class EnumSymbol { - parentEnum: IEnum; - - getName(): string; - toString(): string; - } - - class Event { - constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback); - - static enable(eventName: string, target: any): void; - static enable(eventName: string, target: any, isEnabled: boolean): void; - static enable(eventName: string, target: any, isEnabled: Function): void; - - static isEnabled(eventName: string, target: any): boolean; - publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void; - publishAsync(data: any, errorCallback?: ErrorCallback): void; - subscribe(callback?: (data: any) => void ): number; - unsubscribe(unsubKey: number): boolean; - } -} - -declare module Breeze { - - interface Entity { - entityAspect: EntityAspect; - entityType: EntityType; - } - - interface ComplexObject { - complexAspect: ComplexAspect; - complexType: ComplexType; - } - - interface IProperty { - name: string; - parentEntityType: EntityType; - validators: Validator[]; - isDataProperty: boolean; - isNavigationProperty: boolean; - } - - interface IStructuralType { - complexProperties: DataProperty[]; - dataProperties: DataProperty[]; - name: string; - namespace: string; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - } - - class AutoGeneratedKeyType { - static Identity: AutoGeneratedKeyType; - static KeyGenerator: AutoGeneratedKeyType; - static None: AutoGeneratedKeyType; - } - - class ComplexAspect { - complexObject: ComplexObject; - entityAspect: EntityAspect; - parent: Object; - parentProperty: DataProperty; - propertyPath: string; - originalValues: Object; - } - - class ComplexType implements IStructuralType { - complexProperties: DataProperty[]; - dataProperties: DataProperty[]; - name: string; - namespace: string; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - addProperty(dataProperty: DataProperty); - getProperties(): DataProperty[]; - } - - class DataProperty implements IProperty { - complexTypeName: string; - concurrencyMode: string; - dataType: DataTypeSymbol; - defaultValue: any; - fixedLength: boolean; - isComplexProperty: boolean; - isDataProperty: boolean; - isNavigationProperty: boolean; - isNullable: boolean; - isPartOfKey: boolean; - isUnmapped: boolean; - - maxLength: number; - name: string; - nameOnServer: string; - parentEntityType: EntityType; - relatedNavigationProperty: NavigationProperty; - validators: Validator[]; - constructor (config: DataPropertyOptions); - } - - interface DataPropertyOptions { - complexTypeName?: string; - concurrencyMode?: string; - dataType?: DataTypeSymbol; - defaultValue?: any; - fixedLength?: boolean; - isNullable?: boolean; - isPartOfKey?: boolean; - isUnmapped?: boolean; - maxLength?: number; - name?: string; - nameOnServer?: string; - validators?: Validator[]; - } - - class DataService { - adapterName: string; - hasServerMetadata: boolean; - serviceName: string; - constructor(config: DataServiceOptions); - } - - interface DataServiceOptions { - adapterName?: string; - hasServerMetadata?: boolean; - serviceName?: string; - } - - class DataTypeSymbol extends BreezeCore.EnumSymbol { - defaultValue: any; - isNumeric: boolean; - } - interface DataType extends BreezeCore.IEnum { - Binary: DataTypeSymbol; - Boolean: DataTypeSymbol; - Byte: DataTypeSymbol; - DateTime: DataTypeSymbol; - Decimal: DataTypeSymbol; - Double: DataTypeSymbol; - Guid: DataTypeSymbol; - Int16: DataTypeSymbol; - Int32: DataTypeSymbol; - Int64: DataTypeSymbol; - Single: DataTypeSymbol; - String: DataTypeSymbol; - Time: DataTypeSymbol; - Undefined: DataTypeSymbol; - toDataType(typeName: string): DataTypeSymbol; - parseDateFromServer(date: any): Date; - - } - var DataType: DataType; - - class EntityActionSymbol extends BreezeCore.EnumSymbol { - } - interface EntityAction extends BreezeCore.IEnum { - AcceptChanges: EntityActionSymbol; - Attach: EntityActionSymbol; - AttachOnImport: EntityActionSymbol; - AttachOnQuery: EntityActionSymbol; - Clear: EntityActionSymbol; - Detach: EntityActionSymbol; - EntityStateChange: EntityActionSymbol; - MergeOnImport: EntityActionSymbol; - MergeOnSave: EntityActionSymbol; - MergeOnQuery: EntityActionSymbol; - PropertyChange: EntityActionSymbol; - RejectChanges: EntityActionSymbol; - } - var EntityAction: EntityAction; - - class EntityAspect { - entity: Entity; - entityManager: EntityManager; - entityState: EntityStateSymbol; - isBeingSaved: boolean; - originalValues: any; - - propertyChanged: PropertyChangedEvent; - validationErrorsChanged: ValidationErrorsChangedEvent; - - acceptChanges(): void; - addValidationError(validationError: ValidationError): void; - clearValidationErrors(): void; - getKey(forceRefresh?: boolean): EntityKey; - - getValidationErrors(): ValidationError[]; - getValidationErrors(property: string): ValidationError[]; - getValidationErrors(property: IProperty): ValidationError[]; - - loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise; - loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise; - - rejectChanges(): void; - - removeValidationError(validator: Validator): void; - removeValidationError(validator: Validator, property: DataProperty): void; - removeValidationError(validator: Validator, property: NavigationProperty): void; - - setDeleted(): void; - setModified(): void; - setUnchanged(): void; - validateEntity(): boolean; - - validateProperty(property: string, context?: any): boolean; - validateProperty(property: DataProperty, context?: any): boolean; - validateProperty(property: NavigationProperty, context?: any): boolean; - } - - class PropertyChangedEventArgs { - entity: Entity; - propertyName: string; - oldValue: any; - newValue: any; - } - - class PropertyChangedEvent extends BreezeCore.Event { - subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number; - } - - class ValidationErrorsChangedEventArgs { - entity: Entity; - added: ValidationError[]; - removed: ValidationError[]; - } - - class ValidationErrorsChangedEvent extends BreezeCore.Event { - subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number; - } - - class EntityKey { - constructor (entityType: EntityType, keyValue: any); - constructor (entityType: EntityType, keyValues: any[]); - - equals(entityKey: EntityKey): boolean; - static equals(k1: EntityKey, k2: EntityKey): boolean; - } - - class EntityManager { - dataService: DataService; - keyGeneratorCtor: Function; - metadataStore: MetadataStore; - queryOptions: QueryOptions; - saveOptions: SaveOptions; - serviceName: string; - validationOptions: ValidationOptions; - - entityChanged: EntityChangedEvent; - hasChangesChanged: BreezeCore.Event; - - constructor (config?: EntityManagerOptions); - constructor (config?: string); - - addEntity(entity: Entity): Entity; - attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity; - clear(): void; - createEmptyCopy(): EntityManager; - detachEntity(entity: Entity): boolean; - createEntity(entityTypeName: string, propertyInitializer: {}): Entity; - - executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - - executeQueryLocally(query: EntityQuery): Entity[]; - exportEntities(entities?: Entity[]): string; - fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Entity; - fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Entity; - fetchEntityByKey(entityKey: EntityKey): Entity; - fetchMetadata(callback?: (schema: any) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; - generateTempKeyValue(entity: Entity): any; - getChanges(): Entity[]; - getChanges(entityTypeName: string): Entity[]; - getChanges(entityTypeNames: string[]): Entity[]; - getChanges(entityType: EntityType): Entity[]; - getChanges(entityTypes: EntityType[]): Entity[]; - - getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[]; - getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[]; - - getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[]; - getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[]; - getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[]; - - getEntityByKey(typeName: string, keyValue: any): Entity; - getEntityByKey(typeName: string, keyValues: any[]): Entity; - getEntityByKey(entityKey: EntityKey): Entity; - - hasChanges(): boolean; - hasChanges(entityTypeName: string): boolean; - hasChanges(entityTypeNames: string[]): boolean; - hasChanges(entityType: EntityType): boolean; - hasChanges(entityTypes: EntityType[]): boolean; - - static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - - rejectChanges(): Entity[]; - saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise; - setProperties(config: EntityManagerProperties): void; - } - - interface EntityManagerOptions { - serviceName?: string; - dataService?: DataService; - metadataStore?: MetadataStore; - queryOptions?: QueryOptions; - saveOptions?: SaveOptions; - validationOptions?: ValidationOptions; - keyGeneratorCtor?: Function; - } - - interface EntityManagerProperties { - serviceName?: string; - dataService?: DataService; - queryOptions?: QueryOptions; - saveOptions?: SaveOptions; - validationOptions?: ValidationOptions; - keyGeneratorCtor?: Function; - } - - interface ExecuteQuerySuccessCallback { - (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void; - } - - interface ExecuteQueryErrorCallback { - (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void; - } - - interface SaveChangesSuccessCallback { - (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void; - } - - interface SaveChangesErrorCallback { - (error: { XHR: XMLHttpRequest; }): void; - } - - class EntityChangedEventArgs { - entity: Entity; - entityAction: EntityActionSymbol; - args: Object; - } - - class EntityChangedEvent extends BreezeCore.Event { - subscribe(callback?: (data: EntityChangedEventArgs) => void ): number; - } - - class EntityQuery { - entityManager: EntityManager; - orderByClause: OrderByClause; - parameters: Object; - queryOptions: QueryOptions; - resourceName: string; - skipCount: number; - takeCount: number; - wherePredicate: Predicate; - - constructor (resourceName?: string); - - execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - executeLocally(): Entity[]; - expand(propertyPaths: string[]): EntityQuery; - expand(propertyPaths: string): EntityQuery; - static from(resourceName: string): EntityQuery; - from(resourceName: string): EntityQuery; - static fromEntities(entity: Entity): EntityQuery; - static fromEntities(entities: Entity[]): EntityQuery; - static fromEntityKey(entityKey: EntityKey): EntityQuery; - static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery; - inlineCount(enabled?: boolean): EntityQuery; - orderBy(propertyPaths: string): EntityQuery; - orderBy(propertyPaths: string[]): EntityQuery; - orderByDesc(propertyPaths: string): EntityQuery; - orderByDesc(propertyPaths: string[]): EntityQuery; - select(propertyPaths: string): EntityQuery; - select(propertyPaths: string[]): EntityQuery; - skip(count: number): EntityQuery; - take(count: number): EntityQuery; - top(count: number): EntityQuery; - - using(obj: EntityManager): EntityQuery; - using(obj: MergeStrategySymbol): EntityQuery; - using(obj: FetchStrategySymbol): EntityQuery; - - where(predicate: Predicate): EntityQuery; - where(property: string, operator: string, value: any): EntityQuery; - where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery; - where(predicate: FilterQueryOpSymbol): EntityQuery; - withParameters(params: Object): EntityQuery; - } - - interface OrderByClause { - } - - class EntityStateSymbol extends BreezeCore.EnumSymbol { - isAdded(): boolean; - isAddedModifiedOrDeleted(): boolean; - isDeleted(): boolean; - isDetached(): boolean; - isModified(): boolean; - isUnchanged(): boolean; - isUnchangedOrModified(): boolean; - } - interface EntityState extends BreezeCore.IEnum { - Added: EntityStateSymbol; - Deleted: EntityStateSymbol; - Detached: EntityStateSymbol; - Modified: EntityStateSymbol; - Unchanged: EntityStateSymbol; - } - var EntityState: EntityState; - - class EntityType implements IStructuralType { - autoGeneratedKeyType: AutoGeneratedKeyType; - complexProperties: DataProperty[]; - concurrencyProperties: DataProperty[]; - dataProperties: DataProperty[]; - defaultResourceName: string; - foreignKeyProperties: DataProperty[]; - keyProperties: DataProperty[]; - metadataStore: MetadataStore; - name: string; - namespace: string; - navigationProperties: NavigationProperty[]; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - - constructor (config: MetadataStore); - constructor (config: EntityTypeOptions); - - addProperty(property: IProperty): void; - addValidator(validator: Validator, property?: IProperty): void; - createEntity(initialValues?: Object): Entity; - getDataProperty(propertyName: string): DataProperty; - getEntityCtor(): Function; - getNavigationProperty(propertyName: string): NavigationProperty; - getProperties(): IProperty[]; - getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty; - getPropertyNames(): string[]; - setProperties(config: EntityTypeProperties): void; - toString(): string; - } - - interface EntityTypeOptions { - shortName?: string; - namespace?: string; - autogeneratedKeyType?: AutoGeneratedKeyType; - defaultResourceName?: string; - } - - interface EntityTypeProperties { - autogeneratedKeyType?: AutoGeneratedKeyType; - defaultResourceName?: string; - } - - class FetchStrategySymbol extends BreezeCore.EnumSymbol { - } - interface FetchStrategy extends BreezeCore.IEnum { - FromLocalCache: FetchStrategySymbol; - FromServer: FetchStrategySymbol; - } - var FetchStrategy: FetchStrategy; - - class FilterQueryOpSymbol extends BreezeCore.EnumSymbol { - } - interface FilterQueryOp extends BreezeCore.IEnum { - Contains: FilterQueryOpSymbol; - EndsWith: FilterQueryOpSymbol; - Equals: FilterQueryOpSymbol; - GreaterThan: FilterQueryOpSymbol; - GreaterThanOrEqual: FilterQueryOpSymbol; - LessThan: FilterQueryOpSymbol; - LessThanOrEqual: FilterQueryOpSymbol; - NotEquals: FilterQueryOpSymbol; - StartsWith: FilterQueryOpSymbol; - } - var FilterQueryOp: FilterQueryOp; - - class LocalQueryComparisonOptions { - static caseInsensitiveSQL: LocalQueryComparisonOptions; - static defaultInstance: LocalQueryComparisonOptions; - - constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; }); - - setAsDefault(): void; - } - - class MergeStrategySymbol extends BreezeCore.EnumSymbol { - } - interface MergeStrategy extends BreezeCore.IEnum { - OverwriteChanges: MergeStrategySymbol; - PreserveChanges: MergeStrategySymbol; - } - var MergeStrategy: MergeStrategy; - - class MetadataStore { - namingConvention: NamingConvention; - - constructor (config?: MetadataStoreOptions); - addDataService(dataService: DataService): void; - addEntityType(structuralType: IStructuralType): void; - exportMetadata(): string; - fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; - fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: BreezeCore.ErrorCallback): Promise; - getDataService(serviceName: string): DataService; - getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType; - getEntityTypes(): IStructuralType[]; - hasMetadataFor(serviceName: string): boolean; - static importMetadata(exportedString: string): MetadataStore; - importMetadata(exportedString: string): MetadataStore; - isEmpty(): boolean; - registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void; - trackUnmappedType(entityCtor: Function, interceptor?: Function); - } - - interface MetadataStoreOptions { - namingConvention?: NamingConvention; - localQueryComparisonOptions?: LocalQueryComparisonOptions; - } - - class NamingConvention { - static camelCase: NamingConvention; - static defaultInstance: NamingConvention; - static none: NamingConvention; - - constructor (config: NamingConventionOptions); - - clientPropertyNameToServer(clientPropertyName: string): string; - clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string; - - serverPropertyNameToClient(serverPropertyName: string): string; - serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string; - - setAsDefault(); - } - - interface NamingConventionOptions { - serverPropertyNameToClient?: (name: string) => string; - clientPropertyNameToServer?: (name: string) => string; - } - - class NavigationProperty implements IProperty { - associationName: string; - entityType: EntityType; - foreignKeyNames: string[]; - inverse: NavigationProperty; - isDataProperty: boolean; - isNavigationProperty: boolean; - isScalar: boolean; - name: string; - parentEntityType: EntityType; - relatedDataProperties: DataProperty[]; - validators: Validator[]; - - constructor (config: NavigationPropertyOptions); - } - - interface NavigationPropertyOptions { - name?: string; - nameOnServer?: string; - entityTypeName: string; - isScalar?: boolean; - associationName?: string; - foreignKeyNames?: string[]; - foreignKeyNamesOnServer?: string[]; - validators?: Validator[]; - } - - class Predicate { - constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean); - constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean); - - and: PredicateMethod; - static and: PredicateMethod; - - static create: PredicateMethod; - - static isPredicate(o: any): boolean; - - static not(predicate: Predicate): Predicate; - not(): Predicate; - - static or: PredicateMethod; - or: PredicateMethod; - - toFunction(): Function; - toString(): string; - validate(entityType: EntityType): void; - } - - interface PredicateMethod { - (predicates: Predicate[]): Predicate; - (...predicates: Predicate[]): Predicate; - (property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate; - (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate; - } - - class Promise { - fail(errorCallback: Function): Promise; - fin(finallyCallback: Function): Promise; - then(callback: Function): Promise; - } - - class QueryOptions { - static defaultInstance: QueryOptions; - fetchStrategy: FetchStrategySymbol; - mergeStrategy: MergeStrategySymbol; - - constructor (config?: QueryOptionsConfiguration); - - setAsDefault(): void; - using(config: QueryOptionsConfiguration): QueryOptions; - using(config: MergeStrategySymbol): QueryOptions; - using(config: FetchStrategySymbol): QueryOptions; - } - - interface QueryOptionsConfiguration { - fetchStrategy?: FetchStrategySymbol; - mergeStrategy?: MergeStrategySymbol; - } - - class SaveOptions { - allowConcurrentSaves: boolean; - static defaultInstance: SaveOptions; - - constructor (config?: { allowConcurrentSaves?: boolean; }); - - setAsDefault(): SaveOptions; - } - - class ValidationError { - context: any; - errorMessage: string; - property: IProperty; - propertyName: string; - validator: Validator; - - constructor (validator: Validator, context: any, errorMessage: string); - } - - class ValidationOptions { - static defaultInstance: ValidationOptions; - validateOnAttach: boolean; - validateOnPropertyChange: boolean; - validateOnQuery: boolean; - validateOnSave: boolean; - - constructor (config?: ValidationOptionsConfiguration); - - setAsDefault(): ValidationOptions; - using(config: ValidationOptionsConfiguration): ValidationOptions; - } - - interface ValidationOptionsConfiguration { - validateOnAttach?: boolean; - validateOnSave?: boolean; - validateOnQuery?: boolean; - validateOnPropertyChange?: boolean; - } - - class Validator { - static messageTemplates: any; - - constructor (name: string, validatorFn: ValidatorFunction, context?: any); - - static bool(): Validator; - static byte(): Validator; - static date(): Validator; - static duration(): Validator; - getMessage(): string; - static guid(): Validator; - static int16(): Validator; - static int32(): Validator; - static int64(): Validator; - static maxLength(context: { maxLength: number; }): Validator; - static number(): Validator; - static required(): Validator; - static string(): Validator; - static stringLength(context: { maxLength: number; minLength: number; }): Validator; - validate(value: any, context?: any): ValidationError; - } - - interface ValidatorFunction { - (value: any, context: ValidatorFunctionContext): void; - } - - interface ValidatorFunctionContext { - value: any; - validatorName: string; - displayName: string; - messageTemplate: string; - message?: string; - } -} diff --git a/breeze/breeze-1.0.d.ts.tscparams b/breeze/breeze-1.0.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/breeze/breeze-1.0.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/breeze/breeze-1.2-tests.ts b/breeze/breeze-1.2-tests.ts deleted file mode 100644 index 2dbee1545..000000000 --- a/breeze/breeze-1.2-tests.ts +++ /dev/null @@ -1,797 +0,0 @@ -/// - -import core = breezeCore; - -function test_dataType() { - var typ = breeze.DataType.DateTime; - var nm = typ.getName(); - var isNumber = typ.isNumeric; - var dv = typ.defaultValue; - var symbs = breeze.DataType.getSymbols(); - var x = typ.parentEnum === breeze.DataType; - var isFalse = breeze.DataType.contains(breeze.DataType.Double); - var dt = breeze.DataType.fromName("Decimal"); - -} - -function test_dataProperty() { - var lastNameProp = new breeze.DataProperty({ - name: "lastName", - dataType: breeze.DataType.String, - isNullable: true, - maxLength: 20 - }); - var personEntityType: breeze.EntityType; - personEntityType.addProperty(lastNameProp); -} - -function test_dataService() { - var ds = new breeze.DataService({ - serviceName: "api/NorthwindIBModel", - hasServerMetadata: true - }); - var em = new breeze.EntityManager({ - dataService: ds - }); - -} - -function test_entityAspect() { - var order: breeze.Entity; - order.entityAspect.acceptChanges(); - var entityKey = order.entityAspect.getKey(); - var valErrors = order.entityAspect.getValidationErrors(); - var orderDateErrors = order.entityAspect.getValidationErrors("OrderDate"); - var orderDateProperty = order.entityType.getProperty("OrderDate"); - var orderDateErrors = order.entityAspect.getValidationErrors(orderDateProperty); - order.entityAspect.loadNavigationProperty("Orders").then(function (data) { - var orders = data.results; - }).fail(function (exception) { }); - order.entityAspect.rejectChanges(); - order.entityAspect.setDeleted(); - order.entityAspect.setModified(); - order.entityAspect.setUnchanged(); - var isOk = order.entityAspect.validateEntity(); - if (!isOk) { - var errors = order.entityAspect.getValidationErrors(); - } - var isOk = order.entityAspect.validateProperty("Order"); - var orderDateProperty = order.entityType.getProperty("OrderDate"); - //var isOk = order.entityAspect.validateProperty(OrderDateProperty); - order.entityAspect.propertyChanged.subscribe(function (propertyChangedArgs) { - var entity = propertyChangedArgs.entity; - var propertyNameChanged = propertyChangedArgs.propertyName; - var oldValue = propertyChangedArgs.oldValue; - var newValue = propertyChangedArgs.newValue; - }); - order.entityAspect.validationErrorsChanged.subscribe(function (validationChangeArgs) { - var entity = validationChangeArgs.entity; - var errorsAdded = validationChangeArgs.added; - var errorsCleared = validationChangeArgs.removed; - }); - -} - -function test_entityKey() { - var em1: breeze.EntityManager; - var employee1: breeze.Entity; - var empType = em1.metadataStore.getEntityType("Employee"); - var entityKey = new breeze.EntityKey( empType, 1); - var empKey = employee1.entityAspect.getKey(); - var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory"); - var empTerrKey = new breeze.EntityKey( empTerrType, [1, 77]); - var empType = em1.metadataStore.getEntityType("Employee"); - var empKey1 = new breeze.EntityKey( empType, 1); - var empKey2 = employee1.entityAspect.getKey(); - if (empKey1.equals(empKey2)) { } - if (breeze.EntityKey.equals(empKey1, empKey2)) { } -} - -function test_metadataStore() { - var ms = new breeze.MetadataStore(); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - metadataStore: ms - }); - var em1: breeze.EntityManager; - em1.setProperties({ metadataStore: ms }); - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = new breeze.MetadataStore(); - newMetadataStore.importMetadata(metadataFromStorage); - var ms = new breeze.MetadataStore(); - ms.fetchMetadata("api/NorthwindIBModel") - .then(function (rawMetadata) { }) - .fail(function (exception) { }); - var odType = em1.metadataStore.getEntityType("OrderDetail"); - var badType = em1.metadataStore.getEntityType("Foo", false); - var allTypes = em1.metadataStore.getEntityTypes(); - if (!em1.metadataStore.hasMetadataFor("api/NorthwindIBModel")) { } - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = breeze.MetadataStore.importMetadata(metadataFromStorage); - var metadataAsString = ms.exportMetadata(); - window.localStorage.setItem("metadata", metadataAsString); - var metadataFromStorage = window.localStorage.getItem("metadata"); - var newMetadataStore = new breeze.MetadataStore(); - newMetadataStore.importMetadata(metadataFromStorage); - if (em1.metadataStore.isEmpty()) { } - var Customer = function () { - this.miscData = "asdf"; - } - em1.metadataStore.registerEntityTypeCtor("Customer", Customer); -} - -function test_entityManager() { - var entityManager = new breeze.EntityManager("api/NorthwindIBModel"); - var em1 = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - var metadataStore = new breeze.MetadataStore(); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - metadataStore: metadataStore - }); - - return new breeze.QueryOptions({ - mergeStrategy: null, - fetchStrategy: this.fetchStrategy - }); - var queryOptions = new breeze.QueryOptions({ - mergeStrategy: breeze.MergeStrategy.OverwriteChanges, - fetchStrategy: breeze.FetchStrategy.FromServer - }); - var validationOptions = new breeze.ValidationOptions({ - validateOnAttach: true, - validateOnSave: true, - validateOnQuery: false - }); - var entityManager = new breeze.EntityManager({ - serviceName: "api/NorthwindIBModel", - queryOptions: queryOptions, - validationOptions: validationOptions - }); - var custType = em1.metadataStore.getEntityType("Customer"); - var cust1 = custType.createEntity(); - em1.addEntity(cust1); - - var cust2 = em1.createEntity("Customer", { companyName: "foo" }); - var cust3 = em1.createEntity("foo", { xxx: 3 }, breeze.EntityState.Added); - - em1.attachEntity(cust1, breeze.EntityState.Added); - em1.clear(); - var em2 = em1.createEmptyCopy(); - em1.detachEntity(cust1); - var serviceName: string; - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query, - function (data) { - var orders = data.results; - }, - function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute() - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - var orders = em.executeQueryLocally(query); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(breeze.FetchStrategy.FromLocalCache); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var bundle = em1.exportEntities(); - window.localStorage.setItem("myEntityManager", bundle); - var bundleFromStorage = window.localStorage.getItem("myEntityManager"); - var em2 = new breeze.EntityManager({ - serviceName: em1.serviceName, - metadataStore: em1.metadataStore - }); - em2.importEntities(bundleFromStorage); - var entitiesToExport: breeze.Entity[]; - var bundle = em1.exportEntities(entitiesToExport); - em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); - var em1 = new breeze.EntityManager("api/NorthwindIBModel"); - em1.fetchMetadata() - .then(function () { - var metadataStore = em1.metadataStore; - }) - .fail(function (exception) { - }); - var employeeType = em1.metadataStore.getEntityType("Employee"); - var employeeKey = new breeze.EntityKey( employeeType, 1); - var employee = em1.fetchEntityByKey(employeeKey); - var emp2 = em1.fetchEntityByKey("Employee", 6); - var emp3 = em1.fetchEntityByKey("Entityee", [6]); - var custType = em1.metadataStore.getEntityType("Customer"); - var custumer = custType.createEntity(); - var customerId = em.generateTempKeyValue(custumer); - em1.saveChanges() - .then(function (data) { - var sameCust1 = data.results[0]; - }); - var changedEntities = em1.getChanges(); - var custType = em1.metadataStore.getEntityType("Customer"); - var changedCustomers = em1.getChanges(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var changedCustomersAndOrders = em1.getChanges([custType, orderType]); - var entities = em1.getEntities(); - var custType = em1.metadataStore.getEntityType("Customer"); - var customers = em1.getEntities(custType); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var customersAndOrders = em1.getChanges([custType, orderType]); - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - var addedCustomersAndOrders = em1.getEntities([custType, orderType], breeze.EntityState.Added); - if (em1.hasChanges()) { } - var custType = em1.metadataStore.getEntityType("Customer"); - if (em1.hasChanges(custType)) { } - var custType = em1.metadataStore.getEntityType("Customer"); - var orderType = em1.metadataStore.getEntityType("Order"); - if (em1.hasChanges([custType, orderType])) { }; - - var bundle = em1.exportEntities(); - window.localStorage.setItem("myEntityManager", bundle); - var bundleFromStorage = window.localStorage.getItem("myEntityManager"); - var em2 = breeze.EntityManager.importEntities(bundleFromStorage); - var bundle = em1.exportEntities(); - var em2 = new breeze.EntityManager({ - serviceName: em1.serviceName, - metadataStore: em1.metadataStore - }); - em2.importEntities(bundle); - var bundle = em1.exportEntities(); - em2.importEntities(bundle, { mergeStrategy: breeze.MergeStrategy.PreserveChanges }); - em.saveChanges().then(function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }).fail(function (e) { - }); - var saveOptions = new breeze.SaveOptions({ allowConcurrentSaves: true }); - var entitiesToSave: breeze.Entity[]; - em.saveChanges(entitiesToSave, saveOptions).then(function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }).fail(function (e) { - }); - em.saveChanges(entitiesToSave, null, - function (saveResult) { - var savedEntities = saveResult.entities; - var keyMappings = saveResult.keyMappings; - }, function (e) { } - ); - em1.setProperties({ - serviceName: "api/foo", - }); - var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - em.entityChanged.subscribe(function (changeArgs) { - var action = changeArgs.entityAction; - var entity = changeArgs.entity; - }); - var em = new breeze.EntityManager({ serviceName: "api/NorthwindIBModel" }); - em.hasChangesChanged.subscribe(function (args) { - var hasChanges = args.hasChanges; - var entityManager = args.entityManager; - }); -} - -function test_entityQuery() { - var query = new breeze.EntityQuery("Customers"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .orderBy("Region"); - var serviceName: string; - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute() - .then(function (data) { }) - .fail(function (err) { }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders").using(em); - query.execute( - function (data) { - var orders = data.results; - }, - function (err) { }); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders"); - em.executeQuery(query) - .then(function (data) { - var orders = data.results; - }).fail(function (err) { - }); - var query = new breeze.EntityQuery("Orders").using(em); - var orders = query.executeLocally(); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .expand("Orders"); - var query = new breeze.EntityQuery("Orders") - .expand("Customer, Employee"); - var query = new breeze.EntityQuery("Orders") - .expand("Customer, OrderDetails, OrderDetails.Product"); - var query = breeze.EntityQuery.from("Customers"); - var query = new breeze.EntityQuery("Customers"); - var query = new breeze.EntityQuery().from("Customers"); - var customer: breeze.Entity; - var customers: breeze.Entity[]; - var customersQuery = breeze.EntityQuery.fromEntities(customers); - var customersQuery = breeze.EntityQuery.fromEntities(customers) - .where("Region", breeze.FilterQueryOp.NotEquals, null); - var customerQuery = breeze.EntityQuery.fromEntities(customer); - var metadataStore: breeze.MetadataStore; - var empType = metadataStore.getEntityType("Employee"); - var entityKey = new breeze.EntityKey( empType, 1); - var query = breeze.EntityQuery.fromEntityKey(entityKey); - var employee: breeze.Entity; - var entityKey = employee.entityAspect.getKey(); - var query = breeze.EntityQuery.fromEntityKey(entityKey); - var ordersNavProp = employee.entityType.getProperty("Orders"); - var query = breeze.EntityQuery.fromEntityNavigation(employee, ordersNavProp); - var query = new breeze.EntityQuery("Customers") - .orderBy("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .orderBy("Region, CompanyName"); - var query = new breeze.EntityQuery("Products") - .orderBy("Category.CategoryName"); - var query = new breeze.EntityQuery("Customers") - .orderBy("CompanyName desc"); - var query = new breeze.EntityQuery("Customers") - .orderBy("Region desc, CompanyName desc"); - var query = new breeze.EntityQuery("Customers") - .orderByDesc("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("CompanyName"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("Orders"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .select("CompanyName, Orders"); - var query = new breeze.EntityQuery("Orders") - .where("Customer.CompanyName", "startsWith", "C") - .select("Customer.CompanyName, Customer, OrderDate"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C") - .skip(5); - var query = new breeze.EntityQuery("Customers") - .take(5); - var query = new breeze.EntityQuery("Customers") - .top(5); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(em); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(breeze.MergeStrategy.PreserveChanges); - var em = new breeze.EntityManager(serviceName); - var query = new breeze.EntityQuery("Orders") - .using(breeze.FetchStrategy.FromLocalCache); - var adapter = new breeze.JsonResultsAdapter({ name: "foo", visitNode: function (x) { return x; } }); - var q2 = query.using(adapter); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", "startsWith", "C"); - var query = new breeze.EntityQuery("Customers") - .where("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); - var pred = new breeze.Predicate("CompanyName", breeze.FilterQueryOp.StartsWith, "C"); - var query = new breeze.EntityQuery("Customers") - .where(pred); - var pred = breeze.Predicate.create("CompanyName", "startswith", "C").and("Region", breeze.FilterQueryOp.Equals, null); - var query = new breeze.EntityQuery("Customers") - .where(pred); - var query = new breeze.EntityQuery("Products") - .where("Category.CategoryName", "startswith", "S"); - var query = new breeze.EntityQuery("Customers") - .where("toLower(CompanyName)", "startsWith", "c"); - var query = new breeze.EntityQuery("Customers") - .where("toUpper(substring(CompanyName, 1, 2))", breeze.FilterQueryOp.Equals, "OM"); - var q2 = query.toType("foo").orderBy("foo2"); -} - -function test_entityState() { - var anEntity: breeze.Entity; - var es = anEntity.entityAspect.entityState; - return es.isAdded(); - return es === breeze.EntityState.Added; - var es = anEntity.entityAspect.entityState; - return es.isAddedModifiedOrDeleted(); - return es === breeze.EntityState.Added || es === breeze.EntityState.Modified || es === breeze.EntityState.Deleted; - var es = anEntity.entityAspect.entityState; - return es.isDeleted(); - return es === breeze.EntityState.Deleted; - var es = anEntity.entityAspect.entityState; - return es.isDetached(); - return es === breeze.EntityState.Detached; - var es = anEntity.entityAspect.entityState; - return es.isModified(); - return es === breeze.EntityState.Modified; - var es = anEntity.entityAspect.entityState; - return es.isUnchanged(); - return es === breeze.EntityState.Unchanged; - var es = anEntity.entityAspect.entityState; - return es.isUnchangedOrModified(); - - return es === breeze.EntityState.Unchanged || es === breeze.EntityState.Modified; -} - -function test_entityType() { - var myMetadataStore: breeze.MetadataStore; - var myEntityType: breeze.EntityType; - var dataProperty1, dataProperty2, navigationProperty1: breeze.DataProperty; - var em1: breeze.EntityManager; - var entityManager = new breeze.EntityType({ - metadataStore: myMetadataStore, - serviceName: "api/NorthwindIBModel", - name: "person", - namespace: "myAppNamespace" - }); - myEntityType.addProperty(dataProperty1); - myEntityType.addProperty(dataProperty2); - myEntityType.addProperty(navigationProperty1); - var custType = em1.metadataStore.getEntityType("Customer"); - var countryProp = custType.getProperty("Country"); - var valFn = function (v) { - if (v == null) return true; - return (v.substring(0,2) === "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, - { displayName: "Country", messageTemplate: "'%displayName%' must start with 'US'" }); - custType.addValidator(countryValidator, countryProp); - countryProp.validators.push(countryValidator); - var someEntityLevelValidator: breeze.Validator; - custType.addValidator(someEntityLevelValidator); - custType.validators.push(someEntityLevelValidator); - var custType = em1.metadataStore.getEntityType("Customer"); - var cust1 = custType.createEntity(); - em1.addEntity(cust1); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerNameDataProp = custType.getDataProperty("CustomerName"); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerOrdersNavProp = custType.getDataProperty("Orders"); - var custType = em1.metadataStore.getEntityType("Customer"); - var arrayOfProps = custType.getProperties(); - var custType = em1.metadataStore.getEntityType("Customer"); - var companyNameProp = custType.getProperty("CompanyName"); - var orderDetailType = em1.metadataStore.getEntityType("OrderDetail"); - var companyNameProp2 = orderDetailType.getProperty("Order.Customer.CompanyName"); - var custType = em1.metadataStore.getEntityType("Customer"); - var arrayOfPropNames = custType.getPropertyNames(); - var custType = em1.metadataStore.getEntityType("Customer"); - custType.setProperties({ - autoGeneratedKeyType: breeze.AutoGeneratedKeyType.Identity, - defaultResourceName: "CustomersAndIncludedOrders" - }); -} - -//function test_enum() { -// var prototype = { -// nextDay: function () { -// var nextIndex = (this.dayIndex + 1) % 7; -// return DayOfWeek.getSymbols()[nextIndex]; -// } -// }; -// var DayOfWeek = new core.Enum("DayOfWeek", prototype); -// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); -// var symbol = DayOfWeek.Friday; -// if (DayOfWeek.contains(symbol)) { } -// var dayOfWeek = DayOfWeek.from("Thursday"); -// var symbols = DayOfWeek.getNames(); -// var symbols = DayOfWeek.getSymbols(); -// if (core.Enum.isSymbol(DayOfWeek.Wednesday)) { }; -// DayOfWeek.seal(); -// var name = DayOfWeek.Monday.getName(); -// var name = DayOfWeek.Monday.toString(); - - -// var prototype = { -// nextDay: function () { -// var nextIndex = (this.dayIndex + 1) % 7; -// return DayOfWeek.getSymbols()[nextIndex]; -// } -// }; -// var DayOfWeek = new core.Enum("DayOfWeek", prototype); -// DayOfWeek.Monday = DayOfWeek.addSymbol({ dayIndex: 0 }); -// DayOfWeek.Tuesday = DayOfWeek.addSymbol({ dayIndex: 1 }); -// DayOfWeek.Wednesday = DayOfWeek.addSymbol({ dayIndex: 2 }); -// DayOfWeek.Thursday = DayOfWeek.addSymbol({ dayIndex: 3 }); -// DayOfWeek.Friday = DayOfWeek.addSymbol({ dayIndex: 4 }); -// DayOfWeek.Saturday = DayOfWeek.addSymbol({ dayIndex: 5, isWeekend: true }); -// DayOfWeek.Sunday = DayOfWeek.addSymbol({ dayIndex: 6, isWeekend: true }); -// DayOfWeek.seal(); -// DayOfWeek.Monday.nextDay() === DayOfWeek.Tuesday; -// DayOfWeek.Sunday.nextDay() === DayOfWeek.Monday; -// DayOfWeek.Tuesday.isWeekend === undefined; -// DayOfWeek.Saturday.isWeekend == true; -// DayOfWeek instanceof core.Enum; -// core.Enum.isSymbol(DayOfWeek.Wednesday); -// DayOfWeek.contains(DayOfWeek.Thursday); -// DayOfWeek.Tuesday.parentEnum == DayOfWeek; -// DayOfWeek.getSymbols().length === 7; -// DayOfWeek.Friday.toString() === "Friday"; -//} - -function test_event() { - var myEntityManager: breeze.EntityManager; - var myEntity, person: breeze.Entity; - var salaryEvent = new core.Event("salaryEvent", person); - core.Event.enable("propertyChanged", myEntityManager, false); - core.Event.enable("propertyChanged", myEntityManager, true); - core.Event.enable("propertyChanged", myEntity.entityAspect, false); - core.Event.enable("propertyChanged", myEntity.entityAspect, null); - core.Event.enable("validationErrorsChanged", myEntityManager, function (em) { - return em.customTag === "blue"; - }); - core.Event.isEnabled("propertyChanged", myEntityManager); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true); - salaryEvent.publish({ eventType: "payRaise", amount: 100 }, true, function (error) { }); - salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }); - salaryEvent.publishAsync({ eventType: "payRaise", amount: 100 }, function (error) { }); - salaryEvent.subscribe(function (eventArgs) { - if (eventArgs.eventType === "payRaise") { } - }); - var order: breeze.Entity; - order.entityAspect.propertyChanged.subscribe(function (pcEvent) { - if (pcEvent.propertyName === "OrderDate") { } - }); - var token = order.entityAspect.propertyChanged.subscribe(function (pcEvent) { }); - order.entityAspect.propertyChanged.unsubscribe(token); -} - -function test_localQueryComparisonOptions() { - var lqco = new breeze.LocalQueryComparisonOptions({ - name: "caseSensitive-nonSQL", - isCaseSensitive: true, - usesSql92CompliantStringComparison: false - }); - lqco.setAsDefault(); - var ms = new breeze.MetadataStore({ localQueryComparisonOptions: lqco }); - var em = new breeze.EntityManager({ metadataStore: ms }); - var lqco = new breeze.LocalQueryComparisonOptions({ - isCaseSensitive: false, - usesSql92CompliantStringComparison: true - }); - lqco.setAsDefault(); -} - -function test_namingConventions() { - var namingConv = new breeze.NamingConvention({ - serverPropertyNameToClient: function (serverPropertyName) { - return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); - }, - clientPropertyNameToServer: function (clientPropertyName) { - return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); - } - }); - var nc = new breeze.NamingConvention({ - serverPropertyNameToClient: function (x) { - return "xxx"; - } - }); - var ms = new breeze.MetadataStore({ namingConvention: namingConv }); - var em = new breeze.EntityManager({ metadataStore: ms }); - var namingConv = new breeze.NamingConvention({ - serverPropertyNameToClient: function (serverPropertyName) { - return serverPropertyName.substr(0, 1).toLowerCase() + serverPropertyName.substr(1); - }, - clientPropertyNameToServer: function (clientPropertyName) { - return clientPropertyName.substr(0, 1).toUpperCase() + clientPropertyName.substr(1); - } - }); - namingConv.setAsDefault(); -} - -function test_navigationProperty() { - var homeAddressProp = new breeze.NavigationProperty({ - name: "homeAddress", - entityTypeName: "Address:#myNamespace", - isScalar: true, - associationName: "address_person", - foreignKeyNames: ["homeAddressId"] - }); - var homeAddressIdProp = new breeze.DataProperty({ - name: "homeAddressId", - dataType: breeze.DataType.Int32 - }); - var personEntityType: breeze.EntityType; - personEntityType.addProperty(homeAddressProp); - personEntityType.addProperty(homeAddressIdProp); -} - -function test_predicate() { - var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); - var p1a = breeze.Predicate.create("CompanyName", "==", "City"); - var p2a = p1a.and(p1a.not()); - var query = new breeze.EntityQuery("Customers").where(p1); - var p2 = new breeze.Predicate("Region", breeze.FilterQueryOp.Equals, null); - var query = new breeze.EntityQuery("Customers").where(p2); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = p1.and(p2, p3); - var preds = [p2, p3]; - var newPred = p1.and(preds); - var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") - .and("Size", "gt", 2000); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = breeze.Predicate.and(p1, p2, p3); - var preds = [p1, p2, p3]; - var newPred = breeze.Predicate.and(preds); - var p1 = breeze.Predicate.create("Freight", "gt", 100); - var predArgs: any[] = ["Freight", "gt", 100]; - var p1 = breeze.Predicate.create(predArgs); - var p1 = new breeze.Predicate("Freight", "gt", 100); - var p1 = new breeze.Predicate("CompanyName", "StartsWith", "B"); - if (breeze.Predicate.isPredicate(p1)) { } - var p1 = breeze.Predicate.create("Freight", "gt", 100); - var not_p1 = breeze.Predicate.not(p1); - var not_p1 = p1.not(); - var not_p1 = breeze.Predicate.create("Freight", "le", 100); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = breeze.Predicate.or(p1, p2, p3); - var preds = [p1, p2, p3]; - var newPred = breeze.Predicate.or(preds); - var dt = new Date(88, 9, 12); - var p1 = breeze.Predicate.create("OrderDate", "ne", dt); - var p2 = breeze.Predicate.create("ShipCity", "startsWith", "C"); - var p3 = breeze.Predicate.create("Freight", ">", 100); - var newPred = p1.and(p2, p3); - var preds = [p2, p3]; - var newPred = p1.and(preds); - var p4 = breeze.Predicate.create("ShipCity", "startswith", "F") - .or("Size", "gt", 2000); -} - -function test_queryOptions() { - var em1: breeze.EntityManager; - var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); - em1.setProperties({ queryOptions: newQo }); - var newQo = new breeze.QueryOptions({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); - newQo.setAsDefault(); - var queryOptions = em1.queryOptions.using(breeze.MergeStrategy.PreserveChanges); - var queryOptions = em1.queryOptions.using(breeze.FetchStrategy.FromLocalCache); - var queryOptions = em1.queryOptions.using({ mergeStrategy: breeze.MergeStrategy.OverwriteChanges }); -} - -function test_validationOptions() { - var newVo = new breeze.ValidationOptions({ validateOnSave: false, validateOnAttach: false }); - var em1: breeze.EntityManager; - em1.setProperties({ validationOptions: newVo }); - var validationOptions = new breeze.ValidationOptions() - var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); - newOptions.setAsDefault(); - var validationOptions = new breeze.ValidationOptions(); - var newOptions = validationOptions.using({ validateOnQuery: true, validateOnSave: false }); -} - -function test_validator() { - var valFn = function (v) { - if (v == null) return true; - return ( v.substr(0,2)=== "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, { - displayName: "Country", - messageTemplate: "'%displayName%' must start with 'US'" - }); - var metadataStore: breeze.MetadataStore; - var custType = metadataStore.getEntityType("Customer"); - var countryProp = custType.getProperty("Country"); - countryProp.validators.push(countryValidator); - function isValidZipCode(value) { - var re = /^\d{5}([\-]\d{4})?$/; - return (re.test(value)); - } - var valFn = function (v) { - if (v.getProperty("Country") === "USA") { - var postalCode = v.getProperty("PostalCode"); - return isValidZipCode(postalCode); - } - return true; - }; - var zipCodeValidator = new breeze.Validator("zipCodeValidator", valFn, - { messageTemplate: "For the US, this is not a valid PostalCode" }); - var em1: breeze.EntityManager; - var custType = em1.metadataStore.getEntityType("Customer"); - custType.validators.push(zipCodeValidator); - var numericRangeValidator = function (context) { - var valFn = function (v, ctx) { - if (v == null) return true; - if (typeof (v) !== "number") return false; - if (ctx.min != null && v < ctx.min) return false; - if (ctx.max != null && v > ctx.max) return false; - return true; - }; - return new breeze.Validator("numericRange", valFn, { - messageTemplate: "'%displayName%' must be an integer between the values of %min% and %max%", - min: context.min, - max: context.max - }); - }; - freightProperty.validators.push(numericRangeValidator({ min: 100, max: 500 })); - var productType = em1.metadataStore.getEntityType("Product"); - var discontinuedProperty = productType.getProperty("Discontinued"); - discontinuedProperty.validators.push(breeze.Validator.bool()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - regionProperty.validators.push(breeze.Validator.byte()); - var orderType = em1.metadataStore.getEntityType("Order"); - var orderDateProperty = orderType.getProperty("OrderDate"); - orderDateProperty.validators.push(breeze.Validator.date()); - var v0 = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); - v0.validate("adasdfasdf"); - var errMessage = v0.getMessage(); - var custType = em1.metadataStore.getEntityType("Customer"); - var customerIdProperty = custType.getProperty("CustomerID"); - customerIdProperty.validators.push(breeze.Validator.guid()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int16()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int32()); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.int64()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.maxLength({ maxLength: 5 })); - var orderType = em1.metadataStore.getEntityType("Order"); - var freightProperty = orderType.getProperty("Freight"); - freightProperty.validators.push(breeze.Validator.number()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.required()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.string()); - var custType = em1.metadataStore.getEntityType("Customer"); - var regionProperty = custType.getProperty("Region"); - regionProperty.validators.push(breeze.Validator.stringLength({ minLength: 2, maxLength: 5 })); - var validator = breeze.Validator.maxLength({ maxLength: 5, displayName: "City" }); - var result = validator.validate("asdf"); - var ok = result === null; - result = validator.validate("adasdfasdf"); - var errMsg = result.errorMessage; - var context = result.context; - var sameValidator = result.validator; - var valFn = function (v) { - if (v == null) return true; - return (v.substr(0,2) === "US"); - }; - var countryValidator = new breeze.Validator("countryIsUS", valFn, { displayName: "Country" }); - breeze.Validator.messageTemplates["countryIsUS"] = "'%displayName%' must start with 'US'"; -} - -function test_demo() { - - var manager = new breeze.EntityManager('api/northwind'); - - var query = new breeze.EntityQuery() - .from("Employees"); - - manager.executeQuery(query).then(function (data) { }); -} \ No newline at end of file diff --git a/breeze/breeze-1.2-tests.ts.tscparams b/breeze/breeze-1.2-tests.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/breeze/breeze-1.2-tests.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/breeze/breeze-1.2.d.ts b/breeze/breeze-1.2.d.ts deleted file mode 100644 index 264b36431..000000000 --- a/breeze/breeze-1.2.d.ts +++ /dev/null @@ -1,779 +0,0 @@ -// Type definitions for Breeze 1.2.7 -// Project: http://www.breezejs.com/ -// Definitions by: Boris Yankov , -// IdeaBlade -// Definitions: https://github.com/borisyankov/DefinitelyTyped - -// Updated March 27 2013 - John Lantz (www.ideablade.com) - - -declare module breezeCore { - - interface ErrorCallback { - (error: Error): void; - } - - interface IEnum { - contains(object: any): boolean; - fromName(name: string): EnumSymbol; - getNames(): string[]; - getSymbols(): EnumSymbol[]; - } - - class Enum implements IEnum { - constructor (name: string, methodObj?: any); - - addSymbol(propertiesObj?: any): EnumSymbol; - contains(object: any): boolean; - fromName(name: string): EnumSymbol; - getNames(): string[]; - getSymbols(): EnumSymbol[]; - static isSymbol(object: any): boolean; - seal(): void; - } - - class EnumSymbol { - parentEnum: IEnum; - - getName(): string; - toString(): string; - } - - class Event { - constructor (name: string, publisher: any, defaultErrorCallback?: ErrorCallback); - - static enable(eventName: string, target: any): void; - static enable(eventName: string, target: any, isEnabled: boolean): void; - static enable(eventName: string, target: any, isEnabled: Function): void; - - static isEnabled(eventName: string, target: any): boolean; - publish(data: any, publishAsync?: boolean, errorCallback?: ErrorCallback): void; - publishAsync(data: any, errorCallback?: ErrorCallback): void; - subscribe(callback?: (data: any) => void ): number; - unsubscribe(unsubKey: number): boolean; - } -} - -declare module breeze { - - interface Entity { - entityAspect: EntityAspect; - entityType: EntityType; - } - - interface ComplexObject { - complexAspect: ComplexAspect; - complexType: ComplexType; - } - - interface IProperty { - name: string; - parentEntityType: EntityType; - validators: Validator[]; - isDataProperty: boolean; - isNavigationProperty: boolean; - } - - interface IStructuralType { - complexProperties: DataProperty[]; - dataProperties: DataProperty[]; - name: string; - namespace: string; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - } - - class AutoGeneratedKeyType { - static Identity: AutoGeneratedKeyType; - static KeyGenerator: AutoGeneratedKeyType; - static None: AutoGeneratedKeyType; - } - - class ComplexAspect { - complexObject: ComplexObject; - entityAspect: EntityAspect; - parent: Object; - parentProperty: DataProperty; - propertyPath: string; - originalValues: Object; - } - - class ComplexType implements IStructuralType { - complexProperties: DataProperty[]; - dataProperties: DataProperty[]; - name: string; - namespace: string; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - addProperty(dataProperty: DataProperty); - getProperties(): DataProperty[]; - } - - class DataProperty implements IProperty { - complexTypeName: string; - concurrencyMode: string; - dataType: DataTypeSymbol; - defaultValue: any; - fixedLength: boolean; - isComplexProperty: boolean; - isDataProperty: boolean; - isNavigationProperty: boolean; - isNullable: boolean; - isPartOfKey: boolean; - isUnmapped: boolean; - - maxLength: number; - name: string; - nameOnServer: string; - parentEntityType: EntityType; - relatedNavigationProperty: NavigationProperty; - validators: Validator[]; - constructor (config: DataPropertyOptions); - } - - interface DataPropertyOptions { - complexTypeName?: string; - concurrencyMode?: string; - dataType?: DataTypeSymbol; - defaultValue?: any; - fixedLength?: boolean; - isNullable?: boolean; - isPartOfKey?: boolean; - isUnmapped?: boolean; - maxLength?: number; - name?: string; - nameOnServer?: string; - validators?: Validator[]; - } - - class DataService { - adapterName: string; - hasServerMetadata: boolean; - serviceName: string; - jsonResultsAdapter: JsonResultsAdapter; - constructor(config: DataServiceOptions); - } - - interface DataServiceOptions { - adapterName?: string; - hasServerMetadata?: boolean; - serviceName?: string; - jsonResultsAdapter?: JsonResultsAdapter; - } - - class JsonResultsAdapter { - name: string; - extractResults: (data: {}) => {}; - visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; }; - constructor(config: { - name: string; - extractResults?: (data: {}) => {}; - visitNode: (node: {}, queryContext: QueryContext, nodeContext: NodeContext) => { entityType?: EntityType; nodeId?: any; nodeRefId?: any; ignore?: boolean; }; - }); - } - - interface QueryContext { - query: any; // how to also say it could be an EntityQuery or a string - entityManager: EntityManager; - jsonResultsAdapter: JsonResultsAdapter; - mergeStrategy: MergeStrategy; - } - - interface NodeContext { - nodeType: string; - } - - - - class DataTypeSymbol extends breezeCore.EnumSymbol { - defaultValue: any; - isNumeric: boolean; - } - interface DataType extends breezeCore.IEnum { - Binary: DataTypeSymbol; - Boolean: DataTypeSymbol; - Byte: DataTypeSymbol; - DateTime: DataTypeSymbol; - Decimal: DataTypeSymbol; - Double: DataTypeSymbol; - Guid: DataTypeSymbol; - Int16: DataTypeSymbol; - Int32: DataTypeSymbol; - Int64: DataTypeSymbol; - Single: DataTypeSymbol; - String: DataTypeSymbol; - Time: DataTypeSymbol; - Undefined: DataTypeSymbol; - toDataType(typeName: string): DataTypeSymbol; - parseDateFromServer(date: any): Date; - - } - var DataType: DataType; - - class EntityActionSymbol extends breezeCore.EnumSymbol { - } - interface EntityAction extends breezeCore.IEnum { - AcceptChanges: EntityActionSymbol; - Attach: EntityActionSymbol; - AttachOnImport: EntityActionSymbol; - AttachOnQuery: EntityActionSymbol; - Clear: EntityActionSymbol; - Detach: EntityActionSymbol; - EntityStateChange: EntityActionSymbol; - MergeOnImport: EntityActionSymbol; - MergeOnSave: EntityActionSymbol; - MergeOnQuery: EntityActionSymbol; - PropertyChange: EntityActionSymbol; - RejectChanges: EntityActionSymbol; - } - var EntityAction: EntityAction; - - class EntityAspect { - entity: Entity; - entityManager: EntityManager; - entityState: EntityStateSymbol; - isBeingSaved: boolean; - originalValues: any; - - propertyChanged: PropertyChangedEvent; - validationErrorsChanged: ValidationErrorsChangedEvent; - - acceptChanges(): void; - addValidationError(validationError: ValidationError): void; - clearValidationErrors(): void; - getKey(forceRefresh?: boolean): EntityKey; - - getValidationErrors(): ValidationError[]; - getValidationErrors(property: string): ValidationError[]; - getValidationErrors(property: IProperty): ValidationError[]; - - loadNavigationProperty(navigationProperty: string, callback?: Function, errorCallback?: Function): Promise; - loadNavigationProperty(navigationProperty: NavigationProperty, callback?: Function, errorCallback?: Function): Promise; - - rejectChanges(): void; - - removeValidationError(validator: Validator): void; - removeValidationError(validator: Validator, property: DataProperty): void; - removeValidationError(validator: Validator, property: NavigationProperty): void; - - setDeleted(): void; - setModified(): void; - setUnchanged(): void; - setDetached(): boolean; - validateEntity(): boolean; - - validateProperty(property: string, context?: any): boolean; - validateProperty(property: DataProperty, context?: any): boolean; - validateProperty(property: NavigationProperty, context?: any): boolean; - } - - class PropertyChangedEventArgs { - entity: Entity; - propertyName: string; - oldValue: any; - newValue: any; - } - - class PropertyChangedEvent extends breezeCore.Event { - subscribe(callback?: (data: PropertyChangedEventArgs) => void ): number; - } - - class ValidationErrorsChangedEventArgs { - entity: Entity; - added: ValidationError[]; - removed: ValidationError[]; - } - - class ValidationErrorsChangedEvent extends breezeCore.Event { - subscribe(callback?: (data: ValidationErrorsChangedEventArgs) => void ): number; - } - - class EntityKey { - constructor (entityType: EntityType, keyValue: any); - constructor (entityType: EntityType, keyValues: any[]); - - equals(entityKey: EntityKey): boolean; - static equals(k1: EntityKey, k2: EntityKey): boolean; - } - - class EntityManager { - dataService: DataService; - keyGeneratorCtor: Function; - metadataStore: MetadataStore; - queryOptions: QueryOptions; - saveOptions: SaveOptions; - serviceName: string; - validationOptions: ValidationOptions; - - entityChanged: EntityChangedEvent; - hasChangesChanged: HasChangesChangedEvent; - - constructor (config?: EntityManagerOptions); - constructor (config?: string); - - addEntity(entity: Entity): Entity; - attachEntity(entity: Entity, entityState?: EntityStateSymbol): Entity; - clear(): void; - createEmptyCopy(): EntityManager; - createEntity(typeName: string, config?: {}, entityState?: EntityStateSymbol) : Entity; - detachEntity(entity: Entity): boolean; - executeQuery(query: string, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - executeQuery(query: EntityQuery, callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - - executeQueryLocally(query: EntityQuery): Entity[]; - exportEntities(entities?: Entity[]): string; - fetchEntityByKey(typeName: string, keyValue: any, checkLocalCacheFirst?: boolean): Promise; - fetchEntityByKey(typeName: string, keyValues: any[], checkLocalCacheFirst?: boolean): Promise; - fetchEntityByKey(entityKey: EntityKey): Promise; - fetchMetadata(callback?: (schema: any) => void , errorCallback?: breezeCore.ErrorCallback): Promise; - generateTempKeyValue(entity: Entity): any; - getChanges(): Entity[]; - getChanges(entityTypeName: string): Entity[]; - getChanges(entityTypeNames: string[]): Entity[]; - getChanges(entityType: EntityType): Entity[]; - getChanges(entityTypes: EntityType[]): Entity[]; - - getEntities(entityTypeName: string, entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypeNames?: string[], entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypeName?: string, entityStates?: EntityStateSymbol[]): Entity[]; - getEntities(entityTypeNames?: string[], entityStates?: EntityStateSymbol[]): Entity[]; - - getEntities(entityType: EntityType, entityState?: EntityStateSymbol): Entity[]; - getEntities(entityTypes?: EntityType[], entityState?: EntityStateSymbol): Entity[]; - getEntities(entityType?: EntityType, entityStates?: EntityStateSymbol[]): Entity[]; - getEntities(entityTypes?: EntityType[], entityStates?: EntityStateSymbol[]): Entity[]; - - getEntityByKey(typeName: string, keyValue: any): Entity; - getEntityByKey(typeName: string, keyValues: any[]): Entity; - getEntityByKey(entityKey: EntityKey): Entity; - - hasChanges(): boolean; - hasChanges(entityTypeName: string): boolean; - hasChanges(entityTypeNames: string[]): boolean; - hasChanges(entityType: EntityType): boolean; - hasChanges(entityTypes: EntityType[]): boolean; - - static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - importEntities(exportedString: any, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - - rejectChanges(): Entity[]; - saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Promise; - setProperties(config: EntityManagerProperties): void; - - helper: { - unwrapInstance(structObj: Entity, isOData: boolean): any; - unwrapOriginalValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any; - unwrapChangedValues(target: Entity, metadataStore: MetadataStore, isOData: boolean): any; - getEntityKeyFromRawEntity(rawEntity: any, entityType: EntityType, isClient: boolean): EntityKey; - }; - } - - interface EntityManagerOptions { - serviceName?: string; - dataService?: DataService; - metadataStore?: MetadataStore; - queryOptions?: QueryOptions; - saveOptions?: SaveOptions; - validationOptions?: ValidationOptions; - keyGeneratorCtor?: Function; - } - - interface EntityManagerProperties { - serviceName?: string; - dataService?: DataService; - queryOptions?: QueryOptions; - saveOptions?: SaveOptions; - validationOptions?: ValidationOptions; - keyGeneratorCtor?: Function; - } - - interface ExecuteQuerySuccessCallback { - (data: { results: Entity[]; query: EntityQuery; XHR: XMLHttpRequest; }): void; - } - - interface ExecuteQueryErrorCallback { - (error: { query: EntityQuery; XHR: XMLHttpRequest; }): void; - } - - interface SaveChangesSuccessCallback { - (saveResult: { entities: Entity[]; keyMappings: any; XHR: XMLHttpRequest; }): void; - } - - interface SaveChangesErrorCallback { - (error: { XHR: XMLHttpRequest; }): void; - } - - class EntityChangedEventArgs { - entity: Entity; - entityAction: EntityActionSymbol; - args: Object; - } - - class EntityChangedEvent extends breezeCore.Event { - subscribe(callback?: (data: EntityChangedEventArgs) => void ): number; - } - - class HasChangesChangedEventArgs { - entityManager: EntityManager; - hasChanges: boolean; - } - - class HasChangesChangedEvent extends breezeCore.Event { - subscribe(callback?: (data: HasChangesChangedEventArgs) => void ): number; - } - - class EntityQuery { - entityManager: EntityManager; - orderByClause: OrderByClause; - parameters: Object; - queryOptions: QueryOptions; - resourceName: string; - skipCount: number; - takeCount: number; - wherePredicate: Predicate; - - constructor (resourceName?: string); - - execute(callback?: ExecuteQuerySuccessCallback, errorCallback?: ExecuteQueryErrorCallback): Promise; - executeLocally(): Entity[]; - expand(propertyPaths: string[]): EntityQuery; - expand(propertyPaths: string): EntityQuery; - static from(resourceName: string): EntityQuery; - from(resourceName: string): EntityQuery; - static fromEntities(entity: Entity): EntityQuery; - static fromEntities(entities: Entity[]): EntityQuery; - static fromEntityKey(entityKey: EntityKey): EntityQuery; - static fromEntityNavigation(entity: Entity, navigationProperty: NavigationProperty): EntityQuery; - inlineCount(enabled?: boolean): EntityQuery; - orderBy(propertyPaths: string): EntityQuery; - orderBy(propertyPaths: string[]): EntityQuery; - orderByDesc(propertyPaths: string): EntityQuery; - orderByDesc(propertyPaths: string[]): EntityQuery; - select(propertyPaths: string): EntityQuery; - select(propertyPaths: string[]): EntityQuery; - skip(count: number): EntityQuery; - take(count: number): EntityQuery; - top(count: number): EntityQuery; - toType(typeName: string): EntityQuery; - toType(type: EntityType): EntityQuery; - - using(obj: EntityManager): EntityQuery; - using(obj: MergeStrategySymbol): EntityQuery; - using(obj: FetchStrategySymbol): EntityQuery; - using(obj: JsonResultsAdapter): EntityQuery; - - where(predicate: Predicate): EntityQuery; - where(property: string, operator: string, value: any): EntityQuery; - where(property: string, operator: FilterQueryOpSymbol, value: any): EntityQuery; - where(predicate: FilterQueryOpSymbol): EntityQuery; - withParameters(params: Object): EntityQuery; - } - - interface OrderByClause { - } - - class EntityStateSymbol extends breezeCore.EnumSymbol { - isAdded(): boolean; - isAddedModifiedOrDeleted(): boolean; - isDeleted(): boolean; - isDetached(): boolean; - isModified(): boolean; - isUnchanged(): boolean; - isUnchangedOrModified(): boolean; - } - interface EntityState extends breezeCore.IEnum { - Added: EntityStateSymbol; - Deleted: EntityStateSymbol; - Detached: EntityStateSymbol; - Modified: EntityStateSymbol; - Unchanged: EntityStateSymbol; - } - var EntityState: EntityState; - - class EntityType implements IStructuralType { - autoGeneratedKeyType: AutoGeneratedKeyType; - complexProperties: DataProperty[]; - concurrencyProperties: DataProperty[]; - dataProperties: DataProperty[]; - defaultResourceName: string; - foreignKeyProperties: DataProperty[]; - keyProperties: DataProperty[]; - metadataStore: MetadataStore; - name: string; - namespace: string; - navigationProperties: NavigationProperty[]; - shortName: string; - unmappedProperties: DataProperty[]; - validators: Validator[]; - - constructor (config: MetadataStore); - constructor (config: EntityTypeOptions); - - addProperty(property: IProperty): void; - addValidator(validator: Validator, property?: IProperty): void; - createEntity(initialValues?: Object): Entity; - getDataProperty(propertyName: string): DataProperty; - getEntityCtor(): Function; - getNavigationProperty(propertyName: string): NavigationProperty; - getProperties(): IProperty[]; - getProperty(propertyPath: string, throwIfNotFound?: boolean): IProperty; - getPropertyNames(): string[]; - setProperties(config: EntityTypeProperties): void; - toString(): string; - } - - interface EntityTypeOptions { - shortName?: string; - namespace?: string; - autogeneratedKeyType?: AutoGeneratedKeyType; - defaultResourceName?: string; - } - - interface EntityTypeProperties { - autogeneratedKeyType?: AutoGeneratedKeyType; - defaultResourceName?: string; - } - - class FetchStrategySymbol extends breezeCore.EnumSymbol { - } - interface FetchStrategy extends breezeCore.IEnum { - FromLocalCache: FetchStrategySymbol; - FromServer: FetchStrategySymbol; - } - var FetchStrategy: FetchStrategy; - - class FilterQueryOpSymbol extends breezeCore.EnumSymbol { - } - interface FilterQueryOp extends breezeCore.IEnum { - Contains: FilterQueryOpSymbol; - EndsWith: FilterQueryOpSymbol; - Equals: FilterQueryOpSymbol; - GreaterThan: FilterQueryOpSymbol; - GreaterThanOrEqual: FilterQueryOpSymbol; - LessThan: FilterQueryOpSymbol; - LessThanOrEqual: FilterQueryOpSymbol; - NotEquals: FilterQueryOpSymbol; - StartsWith: FilterQueryOpSymbol; - } - var FilterQueryOp: FilterQueryOp; - - class LocalQueryComparisonOptions { - static caseInsensitiveSQL: LocalQueryComparisonOptions; - static defaultInstance: LocalQueryComparisonOptions; - - constructor (config: { name?: string; isCaseSensitive?: boolean; usesSql92CompliantStringComparison?: boolean; }); - - setAsDefault(): void; - } - - class MergeStrategySymbol extends breezeCore.EnumSymbol { - } - interface MergeStrategy extends breezeCore.IEnum { - OverwriteChanges: MergeStrategySymbol; - PreserveChanges: MergeStrategySymbol; - } - var MergeStrategy: MergeStrategy; - - class MetadataStore { - namingConvention: NamingConvention; - - constructor (config?: MetadataStoreOptions); - addDataService(dataService: DataService): void; - addEntityType(structuralType: IStructuralType): void; - exportMetadata(): string; - fetchMetadata(dataService: string, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise; - fetchMetadata(dataService: DataService, callback?: (data) => void , errorCallback?: breezeCore.ErrorCallback): Promise; - getDataService(serviceName: string): DataService; - getEntityType(entityTypeName: string, okIfNotFound?: boolean): IStructuralType; - getEntityTypes(): IStructuralType[]; - hasMetadataFor(serviceName: string): boolean; - static importMetadata(exportedString: string): MetadataStore; - importMetadata(exportedString: string): MetadataStore; - isEmpty(): boolean; - registerEntityTypeCtor(entityTypeName: string, entityCtor: Function, initializationFn?: (entity: Entity) =>void ): void; - trackUnmappedType(entityCtor: Function, interceptor?: Function); - setEntityTypeForResourceName(resourceName: string, entityTypeOrName: string): void; - } - - interface MetadataStoreOptions { - namingConvention?: NamingConvention; - localQueryComparisonOptions?: LocalQueryComparisonOptions; - } - - class NamingConvention { - static camelCase: NamingConvention; - static defaultInstance: NamingConvention; - static none: NamingConvention; - name: string; - - constructor (config: NamingConventionOptions); - - clientPropertyNameToServer(clientPropertyName: string): string; - clientPropertyNameToServer(clientPropertyName: string, property: IProperty): string; - - serverPropertyNameToClient(serverPropertyName: string): string; - serverPropertyNameToClient(serverPropertyName: string, property: IProperty): string; - - setAsDefault(); - } - - interface NamingConventionOptions { - serverPropertyNameToClient?: (name: string) => string; - clientPropertyNameToServer?: (name: string) => string; - } - - class NavigationProperty implements IProperty { - associationName: string; - entityType: EntityType; - foreignKeyNames: string[]; - inverse: NavigationProperty; - isDataProperty: boolean; - isNavigationProperty: boolean; - isScalar: boolean; - name: string; - parentEntityType: EntityType; - relatedDataProperties: DataProperty[]; - validators: Validator[]; - - constructor (config: NavigationPropertyOptions); - } - - interface NavigationPropertyOptions { - name?: string; - nameOnServer?: string; - entityTypeName: string; - isScalar?: boolean; - associationName?: string; - foreignKeyNames?: string[]; - foreignKeyNamesOnServer?: string[]; - validators?: Validator[]; - } - - class Predicate { - constructor (property: string, operator: string, value: any, valueIsLiteral?: boolean); - constructor (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean); - - and: PredicateMethod; - static and: PredicateMethod; - - static create: PredicateMethod; - - static isPredicate(o: any): boolean; - - static not(predicate: Predicate): Predicate; - not(): Predicate; - - static or: PredicateMethod; - or: PredicateMethod; - - toFunction(): Function; - toString(): string; - validate(entityType: EntityType): void; - } - - interface PredicateMethod { - (predicates: Predicate[]): Predicate; - (...predicates: Predicate[]): Predicate; - (property: string, operator: string, value: any, valueIsLiteral?: boolean): Predicate; - (property: string, operator: FilterQueryOpSymbol, value: any, valueIsLiteral?: boolean): Predicate; - } - - class Promise { - fail(errorCallback: Function): Promise; - fin(finallyCallback: Function): Promise; - then(callback: Function): Promise; - } - - class QueryOptions { - static defaultInstance: QueryOptions; - fetchStrategy: FetchStrategySymbol; - mergeStrategy: MergeStrategySymbol; - - constructor (config?: QueryOptionsConfiguration); - - setAsDefault(): void; - using(config: QueryOptionsConfiguration): QueryOptions; - using(config: MergeStrategySymbol): QueryOptions; - using(config: FetchStrategySymbol): QueryOptions; - } - - interface QueryOptionsConfiguration { - fetchStrategy?: FetchStrategySymbol; - mergeStrategy?: MergeStrategySymbol; - } - - class SaveOptions { - allowConcurrentSaves: boolean; - static defaultInstance: SaveOptions; - - constructor (config?: { allowConcurrentSaves?: boolean; }); - - setAsDefault(): SaveOptions; - } - - class ValidationError { - context: any; - errorMessage: string; - property: IProperty; - propertyName: string; - validator: Validator; - - constructor (validator: Validator, context: any, errorMessage: string); - } - - class ValidationOptions { - static defaultInstance: ValidationOptions; - validateOnAttach: boolean; - validateOnPropertyChange: boolean; - validateOnQuery: boolean; - validateOnSave: boolean; - - constructor (config?: ValidationOptionsConfiguration); - - setAsDefault(): ValidationOptions; - using(config: ValidationOptionsConfiguration): ValidationOptions; - } - - interface ValidationOptionsConfiguration { - validateOnAttach?: boolean; - validateOnSave?: boolean; - validateOnQuery?: boolean; - validateOnPropertyChange?: boolean; - } - - class Validator { - static messageTemplates: any; - - constructor (name: string, validatorFn: ValidatorFunction, context?: any); - - static bool(): Validator; - static byte(): Validator; - static date(): Validator; - static duration(): Validator; - getMessage(): string; - static guid(): Validator; - static int16(): Validator; - static int32(): Validator; - static int64(): Validator; - static maxLength(context: { maxLength: number; }): Validator; - static number(): Validator; - static required(): Validator; - static string(): Validator; - static stringLength(context: { maxLength: number; minLength: number; }): Validator; - validate(value: any, context?: any): ValidationError; - } - - interface ValidatorFunction { - (value: any, context: ValidatorFunctionContext): void; - } - - interface ValidatorFunctionContext { - value: any; - validatorName: string; - displayName: string; - messageTemplate: string; - message?: string; - } -} \ No newline at end of file diff --git a/breeze/breeze-1.2.d.ts.tscparams b/breeze/breeze-1.2.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/breeze/breeze-1.2.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/breeze/breeze.d.ts b/breeze/breeze.d.ts index 7e37c7dac..438b3d5b8 100644 --- a/breeze/breeze.d.ts +++ b/breeze/breeze.d.ts @@ -71,7 +71,7 @@ declare module breeze.core { export function requireLib(libnames: string, errMessage: string): Object; export function using(obj: Object, property: string, tempValue: any, fn: () => any): any; - export function memoize(fn:(...any) => any): any; + export function memoize(fn:Function): any; export function getUuid(): string; export function durationToSeconds(duration: string): number; @@ -416,10 +416,10 @@ declare module breeze { hasChanges(entityType: EntityType): boolean; hasChanges(entityTypes: EntityType[]): boolean; - static importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - static importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - importEntities(exportedString: string, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; - importEntities(exportedData: Object, config?: { mergeStrategy?: MergeStrategySymbol; }): EntityManager; + static importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; + static importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; + importEntities(exportedString: string, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; + importEntities(exportedData: Object, config?: { mergeStrategy?: StrategySymbol; }): EntityManager; rejectChanges(): Entity[]; saveChanges(entities?: Entity[], saveOptions?: SaveOptions, callback?: SaveChangesSuccessCallback, errorCallback?: SaveChangesErrorCallback): Q.Promise; @@ -520,8 +520,7 @@ declare module breeze { using(obj: DataService): EntityQuery; using(obj: JsonResultsAdapter): EntityQuery; using(obj: QueryOptions): EntityQuery; - using(obj: MergeStrategySymbol): EntityQuery; - using(obj: FetchStrategySymbol): EntityQuery; + using(obj: StrategySymbol): EntityQuery; where(predicate: Predicate): EntityQuery; where(property: string, operator: string, value: any): EntityQuery; @@ -599,13 +598,10 @@ declare module breeze { interface EntityTypeProperties { autoGeneratedKeyType?: AutoGeneratedKeyType; defaultResourceName?: string; - } - - class FetchStrategySymbol extends breeze.core.EnumSymbol { - } + } interface FetchStrategy extends breeze.core.IEnum { - FromLocalCache: FetchStrategySymbol; - FromServer: FetchStrategySymbol; + FromLocalCache: StrategySymbol; + FromServer: StrategySymbol; } var FetchStrategy: FetchStrategy; @@ -634,11 +630,11 @@ declare module breeze { setAsDefault(): void; } - class MergeStrategySymbol extends breeze.core.EnumSymbol { + class StrategySymbol extends breeze.core.EnumSymbol { } interface MergeStrategy extends breeze.core.IEnum { - OverwriteChanges: MergeStrategySymbol; - PreserveChanges: MergeStrategySymbol; + OverwriteChanges: StrategySymbol; + PreserveChanges: StrategySymbol; } var MergeStrategy: MergeStrategy; @@ -749,20 +745,19 @@ declare module breeze { class QueryOptions { static defaultInstance: QueryOptions; - fetchStrategy: FetchStrategySymbol; - mergeStrategy: MergeStrategySymbol; + fetchStrategy: StrategySymbol; + mergeStrategy: StrategySymbol; constructor (config?: QueryOptionsConfiguration); setAsDefault(): void; using(config: QueryOptionsConfiguration): QueryOptions; - using(config: MergeStrategySymbol): QueryOptions; - using(config: FetchStrategySymbol): QueryOptions; + using(config: StrategySymbol): QueryOptions; } interface QueryOptionsConfiguration { - fetchStrategy?: FetchStrategySymbol; - mergeStrategy?: MergeStrategySymbol; + fetchStrategy?: StrategySymbol; + mergeStrategy?: StrategySymbol; } interface QueryResult { diff --git a/browser-harness/browser-harness.d.ts b/browser-harness/browser-harness.d.ts index 8c410b94a..73eda812c 100644 --- a/browser-harness/browser-harness.d.ts +++ b/browser-harness/browser-harness.d.ts @@ -6,28 +6,28 @@ /// declare module "browser-harness" { - import events = require("events"); + import nodeEvents = require("events"); - interface HarnessEvents extends events.NodeEventEmitter { - once(event: string, listener: (driver: Driver) => void): events.NodeEventEmitter; - once(event: 'ready', listener: (driver: Driver) => void): events.NodeEventEmitter; + interface HarnessEvents extends nodeEvents.NodeEventEmitter { + once(event: string, listener: (driver: Driver) => void): nodeEvents.NodeEventEmitter; + once(event: 'ready', listener: (driver: Driver) => void): nodeEvents.NodeEventEmitter; - on(event: string, listener: (driver: Driver) => void): events.NodeEventEmitter; - on(event: 'ready', listener: (driver: Driver) => void): events.NodeEventEmitter; + on(event: string, listener: (driver: Driver) => void): nodeEvents.NodeEventEmitter; + on(event: 'ready', listener: (driver: Driver) => void): nodeEvents.NodeEventEmitter; } - interface DriverEvents extends events.NodeEventEmitter { - once(event: string, listener: (text: string) => void): events.NodeEventEmitter; - once(event: 'console.log', listener: (text: string) => void): events.NodeEventEmitter; - once(event: 'console.warn', listener: (text: string) => void): events.NodeEventEmitter; - once(event: 'console.error', listener: (text: string) => void): events.NodeEventEmitter; - once(event: 'window.onerror', listener: (text: string) => void): events.NodeEventEmitter; + interface DriverEvents extends nodeEvents.NodeEventEmitter { + once(event: string, listener: (text: string) => void): nodeEvents.NodeEventEmitter; + once(event: 'console.log', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + once(event: 'console.warn', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + once(event: 'console.error', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + once(event: 'window.onerror', listener: (text: string) => void): nodeEvents.NodeEventEmitter; - on(event: string, listener: (text: string) => void): events.NodeEventEmitter; - on(event: 'console.log', listener: (text: string) => void): events.NodeEventEmitter; - on(event: 'console.warn', listener: (text: string) => void): events.NodeEventEmitter; - on(event: 'console.error', listener: (text: string) => void): events.NodeEventEmitter; - on(event: 'window.onerror', listener: (text: string) => void): events.NodeEventEmitter; + on(event: string, listener: (text: string) => void): nodeEvents.NodeEventEmitter; + on(event: 'console.log', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + on(event: 'console.warn', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + on(event: 'console.error', listener: (text: string) => void): nodeEvents.NodeEventEmitter; + on(event: 'window.onerror', listener: (text: string) => void): nodeEvents.NodeEventEmitter; } export interface Driver { diff --git a/commander/commander-tests.ts b/commander/commander-tests.ts index eff20f28d..495426edd 100644 --- a/commander/commander-tests.ts +++ b/commander/commander-tests.ts @@ -18,7 +18,7 @@ program program .command('setup [env]') .description('run setup commands for all envs') - .action(function (env) { + .action(function (env?) { env = env || 'all'; console.log('setup for %s env(s)', env); }); @@ -27,7 +27,7 @@ program // $ deploy production program .command('*') - .action(function (env) { + .action(function (env?) { console.log('deploying "%s"', env); }); diff --git a/couchbase/couchbase-tests.ts b/couchbase/couchbase-tests.ts index f4d1b1061..4305300ee 100644 --- a/couchbase/couchbase-tests.ts +++ b/couchbase/couchbase-tests.ts @@ -4,10 +4,14 @@ import couchbase = require('couchbase'); var db = new couchbase.Connection({ bucket: "default" }, function (err) { if (err) throw err; - db.set('testdoc', { name: 'Frank' }, function (err, result) { - if (err) throw err; + // TS 0.9.5 bug https://typescript.codeplex.com/workitem/2035, todo: remove cast after fix + (db).set('testdoc', { name: 'Frank' }, function (err, result) { + if (err) throw err; - db.get('testdoc', function (err, result) { + var s: string = err.message; + + // TS 0.9.5 bug https://typescript.codeplex.com/workitem/2035, todo: remove cast after fix + (db).get('testdoc', function (err, result) { if (err) throw err; console.log(result.value); diff --git a/crossfilter/crossfilter-tests.ts b/crossfilter/crossfilter-tests.ts index 222096566..745ed3aa4 100644 --- a/crossfilter/crossfilter-tests.ts +++ b/crossfilter/crossfilter-tests.ts @@ -44,28 +44,30 @@ paymentsByTotal.filterFunction(d => 0 <= d && d < 10 || 20 <= d && d < 30); paymentsByTotal.filterAll(); // selects all payments var topPayments = paymentsByTotal.top(4); // the top four payments, by total -topPayments[0]; // the biggest payment +{var p: Payment = topPayments[0];} // the biggest payment topPayments[1]; // the second-biggest payment var allPayments = paymentsByTotal.top(Infinity); var bottomPayments = paymentsByTotal.bottom(4); // the bottom four payments, by total -bottomPayments[0]; // the smallest payment +{var p: Payment = bottomPayments[0];} // the smallest payment bottomPayments[1]; // the second-smallest payment var paymentGroupsByTotal = paymentsByTotal.group(total => Math.floor(total / 100)); paymentGroupsByTotal.size(); -paymentGroupsByTotal.reduce((p, v) => p + 1, (p, v) => p - 1, () => 0); +// bug of TS 0.9.5 https://typescript.codeplex.com/discussions/471751 +//paymentGroupsByTotal.reduce((p, v) => p + 1, (p, v) => p - 1, () => 0); +paymentGroupsByTotal.reduce((p, v) => p + 1, (p, v) => p - 1, () => 0); paymentGroupsByTotal.reduceCount(); var paymentsByType = payments.dimension(d => d.type), paymentVolumeByType = paymentsByType.group().reduceSum(d => d.total), topTypes = paymentVolumeByType.top(1); -topTypes[0].key; // the top payment type (e.g., "tab") -topTypes[0].value; // the payment volume for that type (e.g., 900) +{var s: string = topTypes[0].key;} // the top payment type (e.g., "tab") +{var n: number = topTypes[0].value;} // the payment volume for that type (e.g., 900) interface Group { count: number; @@ -101,7 +103,7 @@ topTotals[0].value; // reduced value for that type (e.g., {count:8, total:920}) paymentGroupsByTotal.orderNatural(); -var paymentCountByType = paymentsByType.group(); +var paymentCountByType = paymentsByType.group().reduceCount(); topTypes = paymentCountByType.top(1); topTypes[0].key; // the top payment type (e.g., "tab") topTypes[0].value; // the count of payments of that type (e.g., 8) diff --git a/crossfilter/crossfilter.d.ts b/crossfilter/crossfilter.d.ts index e01cf1fcb..c98d20867 100644 --- a/crossfilter/crossfilter.d.ts +++ b/crossfilter/crossfilter.d.ts @@ -102,8 +102,8 @@ declare module CrossFilter { top(k: number): T[]; bottom(k: number): T[]; dispose(): void; - group(): Group; - group(groupValue: (data: T) => TGroup): Group; + group(): Group; + group(groupValue: (data: TDimension) => TGroup): Group; groupAll(): GroupAll; } } diff --git a/cryptojs/cryptojs.d.ts b/cryptojs/cryptojs.d.ts index fc52995b6..c0773525c 100644 --- a/cryptojs/cryptojs.d.ts +++ b/cryptojs/cryptojs.d.ts @@ -88,8 +88,8 @@ declare module CryptoJS{ createEncryptor(key: WordArray, cfg?: C): ICipher createDecryptor(key: WordArray, cfg?: C): ICipher - create(xformMode: number, key: WordArray, cfg?: C): ICipher - init(xformMode: number, key: WordArray, cfg?: C): void + create(xformMode?: number, key?: WordArray, cfg?: C): ICipher + init(xformMode?: number, key?: WordArray, cfg?: C): void process(dataUpdate: WordArray): WordArray process(dataUpdate: string): WordArray @@ -110,7 +110,7 @@ declare module CryptoJS{ createEncryptor(key: WordArray, cfg?: C): IStreamCipher createDecryptor(key: WordArray, cfg?: C): IStreamCipher - create(xformMode: number, key: WordArray, cfg?: C): IStreamCipher + create(xformMode?: number, key?: WordArray, cfg?: C): IStreamCipher blockSize: number } @@ -119,8 +119,8 @@ declare module CryptoJS{ interface BlockCipherMode extends Base{ createEncryptor(cipher: Cipher, iv: number[]): mode.IBlockCipherEncryptor createDecryptor(cipher: Cipher, iv: number[]): mode.IBlockCipherDecryptor - init(cipher: Cipher, iv: number[]): void - create(cipher: Cipher, iv: number[]): BlockCipherMode + init(cipher?: Cipher, iv?: number[]): void + create(cipher?: Cipher, iv?: number[]): BlockCipherMode } //BlockCipher has interface same as IStreamCipher @@ -144,8 +144,8 @@ declare module CryptoJS{ } interface CipherParams extends Base, CipherParamsData{ - init(cipherParams: CipherParamsData): void - create(cipherParams: CipherParamsData): CipherParams + init(cipherParams?: CipherParamsData): void + create(cipherParams?: CipherParamsData): CipherParams toString(formatter?: format.IFormatter): string } @@ -279,7 +279,7 @@ declare module CryptoJS{ createEncryptor(key: lib.WordArray, cfg?: lib.IBlockCipherCfg): IBlockCipherImpl createDecryptor(key: lib.WordArray, cfg?: lib.IBlockCipherCfg): IBlockCipherImpl - create(xformMode: number, key: lib.WordArray, cfg?: lib.IBlockCipherCfg): IBlockCipherImpl + create(xformMode?: number, key?: lib.WordArray, cfg?: lib.IBlockCipherCfg): IBlockCipherImpl } interface AES extends IBlockCipherImpl{} @@ -304,10 +304,10 @@ declare module CryptoJS{ } interface HMAC extends lib.Base{ - init(hasher: lib.Hasher, key: lib.WordArray): void - init(hasher: lib.Hasher, key: string): void - create(hasher: lib.Hasher, key: lib.WordArray): HMAC - create(hasher: lib.Hasher, key: string): HMAC + init(hasher?: lib.Hasher, key?: lib.WordArray): void + init(hasher?: lib.Hasher, key?: string): void + create(hasher?: lib.Hasher, key?: lib.WordArray): HMAC + create(hasher?: lib.Hasher, key?: string): HMAC update(messageUpdate: lib.WordArray): HMAC update(messageUpdate: string): HMAC @@ -407,8 +407,8 @@ declare module CryptoJS{ high: number low: number - init(high: number, low: number): void - create(high: number, low: number): Word + init(high?: number, low?: number): void + create(high?: number, low?: number): Word } interface WordArray extends lib.Base{ diff --git a/cryptojs/test/aes-tests.ts b/cryptojs/test/aes-tests.ts index eaef25447..d4f0d9537 100644 --- a/cryptojs/test/aes-tests.ts +++ b/cryptojs/test/aes-tests.ts @@ -63,9 +63,9 @@ YUI.add('algo-aes-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/des-tests.ts b/cryptojs/test/des-tests.ts index 5e18608e0..d889abab1 100644 --- a/cryptojs/test/des-tests.ts +++ b/cryptojs/test/des-tests.ts @@ -87,9 +87,9 @@ YUI.add('algo-des-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/pad-iso10126-tests.ts b/cryptojs/test/pad-iso10126-tests.ts index de46f7d81..2961c9a32 100644 --- a/cryptojs/test/pad-iso10126-tests.ts +++ b/cryptojs/test/pad-iso10126-tests.ts @@ -15,9 +15,9 @@ YUI.add('pad-iso10126-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/rabbit-legacy-tests.ts b/cryptojs/test/rabbit-legacy-tests.ts index 658d62b25..30f368717 100644 --- a/cryptojs/test/rabbit-legacy-tests.ts +++ b/cryptojs/test/rabbit-legacy-tests.ts @@ -63,9 +63,9 @@ YUI.add('algo-rabbit-legacy-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/rabbit-tests.ts b/cryptojs/test/rabbit-tests.ts index e8e0d3e3c..a5690face 100644 --- a/cryptojs/test/rabbit-tests.ts +++ b/cryptojs/test/rabbit-tests.ts @@ -67,9 +67,9 @@ YUI.add('algo-rabbit-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/rc4-tests.ts b/cryptojs/test/rc4-tests.ts index 5a4e5aa6f..a827c0921 100644 --- a/cryptojs/test/rc4-tests.ts +++ b/cryptojs/test/rc4-tests.ts @@ -51,9 +51,9 @@ YUI.add('algo-rc4-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/cryptojs/test/tripledes-tests.ts b/cryptojs/test/tripledes-tests.ts index 2227d3710..cbc123ea3 100644 --- a/cryptojs/test/tripledes-tests.ts +++ b/cryptojs/test/tripledes-tests.ts @@ -71,9 +71,9 @@ YUI.add('algo-tripledes-test', function (Y) { // Replace random method with one that returns a predictable value C.lib.WordArray.random = function (nBytes) { - var words = []; + var words: number[] = []; for (var i = 0; i < nBytes; i += 4) { - words.push([0x11223344]); + words.push(0x11223344); } return C.lib.WordArray.create(words, nBytes); diff --git a/dhtmlxgantt/dhtmlxgantt-tests.ts b/dhtmlxgantt/dhtmlxgantt-tests.ts index 0b491ce2b..1bfc7a089 100644 --- a/dhtmlxgantt/dhtmlxgantt-tests.ts +++ b/dhtmlxgantt/dhtmlxgantt-tests.ts @@ -28,6 +28,6 @@ gantt.init("scheduler_here", start); gantt.load("/data/events"); //events -gantt.attachEvent("onBeforeLightbox", function (id: string) { +gantt.attachEvent("onBeforeLightbox", function (id?: string) { gantt.showTask(id); }); \ No newline at end of file diff --git a/dhtmlxscheduler/dhtmlxscheduler-tests.ts b/dhtmlxscheduler/dhtmlxscheduler-tests.ts index d526a1eaf..2f1f2d9ce 100644 --- a/dhtmlxscheduler/dhtmlxscheduler-tests.ts +++ b/dhtmlxscheduler/dhtmlxscheduler-tests.ts @@ -28,6 +28,6 @@ scheduler.init("scheduler_here", start); scheduler.load("/data/events"); //events -scheduler.attachEvent("onEmptyClick", function (ev: Event) { +scheduler.attachEvent("onEmptyClick", function (ev?: Event) { var date: Date = scheduler.getActionData(ev).date; }); \ No newline at end of file diff --git a/easeljs/easeljs.d.ts b/easeljs/easeljs.d.ts index efbdad8f3..dd1563083 100644 --- a/easeljs/easeljs.d.ts +++ b/easeljs/easeljs.d.ts @@ -140,7 +140,7 @@ declare module createjs { toArray(): number[]; // implements Array interface start - concat(...items: ColorMatrix[]): number[]; + concat(...items: ColorMatrix[]): number[]; join(separator?: string): string; pop(): number; push(...items: number[]): number; @@ -162,8 +162,9 @@ declare module createjs { reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; reduce(callbackfn: (previousValue: ColorMatrix, currentValue: number, currentIndex: number, array: number[]) => ColorMatrix, initialValue: ColorMatrix): ColorMatrix; reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue?: number): number; - reduceRight(callbackfn: (previousValue: ColorMatrix, currentValue: number, currentIndex: number, array: number[]) => ColorMatrix, initialValue: ColorMatrix): ColorMatrix; + reduceRight(callbackfn: (previousValue: ColorMatrix, currentValue: number, currentIndex: number, array: number[]) => ColorMatrix, initialValue: ColorMatrix): ColorMatrix; length: number; + [n: number]: number; // implements Array interface end } diff --git a/expect.js/expect.js.d.ts b/expect.js/expect.js.d.ts index 82f85b19d..e19f769b6 100644 --- a/expect.js/expect.js.d.ts +++ b/expect.js/expect.js.d.ts @@ -17,14 +17,14 @@ declare module Expect { * * @param fn callback to match error string against */ - throwError(fn?: Function): void; + throwError(fn?: (exception: any) => void): void; /** * Assert that the function throws. * * @param fn callback to match error string against */ - throwException(fn?: Function): void; + throwException(fn?: (exception: any) => void): void; /** * Assert that the function throws. diff --git a/extjs/ExtJS-4.2.0.d.ts b/extjs/ExtJS-4.2.0.d.ts deleted file mode 100644 index b051ac34d..000000000 --- a/extjs/ExtJS-4.2.0.d.ts +++ /dev/null @@ -1,30521 +0,0 @@ -// Type definitions for ExtJS 4.2.0 -// Project: http://www.sencha.com/products/extjs/ -// Definitions by: Brian Kotek -// Definitions: https://github.com/borisyankov/DefinitelyTyped - -declare module Ext { - export interface IAbstractComponent extends Ext.IBase,Ext.state.IStateful,Ext.util.IAnimate,Ext.util.IElementContainer,Ext.util.IObservable,Ext.util.IPositionable,Ext.util.IRenderable { - /** [Config Option] (String/Object) A tag name or DomHelper spec used to create the Element which will encapsulate this Component. ... */ - autoEl?: any; - /** [Config Option] (Ext.ComponentLoader/Object/String/Boolean) An alias for loader config which also allows to specify just a string which will be used as the url that's automatica... */ - autoLoad?: any; - /** [Config Option] (Boolean/String/HTMLElement/Ext.Element) This config is intended mainly for non-floating Components which may or may not be shown. ... */ - autoRender?: any; - /** [Config Option] (Boolean) true to automatically show the component upon creation. ... */ - autoShow?: boolean; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (Object[]) An array describing the child elements of the Component. ... */ - childEls?: Object[]; - /** [Config Option] (String) An optional extra CSS class that will be added to this component's Element. ... */ - cls?: string; - /** [Config Option] (String) */ - componentCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) Specify an existing HTML element, or the id of an existing HTML element to use as the content for this component. ... */ - contentEl?: string; - /** [Config Option] (Object) */ - data?: any; - /** [Config Option] (Boolean) true to disable the component. ... */ - disabled?: boolean; - /** [Config Option] (String) CSS class to add when the Component is disabled. ... */ - disabledCls?: string; - /** [Config Option] (Boolean) Allows the component to be dragged. ... */ - draggable?: boolean; - /** [Config Option] (Boolean) Create the Component as a floating and use absolute positioning. ... */ - floating?: boolean; - /** [Config Option] (Boolean) Specify as true to have the Component inject framing elements within the Component at render time to provide a graphi... */ - frame?: boolean; - /** [Config Option] (Number) */ - height?: number; - /** [Config Option] (Boolean) true to hide the component. ... */ - hidden?: boolean; - /** [Config Option] (String) A String which specifies how this Component's encapsulating DOM element will be hidden. ... */ - hideMode?: string; - /** [Config Option] (String/Object) An HTML fragment, or a DomHelper specification to use as the layout element content. ... */ - html?: any; - /** [Config Option] (String) The unique id of this component instance. ... */ - id?: string; - /** [Config Option] (String) An itemId can be used as an alternative way to get a reference to a component when no object reference is available. ... */ - itemId?: string; - /** [Config Option] (Ext.ComponentLoader/Object) A configuration object or an instance of a Ext.ComponentLoader to load remote content for this Component. ... */ - loader?: any; - /** [Config Option] (Number/String) Specifies the margin for this component. ... */ - margin?: any; - /** [Config Option] (Number) The maximum value in pixels which this Component will set its height to. ... */ - maxHeight?: number; - /** [Config Option] (Number) The maximum value in pixels which this Component will set its width to. ... */ - maxWidth?: number; - /** [Config Option] (Number) The minimum value in pixels which this Component will set its height to. ... */ - minHeight?: number; - /** [Config Option] (Number) The minimum value in pixels which this Component will set its width to. ... */ - minWidth?: number; - /** [Config Option] (String) An optional extra CSS class that will be added to this component's Element when the mouse moves over the Element, and... */ - overCls?: string; - /** [Config Option] (Number/String) Specifies the padding for this component. ... */ - padding?: any; - /** [Config Option] (Ext.AbstractPlugin[]/Ext.AbstractPlugin/Object[]/Object/Ext.enums.Plugin[]/Ext.enums.Plugin) An array of plugins to be added to this component. ... */ - plugins?: any; - /** [Config Option] (Object) The data used by renderTpl in addition to the following property values of the component: id ui uiCls baseCls compo... */ - renderData?: any; - /** [Config Option] (Object) An object containing properties specifying DomQuery selectors which identify child elements created by the render pro... */ - renderSelectors?: any; - /** [Config Option] (String/HTMLElement/Ext.Element) Specify the id of the element, a DOM element or an existing Element that this component will be rendered into. ... */ - renderTo?: any; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Boolean) True to layout this component and its descendants in "rtl" (right-to-left) mode. ... */ - rtl?: boolean; - /** [Config Option] (Boolean/Number) If this property is a number, it is interpreted as follows: 0: Neither width nor height depend on content. ... */ - shrinkWrap?: any; - /** [Config Option] (String/Object) A custom style specification to be applied to this component's Element. ... */ - style?: any; - /** [Config Option] (Ext.XTemplate/Ext.Template/String/String[]) An Ext.Template, Ext.XTemplate or an array of strings to form an Ext.XTemplate. ... */ - tpl?: any; - /** [Config Option] (String) The Ext.(X)Template method to use when updating the content area of the Component. ... */ - tplWriteMode?: string; - /** [Config Option] (String) A UI style for a component. ... */ - ui?: string; - /** [Config Option] (Number) */ - width?: number; - /** [Config Option] (Ext.enums.Widget) This property provides a shorter alternative to creating objects than using a full class name. ... */ - xtype?: Ext.enums.IWidget; - /** [Property] (Boolean) Setting this property to true causes the isLayoutRoot method to return true and stop the search for the top-most comp... */ - _isLayoutRoot?: boolean; - /** [Property] (String) The name of the padding property that is used by the layout to manage padding. ... */ - contentPaddingProperty?: string; - /** [Property] (Object) Indicates the width of any framing elements which were added within the encapsulating element to provide graphical, r... */ - frameSize?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Component, or subclass thereof. ... */ - isComponent?: boolean; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Property] (Ext.Container) This Component's owner Container (is set automatically when this Component is added to a Container). ... */ - ownerCt?: Ext.IContainer; - /** [Property] (Boolean) Indicates whether or not the component has been rendered. ... */ - rendered?: boolean; - /** [Method] Adds each argument passed to this method to the childEls array */ - addChildEls?(): void; - /** [Method] Adds a CSS class to the top level element representing this component - * @param cls any The CSS class name to add. - */ - addCls?( cls?:any ): any; - addCls?( cls?:string ): Ext.IComponent; - addCls?( cls?:string[] ): Ext.IComponent; - /** [Method] Adds a cls to the uiCls array which will also call addUIClsToElement and adds to all elements of this component - * @param classes String A string or an array of strings to add to the uiCls. - * @param skip Object (Boolean) skip true to skip adding it to the class and do it later (via the return). - */ - addClsWithUI?( classes?:string, skip?:any ): void; - addClsWithUI?( classes?:string[], skip?:any ): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Save a property to the given state object if it is not its default or configured value - * @param state Object The state object. - * @param propName String The name of the property on this object to save. - * @param value String The value of the state property (defaults to this[propName]). - */ - addPropertyToState?( state?:any, propName?:string, value?:string ): boolean; - /** [Method] Add events that will trigger the state to be saved - * @param events String The event name or an array of event names. - */ - addStateEvents?( events?:string ): void; - addStateEvents?( events?:string[] ): void; - /** [Method] Method which adds a specified UI uiCls to the components element - * @param ui String The UI to remove from the element. - */ - addUIClsToElement?( ui?:string ): void; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Template method called after a Component has been positioned - * @param x Number - * @param y Number - */ - afterSetPosition?( x?:number, y?:number ): void; - /** [Method] Aligns the element with another element relative to the specified anchor points - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - * @param animate any true for the default animation or a standard Element animation config object - */ - alignTo?( element?:any, position?:any, offsets?:any, animate?:any ): any; - alignTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - alignTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - alignTo?( element?:string, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - /** [Method] Anchors an element to another element and realigns it when the window is resized - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - * @param animate any true for the default animation or a standard Element animation config object - * @param monitorScroll any True to monitor body scroll and reposition. If this parameter is a number, it is used as the buffer delay in milliseconds. - * @param callback any The function to call after the animation finishes - */ - anchorTo?( element?:any, position?:any, offsets?:any, animate?:any, monitorScroll?:any, callback?:any ): any; - anchorTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:string, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:string, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - /** [Method] Performs custom animation on this object. ... */ - animate?: any; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Occurs before componentLayout is run - * @param adjWidth Number The box-adjusted width that was set. - * @param adjHeight Number The box-adjusted height that was set. - */ - beforeComponentLayout?( adjWidth?:number, adjHeight?:number ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Template method to do any pre focus processing - * @param e Ext.IEventObject The event object - */ - beforeFocus?( e?:Ext.IEventObject ): void; - /** [Method] Occurs before componentLayout is run */ - beforeLayout?(): void; - /** [Method] Calculates the new x y position to move this Positionable into a constrain region - * @param constrainTo any The Element or Region into which this Component is to be constrained. Defaults to the element into which this Positionable was rendered, or this Component's {@link Ext.Component.constrainTo. - * @param proposedPosition any A proposed [X, Y] position to test for validity and to coerce into constraints instead of using this Positionable's current position. - * @param local any The proposedPosition is local (relative to floatParent if a floating Component) - * @param proposedSize any A proposed [width, height] size to use when calculating constraints instead of using this Positionable's current size. - */ - calculateConstrainedPosition?( constrainTo?:any, proposedPosition?:any, local?:any, proposedSize?:any ): any; - calculateConstrainedPosition?( constrainTo?:string, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:HTMLElement, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:Ext.IElement, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:Ext.util.IRegion, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Destroys the Component */ - destroy?(): void; - /** [Method] Disable the component - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): void; - /** [Method] Handles autoRender */ - doAutoRender?(): void; - /** [Method] This method needs to be called whenever you change something on this component that requires the Component s layout t */ - doComponentLayout?(): Ext.container.IContainer; - /** [Method] Enable the component - * @param silent Boolean Passing true will suppress the enable event from being fired. - */ - enable?( silent?:boolean ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Ensures that this component is attached to document body - * @param runLayout Boolean True to run the component's layout. - */ - ensureAttachedToBody?( runLayout?:boolean ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the current animation if this object has any effects actively running or queued else returns false */ - getActiveAnimation?(): any; - /** [Method] Gets the x y coordinates to align this element with another element - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - */ - getAlignToXY?( element?:any, position?:any, offsets?:any ): any; - getAlignToXY?( element?:Ext.util.IPositionable, position?:string, offsets?:number[] ): number[]; - getAlignToXY?( element?:HTMLElement, position?:string, offsets?:number[] ): number[]; - getAlignToXY?( element?:string, position?:string, offsets?:number[] ): number[]; - /** [Method] Gets the x y coordinates specified by the anchor position on the element - * @param anchor String The specified anchor position. See alignTo for details on supported anchor positions. - * @param local Boolean True to get the local (element top/left-relative) anchor position instead of page coordinates - * @param size Object An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size) - */ - getAnchorXY?( anchor?:string, local?:boolean, size?:any ): number[]; - /** [Method] Return an object defining the area of this Element which can be passed to setBox to set another Element s size locati - * @param contentBox Boolean If true a box for the content of the element is returned. - * @param local Boolean If true the element's left and top relative to its offsetParent are returned instead of page x/y. - */ - getBox?( contentBox?:boolean, local?:boolean ): any; - /** [Method] Provides the link for Observable s fireEvent method to bubble up the ownership hierarchy */ - getBubbleTarget?(): Ext.container.IContainer; - /** [Method] Returns the X Y vector by which this Positionable s element must be translated to make a best attempt to constrain - * @param constrainTo any The Positionable, HTMLElement, element id, or Region into which the element is to be constrained. - * @param proposedPosition any A proposed [X, Y] position to test for validity and to produce a vector for instead of using the element's current position - * @param proposedSize any A proposed [width, height] size to constrain instead of using the element's current size - */ - getConstrainVector?( constrainTo?:any, proposedPosition?:any, proposedSize?:any ): any; - getConstrainVector?( constrainTo?:Ext.util.IPositionable, proposedPosition?:number[], proposedSize?:number[] ): any; - getConstrainVector?( constrainTo?:HTMLElement, proposedPosition?:number[], proposedSize?:number[] ): any; - getConstrainVector?( constrainTo?:string, proposedPosition?:number[], proposedSize?:number[] ): any; - getConstrainVector?( constrainTo?:Ext.util.IRegion, proposedPosition?:number[], proposedSize?:number[] ): any; - /** [Method] Retrieves the top level element representing this component */ - getEl?(): Ext.dom.IElement; - /** [Method] Gets the current height of the component s underlying element */ - getHeight?(): number; - /** [Method] Retrieves the id of this component */ - getId?(): string; - /** [Method] This function takes the position argument passed to onRender and returns a DOM element that you can use in the insert - * @param position any Index, element id or element you want to put this component before. - */ - getInsertPosition?( position?:any ): any; - getInsertPosition?( position?:string ): HTMLElement; - getInsertPosition?( position?:number ): HTMLElement; - getInsertPosition?( position?:Ext.dom.IElement ): HTMLElement; - getInsertPosition?( position?:HTMLElement ): HTMLElement; - /** [Method] Returns the value of itemId assigned to this component or when that is not set returns the value of id */ - getItemId?(): string; - /** [Method] Gets the Ext ComponentLoader for this Component */ - getLoader?(): Ext.IComponentLoader; - /** [Method] Overridden in Ext rtl AbstractComponent */ - getLocalX?(): number; - /** [Method] Overridden in Ext rtl AbstractComponent */ - getLocalXY?(): number[]; - /** [Method] Returns the y coordinate of this element reletive to its offsetParent */ - getLocalY?(): number; - /** [Method] Returns the offsets of this element from the passed element - * @param offsetsTo any The Positionable, HTMLElement, or element id to get get the offsets from. - */ - getOffsetsTo?( offsetsTo?:any ): any; - getOffsetsTo?( offsetsTo?:Ext.util.IPositionable ): number[]; - getOffsetsTo?( offsetsTo?:HTMLElement ): number[]; - getOffsetsTo?( offsetsTo?:string ): number[]; - /** [Method] Retrieves a plugin by its pluginId which has been bound to this component - * @param pluginId String - */ - getPlugin?( pluginId?:string ): Ext.IAbstractPlugin; - /** [Method] Returns a region object that defines the area of this element */ - getRegion?(): Ext.util.IRegion; - /** [Method] Gets the current size of the component s underlying element */ - getSize?(): any; - /** [Method] Returns an object that describes how this component s width and height are managed - * @param ownerCtSizeModel Object - */ - getSizeModel?( ownerCtSizeModel?:any ): any; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Returns the content region of this element */ - getViewRegion?(): Ext.util.IRegion; - /** [Method] Gets the current width of the component s underlying element */ - getWidth?(): number; - /** [Method] Gets the current X position of the DOM element based on page coordinates */ - getX?(): number; - /** [Method] Returns this Component s xtype hierarchy as a slash delimited string */ - getXTypes?(): string; - /** [Method] Gets the current position of the DOM element based on page coordinates */ - getXY?(): number[]; - /** [Method] Gets the current Y position of the DOM element based on page coordinates */ - getY?(): number; - /** [Method] Checks if the specified CSS class exists on this element s DOM node - * @param className String The CSS class to check for. - */ - hasCls?( className?:string ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Checks if there is currently a specified uiCls - * @param cls String The cls to check. - */ - hasUICls?( cls?:string ): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Tests whether this Component matches the selector string - * @param selector String The selector string to test against. - */ - is?( selector?:string ): boolean; - /** [Method] Determines whether this component is the descendant of a particular container - * @param container Ext.IContainer - */ - isDescendantOf?( container?:Ext.IContainer ): boolean; - /** [Method] Method to determine whether this Component is currently disabled */ - isDisabled?(): boolean; - /** [Method] Method to determine whether this Component is draggable */ - isDraggable?(): boolean; - /** [Method] Method to determine whether this Component is droppable */ - isDroppable?(): boolean; - /** [Method] Method to determine whether this Component is floating */ - isFloating?(): boolean; - /** [Method] Method to determine whether this Component is currently set to hidden */ - isHidden?(): boolean; - /** [Method] Determines whether this Component is the root of a layout */ - isLayoutRoot?(): void; - /** [Method] Returns true if layout is suspended for this component */ - isLayoutSuspended?(): boolean; - /** [Method] Returns true if this component is visible - * @param deep Boolean Pass true to interrogate the visibility status of all parent Containers to determine whether this Component is truly visible to the user. Generally, to determine whether a Component is hidden, the no argument form is needed. For example when creating dynamically laid out UIs in a hidden Container before showing them. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Tests whether or not this Component is of a specific xtype - * @param xtype String The xtype to check for this Component - * @param shallow Boolean true to check whether this Component is directly of the specified xtype, false to check whether this Component is descended from the xtype. - */ - isXType?( xtype?:string, shallow?:boolean ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Move the element relative to its current position - * @param direction String Possible values are: "l" (or "left") "r" (or "right") "t" (or "top", or "up") "b" (or "bottom", or "down") - * @param distance Number How far to move the element in pixels - * @param animate any true for the default animation or a standard Element animation config object - */ - move?( direction?:string, distance?:number, animate?:any ): void; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Returns the next node in the Component tree in tree traversal order - * @param selector String A ComponentQuery selector to filter the following nodes. - */ - nextNode?( selector?:string ): Ext.IComponent; - /** [Method] Returns the next sibling of this Component - * @param selector String A ComponentQuery selector to filter the following items. - */ - nextSibling?( selector?:string ): Ext.IComponent; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Method to manage awareness of when components are added to their respective Container firing an added event - * @param container Ext.container.IContainer Container which holds the component. - * @param pos Number Position at which the component was added. - */ - onAdded?( container?:Ext.container.IContainer, pos?:number ): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] Called after the component is moved this method is empty by default but can be implemented by any subclass that need - * @param x Number The new x position. - * @param y Number The new y position. - */ - onPosition?( x?:number, y?:number ): void; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the resize operation - * @param width Object - * @param height Object - * @param oldWidth Object - * @param oldHeight Object - */ - onResize?( width?:any, height?:any, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Returns the previous node in the Component tree in tree traversal order - * @param selector String A ComponentQuery selector to filter the preceding nodes. - */ - previousNode?( selector?:string ): Ext.IComponent; - /** [Method] Returns the previous sibling of this Component - * @param selector String A ComponentQuery selector to filter the preceding items. - */ - previousSibling?( selector?:string ): Ext.IComponent; - /** [Method] Called by Component doAutoRender Register a Container configured floating true with this Component s ZIndexManager - * @param cmp Object - */ - registerFloatingItem?( cmp?:any ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Remove any anchor to this element */ - removeAnchor?(): Ext.util.IPositionable; - /** [Method] Removes items in the childEls array based on the return value of a supplied test function - * @param testFn Function The test function. - */ - removeChildEls?( testFn?:any ): void; - /** [Method] Removes a CSS class from the top level element representing this component - * @param cls any The CSS class name to remove. - */ - removeCls?( cls?:any ): any; - removeCls?( cls?:string ): Ext.IComponent; - removeCls?( cls?:string[] ): Ext.IComponent; - /** [Method] Removes a cls to the uiCls array which will also call removeUIClsFromElement and removes it from all elements of thi - * @param cls String A string or an array of strings to remove to the uiCls. - */ - removeClsWithUI?( cls?:string ): void; - removeClsWithUI?( cls?:string[] ): void; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Method which removes a specified UI uiCls from the components element - * @param ui String The UI to add to the element. - */ - removeUIClsFromElement?( ui?:string ): void; - /** [Method] Renders the Component into the passed HTML element - * @param container Ext.IElement The element this Component should be rendered into. If it is being created from existing markup, this should be omitted. - * @param position String The element ID or DOM node index within the container before which this component will be inserted (defaults to appending to the end of the container) - */ - render?( container?:Ext.IElement, position?:string ): void; - render?( container?:HTMLElement, position?:string ): void; - render?( container?:string, position?:string ): void; - render?( container?:Ext.IElement, position?:number ): void; - render?( container?:HTMLElement, position?:number ): void; - render?( container?:string, position?:number ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Conditionally saves a single property from this object to the given state object - * @param propName String The name of the property to save. - * @param state Object The state object in to which to save the property. - * @param stateName String The name to use for the property in state. - */ - savePropToState?( propName?:string, state?:any, stateName?:string ): boolean; - /** [Method] Gathers additional named properties of the instance and adds their current values to the passed state object - * @param propNames any The name (or array of names) of the property to save. - * @param state any The state object in to which to save the property values. - */ - savePropsToState?( propNames?:any, state?:any ): any; - savePropsToState?( propNames?:string, state?:any ): any; - savePropsToState?( propNames?:string[], state?:any ): any; - /** [Method] Saves the state of the object to the persistence store */ - saveState?(): void; - /** [Method] Ensures that all effects queued after sequenceFx is called on this object are run in sequence */ - sequenceFx?(): any; - /** [Method] - * @param border String The border, see border. If a falsey value is passed the border will be removed. - */ - setBorder?( border?:string ): void; - setBorder?( border?:number ): void; - /** [Method] Sets the element s box - * @param box Object The box to fill {x, y, width, height} - * @param animate any true for the default animation or a standard Element animation config object - */ - setBox?( box?:any, animate?:any ): Ext.util.IPositionable; - /** [Method] Enable or disable the component - * @param disabled Boolean true to disable. - */ - setDisabled?( disabled?:boolean ): void; - /** [Method] Sets the dock position of this component in its parent panel - * @param dock Object The dock position. - * @param layoutParent Boolean true to re-layout parent. - */ - setDocked?( dock?:any, layoutParent?:boolean ): Ext.IComponent; - /** [Method] Sets the height of the component - * @param height Number The new height to set. This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. undefined to leave the height unchanged. - */ - setHeight?( height?:number ): Ext.IComponent; - /** [Method] Overridden in Ext rtl AbstractComponent - * @param x Number The x coordinate. A value of null sets the left style to 'auto'. - */ - setLocalX?( x?:number ): Ext.util.IPositionable; - /** [Method] Overridden in Ext rtl AbstractComponent - * @param x any The x coordinate or an array containing [x, y]. A value of null sets the left style to 'auto' - * @param y any The y coordinate, required if x is not an array. A value of null sets the top style to 'auto' - */ - setLocalXY?( x?:any, y?:any ): any; - setLocalXY?( x?:number, y?:number ): Ext.util.IPositionable; - setLocalXY?( x?:any[], y?:number ): Ext.util.IPositionable; - /** [Method] Sets the local y coordinate of this element using CSS style - * @param y Number The y coordinate. A value of null sets the top style to 'auto'. - */ - setLocalY?( y?:number ): Ext.util.IPositionable; - /** [Method] Sets the margin on the target element - * @param margin Number The margin to set. See the margin config. - */ - setMargin?( margin?:number ): void; - setMargin?( margin?:string ): void; - /** [Method] Sets the element s position and size to the specified region - * @param region Ext.util.IRegion The region to fill - * @param animate any true for the default animation or a standard Element animation config object - */ - setRegion?( region?:Ext.util.IRegion, animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the width and height of this Component - * @param width any The new width to set. This may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. A size object in the format {width: widthValue, height: heightValue}. undefined to leave the width unchanged. - * @param height any The new height to set (not required if a size object is passed as the first arg). This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. undefined to leave the height unchanged. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:any, height?:number ): Ext.IComponent; - setSize?( width?:any, height?:string ): Ext.IComponent; - /** [Method] Sets the UI for the component - * @param ui String The new UI for the component. - */ - setUI?( ui?:string ): void; - /** [Method] Convenience function to hide or show this component by Boolean - * @param visible Boolean true to show, false to hide. - */ - setVisible?( visible?:boolean ): Ext.IComponent; - /** [Method] Sets the width of the component - * @param width Number The new width to setThis may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. - */ - setWidth?( width?:number ): Ext.IComponent; - /** [Method] Sets the X position of the DOM element based on page coordinates - * @param The Number X position - * @param animate any True for the default animation, or a standard Element animation config object - */ - setX?( The?:number, animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the position of the DOM element in page coordinates - * @param pos Number[] Contains X & Y [x, y] values for new position (coordinates are page-based) - * @param animate any True for the default animation, or a standard Element animation config object - */ - setXY?( pos?:number[], animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the Y position of the DOM element based on page coordinates - * @param The Number Y position - * @param animate any True for the default animation, or a standard Element animation config object - */ - setY?( The?:number, animate?:any ): Ext.util.IPositionable; - /** [Method] Stops any running effects and clears this object s internal effects queue if it contains any additional effects that */ - stopAnimation?(): Ext.IElement; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Ensures that all effects queued after syncFx is called on this object are run concurrently */ - syncFx?(): any; - /** [Method] Translates the passed page coordinates into left top css values for the element - * @param x any The page x or an array containing [x, y] - * @param y any The page y, required if x is not an array - */ - translatePoints?( x?:any, y?:any ): any; - translatePoints?( x?:number, y?:number ): any; - translatePoints?( x?:any[], y?:number ): any; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Navigates up the ownership hierarchy searching for an ancestor Container which matches any passed simple selector or - * @param selector any The simple selector component or actual component to test. If not passed the immediate owner/activater is returned. - */ - up?( selector?:any ): any; - up?( selector?:string ): Ext.container.IContainer; - up?( selector?:Ext.IComponent ): Ext.container.IContainer; - /** [Method] Update the content area of a component - * @param htmlOrData any If this component has been configured with a template via the tpl config then it will use this argument as data to populate the template. If this component was not configured with a template, the components content area will be updated via Ext.Element update. - * @param loadScripts Boolean Only legitimate when using the html configuration. - * @param callback Function Only legitimate when using the html configuration. Callback to execute when scripts have finished loading. - */ - update?( htmlOrData?:any, loadScripts?:boolean, callback?:any ): void; - /** [Method] Updates this component s layout - * @param options Object An object with layout options. - */ - updateLayout?( options?:any ): void; - } -} -declare module Ext { - export interface IAbstractManager extends Ext.IBase { - /** [Property] (Ext.util.HashMap) */ - all?: Ext.util.IHashMap; - /** [Method] Creates and returns an instance of whatever this manager manages based on the supplied type and config object - * @param config Object The config object - * @param defaultType String If no type is discovered in the config object, we fall back to this type - */ - create?( config?:any, defaultType?:string ): any; - /** [Method] Executes the specified function once for each item in the collection - * @param fn Function The function to execute. - * @param scope Object The scope to execute in. Defaults to this. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Returns an item by id - * @param id String The id of the item - */ - get?( id?:string ): any; - /** [Method] Gets the number of items in the collection */ - getCount?(): number; - /** [Method] Checks if an item type is registered - * @param type String The mnemonic string by which the class may be looked up - */ - isRegistered?( type?:string ): boolean; - /** [Method] Registers a function that will be called when an item with the specified id is added to the manager - * @param id String The item id - * @param fn Function The callback function. Called with a single parameter, the item. - * @param scope Object The scope (this reference) in which the callback is executed. Defaults to the item. - */ - onAvailable?( id?:string, fn?:any, scope?:any ): void; - /** [Method] Registers an item to be managed - * @param item Object The item to register - */ - register?( item?:any ): void; - /** [Method] Registers a new item constructor keyed by a type key - * @param type String The mnemonic string by which the class may be looked up. - * @param cls Function The new instance class. - */ - registerType?( type?:string, cls?:any ): void; - /** [Method] Unregisters an item by removing it from this manager - * @param item Object The item to unregister - */ - unregister?( item?:any ): void; - } -} -declare module Ext { - export interface IAbstractPlugin extends Ext.IBase { - /** [Config Option] (String) A name for the plugin that can be set at creation time to then retrieve the plugin through getPlugin method. ... */ - pluginId?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Plugin, or subclass thereof. ... */ - isPlugin?: boolean; - /** [Method] The destroy method is invoked by the owning Component at the time the Component is being destroyed */ - destroy?(): void; - /** [Method] The base implementation just sets the plugin s disabled flag to true Plugin subclasses which need more complex proce */ - disable?(): void; - /** [Method] The base implementation just sets the plugin s disabled flag to false Plugin subclasses which need more complex proc */ - enable?(): void; - /** [Method] The init method is invoked after initComponent method has been run for the client Component - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - } -} -declare module Ext { - export interface IAction extends Ext.IBase { - /** [Config Option] (Boolean) True to disable all components configured by this Action, false to enable them. ... */ - disabled?: boolean; - /** [Config Option] (Function) */ - handler?: any; - /** [Config Option] (Boolean) True to hide all components configured by this Action, false to show them. ... */ - hidden?: boolean; - /** [Config Option] (String) The CSS class selector that specifies a background image to be used as the header icon for all components configured ... */ - iconCls?: string; - /** [Config Option] (String) */ - itemId?: string; - /** [Config Option] (Object) The scope (this reference) in which the handler is executed. ... */ - scope?: any; - /** [Config Option] (String) The text to set for all components configured by this Action. ... */ - text?: string; - /** [Method] Disables all components configured by this Action */ - disable?(): void; - /** [Method] Executes the specified function once for each Component currently tied to this Action - * @param fn Function The function to execute for each component - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Component. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Enables all components configured by this Action */ - enable?(): void; - /** [Method] Executes this Action manually using the handler function specified in the original config object or the handler funct - * @param args Object... Variable number of arguments passed to the handler function - */ - execute?( ...args:any[] ): void; - /** [Method] Gets the icon CSS class currently used by all components configured by this Action */ - getIconCls?(): void; - /** [Method] Gets the text currently displayed by all components configured by this Action */ - getText?(): void; - /** [Method] Hides all components configured by this Action */ - hide?(): void; - /** [Method] Returns true if the components using this Action are currently disabled else returns false */ - isDisabled?(): void; - /** [Method] Returns true if the components configured by this Action are currently hidden else returns false */ - isHidden?(): void; - /** [Method] Sets the disabled state of all components configured by this Action - * @param disabled Boolean True to disable the component, false to enable it - */ - setDisabled?( disabled?:boolean ): void; - /** [Method] Sets the function that will be called by each Component using this action when its primary event is triggered - * @param fn Function The function that will be invoked by the action's components. The function will be called with no arguments. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Component firing the event. - */ - setHandler?( fn?:any, scope?:any ): void; - /** [Method] Sets the hidden state of all components configured by this Action - * @param hidden Boolean True to hide the component, false to show it. - */ - setHidden?( hidden?:boolean ): void; - /** [Method] Sets the icon CSS class for all components configured by this Action - * @param cls String The CSS class supplying the icon image - */ - setIconCls?( cls?:string ): void; - /** [Method] Sets the text to be displayed by all components configured by this Action - * @param text String The text to display - */ - setText?( text?:string ): void; - /** [Method] Shows all components configured by this Action */ - show?(): void; - } -} -declare module Ext { - export interface IAjax extends Ext.data.IConnection { - } - export class Ajax { - } -} -declare module Ext.app { - export interface IApplication extends Ext.app.IController { - /** [Config Option] (String) The path to the directory which contains all application's classes. ... */ - appFolder?: string; - /** [Config Option] (String) The name of a property to be assigned to the main namespace to gain a reference to this application. ... */ - appProperty?: string; - /** [Config Option] (Boolean) True to automatically load and instantiate AppName.view.Viewport before firing the launch function. ... */ - autoCreateViewport?: boolean; - /** [Config Option] (String[]) */ - controllers?: string[]; - /** [Config Option] (Boolean) True to automatically set up Ext.tip.QuickTip support. ... */ - enableQuickTips?: boolean; - /** [Config Option] (String) The name of your application. ... */ - name?: string; - /** [Config Option] (String[]) The list of namespace prefixes used in the application to resolve dependencies like Views and Stores: Ext.applicati... */ - namespaces?: string[]; - /** [Config Option] (Object) Additional load paths to add to Ext.Loader. ... */ - paths?: any; - /** [Config Option] (Object) The scope to execute the launch function in. ... */ - scope?: any; - /** [Method] Returns the base Ext app Application for this controller */ - getApplication?(): Ext.app.IApplication; - /** [Method] Returns instance of a Controller with the given id - * @param id String - */ - getController?( id?:string ): Ext.app.IController; - /** [Method] Called automatically when the page has completely loaded - * @param profile String The detected application profile - */ - launch?( profile?:string ): boolean; - } -} -declare module Ext.app { - export interface IController extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) The id of this controller. ... */ - id?: string; - /** [Config Option] (String[]) Array of models to require from AppName.model namespace. ... */ - models?: string[]; - /** [Config Option] (Object[]) Array of configs to build up references to views on page. ... */ - refs?: Object[]; - /** [Config Option] (String[]) Array of stores to require from AppName.store namespace and to generate getter methods for. ... */ - stores?: string[]; - /** [Config Option] (String[]) Array of views to require from AppName.view namespace and to generate getter methods for. ... */ - views?: string[]; - /** [Property] (Ext.app.Application) */ - application?: Ext.app.IApplication; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Registers one or more references - * @param refs any - */ - addRef?( refs?:any ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Adds listeners to components selected via Ext ComponentQuery - * @param selectors any If a String, the second argument is used as the listeners, otherwise an object of selectors -> listeners is assumed - * @param listeners Object Config for listeners. - */ - control?( selectors?:any, listeners?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the base Ext app Application for this controller */ - getApplication?(): Ext.app.IApplication; - /** [Method] Returns instance of a Controller with the given id - * @param id String - */ - getController?( id?:string ): Ext.app.IController; - /** [Method] Returns a Model class with the given name - * @param name String - */ - getModel?( name?:string ): Ext.data.IModel; - /** [Method] Returns instance of a Store with the given name - * @param name String - */ - getStore?( name?:string ): Ext.data.IStore; - /** [Method] Returns a View class with the given name - * @param name String - */ - getView?( name?:string ): Ext.IBase; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Returns true if a reference is registered - * @param ref Object - */ - hasRef?( ref?:any ): boolean; - /** [Method] A template method that is called when your application boots - * @param application Ext.app.IApplication - */ - init?( application?:Ext.app.IApplication ): void; - /** [Method] Adds listeners to different event sources also called event domains - * @param to Object Config object containing domains, selectors and listeners. - */ - listen?( to?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] A template method like init but called after the viewport is created - * @param application Ext.app.IApplication - */ - onLaunch?( application?:Ext.app.IApplication ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.app.domain { - export interface IComponent extends Ext.app.IEventDomain { - } - export class Component { - /** [Method] */ - constructor(); - /** [Method] This method matches the firer of the event the target to the given selector - * @param target Object The firer of the event. - * @param selector String The selector to which to match the target. - */ - static match( target?:any, selector?:string ): boolean; - } -} -declare module Ext.app.domain { - export interface IController extends Ext.app.IEventDomain { - } - export class Controller { - /** [Method] */ - constructor(); - } -} -declare module Ext.app.domain { - export interface IDirect extends Ext.app.IEventDomain { - } - export class Direct { - /** [Method] */ - constructor(); - } -} -declare module Ext.app.domain { - export interface IGlobal extends Ext.app.IEventDomain { - } - export class Global { - /** [Method] */ - constructor(); - /** [Method] This method matches the firer of the event the target to the given selector - * @param target Object The firer of the event. - * @param selector String The selector to which to match the target. - */ - static match( target?:any, selector?:string ): boolean; - } -} -declare module Ext.app.domain { - export interface IStore extends Ext.app.IEventDomain { - } - export class Store { - /** [Method] */ - constructor(); - } -} -declare module Ext.app { - export interface IEventBus extends Ext.IBase { - } - export class EventBus { - /** [Method] */ - constructor(); - /** [Method] Adds a set of component event listeners for a controller - * @param selectors Object Config object containing selectors and listeners. - * @param controller Ext.app.IController The listening controller instance. - */ - static control( selectors?:any, controller?:Ext.app.IController ): void; - /** [Method] Adds a set of event domain listeners for a controller - * @param to Object Config object containing domains, selectors and listeners. - * @param controller Ext.app.IController The listening controller instance. - */ - static listen( to?:any, controller?:Ext.app.IController ): void; - /** [Method] Removes all of a controller s attached listeners - * @param controllerId String The id of the controller. - */ - static unlisten( controllerId?:string ): void; - } -} -declare module Ext.app { - export interface IEventDomain extends Ext.IBase { - /** [Config Option] (String) */ - idProperty?: string; - /** [Method] This method matches the firer of the event the target to the given selector - * @param target Object The firer of the event. - * @param selector String The selector to which to match the target. - */ - match?( target?:any, selector?:string ): boolean; - /** [Method] This method is called by the derived class to monitor fireEvent calls - * @param observable Ext.IClass The Observable to monitor for events. - */ - monitor?( observable?:Ext.IClass ): void; - } -} -declare module Ext { - export interface IArray { - } - export class Array { - /** [Method] Filter through an array and remove empty item as defined in Ext isEmpty See filter - * @param array Array - */ - static clean( array?:any[] ): any[]; - /** [Method] Clone a flat array without referencing the previous one - * @param array Array The array - */ - static clone( array?:any[] ): any[]; - /** [Method] Checks whether or not the given array contains the specified item - * @param array Array The array to check - * @param item Object The item to look for - */ - static contains( array?:any[], item?:any ): boolean; - /** [Method] Perform a set difference A B by subtracting all items in array B from array A - * @param arrayA Array - * @param arrayB Array - */ - static difference( arrayA?:any[], arrayB?:any[] ): any[]; - /** [Method] Iterates an array or an iterable value and invoke the given callback function for each item - * @param iterable any The value to be iterated. If this argument is not iterable, the callback function is called once. - * @param fn Function The callback function. If it returns false, the iteration stops and this method returns the current index. - * @param scope Object The scope (this reference) in which the specified function is executed. - * @param reverse Boolean Reverse the iteration order (loop from the end to the beginning) Defaults false - */ - static each( iterable?:any, fn?:any, scope?:any, reverse?:boolean ): boolean; - /** [Method] Shallow compares the contents of 2 arrays using strict equality - * @param array1 Array - * @param array2 Array - */ - static equals( array1?:any[], array2?:any[] ): boolean; - /** [Method] Removes items from an array - * @param array Array The Array on which to replace. - * @param index Number The index in the array at which to operate. - * @param removeCount Number The number of items to remove at index. - */ - static erase( array?:any[], index?:number, removeCount?:number ): any[]; - /** [Method] Executes the specified function for each array element until the function returns a falsy value - * @param array Array - * @param fn Function Callback function for each item - * @param scope Object Callback function scope - */ - static every( array?:any[], fn?:any, scope?:any ): boolean; - /** [Method] Creates a new array with all of the elements of this array for which the provided filtering function returns true - * @param array Array - * @param fn Function Callback function for each item - * @param scope Object Callback function scope - */ - static filter( array?:any[], fn?:any, scope?:any ): any[]; - /** [Method] Returns the first item in the array which elicits a true return value from the passed selection function - * @param array Array The array to search - * @param fn Function The selection function to execute for each item. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the array - */ - static findBy( array?:any[], fn?:any, scope?:any ): any; - /** [Method] Recursively flattens into 1 d Array - * @param array Array The array to flatten - */ - static flatten( array?:any[] ): any[]; - /** [Method] Iterates an array and invoke the given callback function for each item - * @param array Array The array to iterate - * @param fn Function The callback function. - * @param scope Object The execution scope (this) in which the specified function is executed. - */ - static forEach( array?:any[], fn?:any, scope?:any ): void; - /** [Method] Converts a value to an array if it s not already an array returns An empty array if given value is undefined or n - * @param value Object The value to convert to an array if it's not already is an array - * @param newReference Boolean True to clone the given array and return a new reference if necessary, defaults to false - */ - static from( value?:any, newReference?:boolean ): any[]; - /** [Method] Push an item into the array only if the array doesn t contain it yet - * @param array Array The array - * @param item Object The item to include - */ - static include( array?:any[], item?:any ): void; - /** [Method] Get the index of the provided item in the given array a supplement for the missing arrayPrototype indexOf in Interne - * @param array Array The array to check - * @param item Object The item to look for - * @param from Number The index at which to begin the search - */ - static indexOf( array?:any[], item?:any, from?:number ): number; - /** [Method] Inserts items in to an array - * @param array Array The Array in which to insert. - * @param index Number The index in the array at which to operate. - * @param items Array The array of items to insert at index. - */ - static insert( array?:any[], index?:number, items?:any[] ): any[]; - /** [Method] Merge multiple arrays into one with unique items that exist in all of the arrays - * @param array1 Array - * @param array2 Array - * @param etc Array - */ - static intersect( array1?:any[], array2?:any[], etc?:any[] ): any[]; - /** [Method] Creates a new array with the results of calling a provided function on every element in this array - * @param array Array - * @param fn Function Callback function for each item - * @param scope Object Callback function scope - */ - static map( array?:any[], fn?:any, scope?:any ): any[]; - /** [Method] Returns the maximum value in the Array - * @param array any The Array from which to select the maximum value. - * @param comparisonFn any a function to perform the comparision which determines maximization. If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1 - */ - static max( array?:any, comparisonFn?:any ): any; - static max( array?:any[], comparisonFn?:any ): any; - static max( array?:NodeList, comparisonFn?:any ): any; - /** [Method] Calculates the mean of all items in the array - * @param array Array The Array to calculate the mean value of. - */ - static mean( array?:any[] ): number; - /** [Method] Merge multiple arrays into one with unique items - * @param array1 Array - * @param array2 Array - * @param etc Array - */ - static merge( array1?:any[], array2?:any[], etc?:any[] ): any[]; - /** [Method] Returns the minimum value in the Array - * @param array any The Array from which to select the minimum value. - * @param comparisonFn any a function to perform the comparision which determines minimization. If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1 - */ - static min( array?:any, comparisonFn?:any ): any; - static min( array?:any[], comparisonFn?:any ): any; - static min( array?:NodeList, comparisonFn?:any ): any; - /** [Method] Plucks the value of a property from each item in the Array - * @param array any The Array of items to pluck the value from. - * @param propertyName any The property name to pluck from each element. - */ - static pluck( array?:any, propertyName?:any ): any; - static pluck( array?:any[], propertyName?:string ): any[]; - static pluck( array?:NodeList, propertyName?:string ): any[]; - /** [Method] Pushes new items onto the end of an Array - * @param target Array The Array onto which to push new items - * @param elements Object... The elements to add to the array. Each parameter may be an Array, in which case all the elements of that Array will be pushed into the end of the destination Array. - */ - static push( target:any[], ...elements:any[] ): any[]; - /** [Method] Removes the specified item from the array if it exists - * @param array Array The array - * @param item Object The item to remove - */ - static remove( array?:any[], item?:any ): any[]; - /** [Method] Replaces items in an array - * @param array Array The Array on which to replace. - * @param index Number The index in the array at which to operate. - * @param removeCount Number The number of items to remove at index (can be 0). - * @param insert Array An array of items to insert at index. - */ - static replace( array?:any[], index?:number, removeCount?:number, insert?:any[] ): any[]; - /** [Method] Returns a shallow copy of a part of an array - * @param array Array The array (or arguments object). - * @param begin Number The index at which to begin. Negative values are offsets from the end of the array. - * @param end Number The index at which to end. The copied items do not include end. Negative values are offsets from the end of the array. If end is omitted, all items up to the end of the array are copied. - */ - static slice( array?:any[], begin?:number, end?:number ): any[]; - /** [Method] Executes the specified function for each array element until the function returns a truthy value - * @param array Array - * @param fn Function Callback function for each item - * @param scope Object Callback function scope - */ - static some( array?:any[], fn?:any, scope?:any ): boolean; - /** [Method] Sorts the elements of an Array - * @param array Array The array to sort. - * @param sortFn Function The comparison function. - */ - static sort( array?:any[], sortFn?:any ): any[]; - /** [Method] Replaces items in an array - * @param array Array The Array on which to replace. - * @param index Number The index in the array at which to operate. - * @param removeCount Number The number of items to remove at index (can be 0). - * @param elements Object... The elements to add to the array. If you don't specify any elements, splice simply removes elements from the array. - */ - static splice( array:any[], index:number, removeCount:number, ...elements:any[] ): any[]; - /** [Method] Calculates the sum of all items in the given array - * @param array Array The Array to calculate the sum value of. - */ - static sum( array?:any[] ): number; - /** [Method] Converts any iterable numeric indices and a length property into a true array - * @param iterable Object the iterable object to be turned into a true Array. - * @param start Number a zero-based index that specifies the start of extraction. Defaults to 0 - * @param end Number a 1-based index that specifies the end of extraction. Defaults to the last index of the iterable value - */ - static toArray( iterable?:any, start?:number, end?:number ): any[]; - /** [Method] Creates a map object keyed by the elements of the given array - * @param array any The Array to create the map from. - * @param getKey any Name of the object property to use as a key or a function to extract the key. - * @param scope any Value of this inside callback. - */ - static toMap( array?:any, getKey?:any, scope?:any ): any; - static toMap( array?:any[], getKey?:string, scope?:any ): any; - static toMap( array?:any[], getKey?:any, scope?:any ): any; - /** [Method] Creates a map object keyed by a property of elements of the given array - * @param array any The Array to create the map from. - * @param getKey any Name of the object property to use as a key or a function to extract the key. - * @param scope any Value of this inside callback. - */ - static toValueMap( array?:any, getKey?:any, scope?:any ): any; - static toValueMap( array?:any[], getKey?:string, scope?:any ): any; - static toValueMap( array?:any[], getKey?:any, scope?:any ): any; - /** [Method] Merge multiple arrays into one with unique items - * @param array1 Array - * @param array2 Array - * @param etc Array - */ - static union( array1?:any[], array2?:any[], etc?:any[] ): any[]; - /** [Method] Returns a new array with unique items - * @param array Array - */ - static unique( array?:any[] ): any[]; - } -} -declare module Ext { - export interface IBase extends Ext.IClass { - /** [Property] (Ext.Class) Get the reference to the current class from which this object was instantiated. ... */ - self?: Ext.IClass; - /** [Method] Call the parent method of the current method - * @param args any The arguments, either an array or the arguments object from the current method, for example: this.callParent(arguments) - */ - callParent?( args?:any ): any; - callParent?( args?:any[] ): any; - /** [Method] This method is used by an override to call the superclass method but bypass any overridden method - * @param args any The arguments, either an array or the arguments object from the current method, for example: this.callSuper(arguments) - */ - callSuper?( args?:any ): any; - callSuper?( args?:any[] ): any; - /** [Method] Returns the initial configuration passed to constructor when instantiating this class - * @param name String Name of the config option to return. - */ - getInitialConfig?( name?:string ): any; - /** [Method] Initialize configuration for this class - * @param config Object - */ - initConfig?( config?:any ): Ext.IBase; - } -} -declare module Ext.button { - export interface IButton extends Ext.IComponent { - /** [Config Option] (Boolean) False to not allow a pressed Button to be depressed. ... */ - allowDepress?: boolean; - /** [Config Option] (String) The side of the Button box to render the arrow if the button has an associated menu. ... */ - arrowAlign?: string; - /** [Config Option] (String) The className used for the inner arrow element if the button has a menu. ... */ - arrowCls?: string; - /** [Config Option] (String) The base CSS class to add to all buttons. ... */ - baseCls?: string; - /** [Config Option] (Object) */ - baseParams?: any; - /** [Config Option] (String) The DOM event that will fire the handler of the button. ... */ - clickEvent?: string; - /** [Config Option] (String) */ - cls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) Whether or not to destroy any associated menu when this button is destroyed. ... */ - destroyMenu?: boolean; - /** [Config Option] (Boolean) True to start disabled. ... */ - disabled?: boolean; - /** [Config Option] (Boolean) True to enable pressed/not pressed toggling. ... */ - enableToggle?: boolean; - /** [Config Option] (String) The CSS class to add to a button when it is in the focussed state. ... */ - focusCls?: string; - /** [Config Option] (Boolean) Specify as true to have the Component inject framing elements within the Component at render time to provide a graphi... */ - frame?: boolean; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for this button. ... */ - glyph?: any; - /** [Config Option] (Boolean) False to disable visual cues on mouseover, mouseout and mousedown. ... */ - handleMouseEvents?: boolean; - /** [Config Option] (Function) A function called when the button is clicked (can be used instead of click event). ... */ - handler?: any; - /** [Config Option] (Boolean) True to start hidden. ... */ - hidden?: boolean; - /** [Config Option] (String) The URL to open when the button is clicked. ... */ - href?: string; - /** [Config Option] (String) The target attribute to use for the underlying anchor. ... */ - hrefTarget?: string; - /** [Config Option] (String) */ - icon?: string; - /** [Config Option] (String) The side of the Button box to render the icon. ... */ - iconAlign?: string; - /** [Config Option] (String) */ - iconCls?: string; - /** [Config Option] (Ext.menu.Menu/String/Object) */ - menu?: any; - /** [Config Option] (String) The CSS class to add to a button when it's menu is active. ... */ - menuActiveCls?: string; - /** [Config Option] (String) The position to align the menu to (see Ext.util.Positionable.alignTo for more details). ... */ - menuAlign?: string; - /** [Config Option] (Number) The minimum width for this button (used to give a set of buttons a common width). ... */ - minWidth?: number; - /** [Config Option] (String) The CSS class to add to a button when it is in the over (hovered) state. ... */ - overCls?: string; - /** [Config Option] (String) If used in a Toolbar, the text to be used if this item is shown in the overflow menu. ... */ - overflowText?: string; - /** [Config Option] (Object) An object literal of parameters to pass to the url when the href property is specified. ... */ - params?: any; - /** [Config Option] (Boolean) True to start pressed (only if enableToggle = true) ... */ - pressed?: boolean; - /** [Config Option] (String) The CSS class to add to a button when it is in the pressed state. ... */ - pressedCls?: string; - /** [Config Option] (Boolean) True to prevent the default action when the clickEvent is processed. ... */ - preventDefault?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) We have to keep "unselectable" attribute on all elements because it's not inheritable. ... */ - renderTpl?: any; - /** [Config Option] (Boolean/Object) True to repeat fire the click event while the mouse is down. ... */ - repeat?: any; - /** [Config Option] ("small"/"medium"/"large") The size of the Button. ... */ - scale?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler and toggleHandler is executed. ... */ - scope?: any; - /** [Config Option] (Boolean) True to force an attached menu with no items to be shown when clicking this button. ... */ - showEmptyMenu?: boolean; - /** [Config Option] (Boolean/Number) If this property is a number, it is interpreted as follows: 0: Neither width nor height depend on content. ... */ - shrinkWrap?: any; - /** [Config Option] (Number) */ - tabIndex?: number; - /** [Config Option] (String) */ - text?: string; - /** [Config Option] (String) The text alignment for this button (center, left, right). ... */ - textAlign?: string; - /** [Config Option] (String) The group this toggle button is a member of (only 1 per group can be pressed). ... */ - toggleGroup?: string; - /** [Config Option] (Function) Function called when a Button with enableToggle set to true is clicked. ... */ - toggleHandler?: any; - /** [Config Option] (String/Object) The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config obj... */ - tooltip?: any; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Config Option] (String) The type of <input> to create: submit, reset or button. ... */ - type?: string; - /** [Property] (Ext.Template) A Template used to create the Button's DOM structure. ... */ - template?: Ext.ITemplate; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] inherit docs Disable the component - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): void; - /** [Method] inherit docs Enable the component - * @param silent Boolean Passing true will suppress the enable event from being fired. - */ - enable?( silent?:boolean ): void; - /** [Method] This method returns an object which provides substitution parameters for the XTemplate used to create this Button s D */ - getTemplateArgs?(): any; - /** [Method] Gets the text for this Button */ - getText?(): string; - /** [Method] Returns true if the button has a menu and it is visible */ - hasVisibleMenu?(): boolean; - /** [Method] Hides this button s menu if it has one */ - hideMenu?(): Ext.button.IButton; - /** [Method] inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] See comments in onFocus Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Sets this button s glyph - * @param glyph any the numeric charCode or string charCode/font-family. This parameter expects a format consistent with that of glyph - */ - setGlyph?( glyph?:any ): any; - setGlyph?( glyph?:number ): Ext.button.IButton; - setGlyph?( glyph?:string ): Ext.button.IButton; - /** [Method] Assigns this Button s click handler - * @param handler Function The function to call when the button is clicked - * @param scope Object The scope (this reference) in which the handler function is executed. Defaults to this Button. - */ - setHandler?( handler?:any, scope?:any ): Ext.button.IButton; - /** [Method] Sets the href of the embedded anchor element to the passed URL - * @param href String The URL to set in the anchor element. - */ - setHref?( href?:string ): void; - /** [Method] Sets the background image inline style of the button - * @param icon String The path to an image to display in the button - */ - setIcon?( icon?:string ): Ext.button.IButton; - /** [Method] Sets the CSS class that provides a background image to use as the button s icon - * @param cls String The CSS class providing the icon image - */ - setIconCls?( cls?:string ): Ext.button.IButton; - /** [Method] Sets the href of the link dynamically according to the params passed and any baseParams configured - * @param params Object Parameters to use in the href URL. - */ - setParams?( params?:any ): void; - /** [Method] Method to change the scale of the button - * @param scale String The scale to change to. - */ - setScale?( scale?:string ): void; - /** [Method] Sets this Button s text - * @param text String The button text - */ - setText?( text?:string ): Ext.button.IButton; - /** [Method] Sets the text alignment for this button - * @param align String The new alignment of the button text. See textAlign. - */ - setTextAlign?( align?:string ): void; - /** [Method] Sets the tooltip for this Button - * @param tooltip any This may be: String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip Object : A configuration object for Ext.tip.QuickTipManager.register. - */ - setTooltip?( tooltip?:any ): Ext.button.IButton; - /** [Method] inherit docs Sets the UI for the component - * @param ui String The new UI for the component. - */ - setUI?( ui?:string ): void; - /** [Method] Shows this button s menu if it has one - * @param fromEvent Object - */ - showMenu?( fromEvent?:any ): void; - /** [Method] If a state it passed it becomes the pressed state otherwise the current state is toggled - * @param state Boolean Force a particular state - * @param suppressEvent Boolean True to stop events being fired when calling this method. - */ - toggle?( state?:boolean, suppressEvent?:boolean ): Ext.button.IButton; - } -} -declare module Ext { - export interface IButton extends Ext.IComponent { - /** [Config Option] (Boolean) False to not allow a pressed Button to be depressed. ... */ - allowDepress?: boolean; - /** [Config Option] (String) The side of the Button box to render the arrow if the button has an associated menu. ... */ - arrowAlign?: string; - /** [Config Option] (String) The className used for the inner arrow element if the button has a menu. ... */ - arrowCls?: string; - /** [Config Option] (String) The base CSS class to add to all buttons. ... */ - baseCls?: string; - /** [Config Option] (Object) */ - baseParams?: any; - /** [Config Option] (String) The DOM event that will fire the handler of the button. ... */ - clickEvent?: string; - /** [Config Option] (String) */ - cls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) Whether or not to destroy any associated menu when this button is destroyed. ... */ - destroyMenu?: boolean; - /** [Config Option] (Boolean) True to start disabled. ... */ - disabled?: boolean; - /** [Config Option] (Boolean) True to enable pressed/not pressed toggling. ... */ - enableToggle?: boolean; - /** [Config Option] (String) The CSS class to add to a button when it is in the focussed state. ... */ - focusCls?: string; - /** [Config Option] (Boolean) Specify as true to have the Component inject framing elements within the Component at render time to provide a graphi... */ - frame?: boolean; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for this button. ... */ - glyph?: any; - /** [Config Option] (Boolean) False to disable visual cues on mouseover, mouseout and mousedown. ... */ - handleMouseEvents?: boolean; - /** [Config Option] (Function) A function called when the button is clicked (can be used instead of click event). ... */ - handler?: any; - /** [Config Option] (Boolean) True to start hidden. ... */ - hidden?: boolean; - /** [Config Option] (String) The URL to open when the button is clicked. ... */ - href?: string; - /** [Config Option] (String) The target attribute to use for the underlying anchor. ... */ - hrefTarget?: string; - /** [Config Option] (String) */ - icon?: string; - /** [Config Option] (String) The side of the Button box to render the icon. ... */ - iconAlign?: string; - /** [Config Option] (String) */ - iconCls?: string; - /** [Config Option] (Ext.menu.Menu/String/Object) */ - menu?: any; - /** [Config Option] (String) The CSS class to add to a button when it's menu is active. ... */ - menuActiveCls?: string; - /** [Config Option] (String) The position to align the menu to (see Ext.util.Positionable.alignTo for more details). ... */ - menuAlign?: string; - /** [Config Option] (Number) The minimum width for this button (used to give a set of buttons a common width). ... */ - minWidth?: number; - /** [Config Option] (String) The CSS class to add to a button when it is in the over (hovered) state. ... */ - overCls?: string; - /** [Config Option] (String) If used in a Toolbar, the text to be used if this item is shown in the overflow menu. ... */ - overflowText?: string; - /** [Config Option] (Object) An object literal of parameters to pass to the url when the href property is specified. ... */ - params?: any; - /** [Config Option] (Boolean) True to start pressed (only if enableToggle = true) ... */ - pressed?: boolean; - /** [Config Option] (String) The CSS class to add to a button when it is in the pressed state. ... */ - pressedCls?: string; - /** [Config Option] (Boolean) True to prevent the default action when the clickEvent is processed. ... */ - preventDefault?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) We have to keep "unselectable" attribute on all elements because it's not inheritable. ... */ - renderTpl?: any; - /** [Config Option] (Boolean/Object) True to repeat fire the click event while the mouse is down. ... */ - repeat?: any; - /** [Config Option] ("small"/"medium"/"large") The size of the Button. ... */ - scale?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler and toggleHandler is executed. ... */ - scope?: any; - /** [Config Option] (Boolean) True to force an attached menu with no items to be shown when clicking this button. ... */ - showEmptyMenu?: boolean; - /** [Config Option] (Boolean/Number) If this property is a number, it is interpreted as follows: 0: Neither width nor height depend on content. ... */ - shrinkWrap?: any; - /** [Config Option] (Number) */ - tabIndex?: number; - /** [Config Option] (String) */ - text?: string; - /** [Config Option] (String) The text alignment for this button (center, left, right). ... */ - textAlign?: string; - /** [Config Option] (String) The group this toggle button is a member of (only 1 per group can be pressed). ... */ - toggleGroup?: string; - /** [Config Option] (Function) Function called when a Button with enableToggle set to true is clicked. ... */ - toggleHandler?: any; - /** [Config Option] (String/Object) The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config obj... */ - tooltip?: any; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Config Option] (String) The type of <input> to create: submit, reset or button. ... */ - type?: string; - /** [Property] (Ext.Template) A Template used to create the Button's DOM structure. ... */ - template?: Ext.ITemplate; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] inherit docs Disable the component - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): void; - /** [Method] inherit docs Enable the component - * @param silent Boolean Passing true will suppress the enable event from being fired. - */ - enable?( silent?:boolean ): void; - /** [Method] This method returns an object which provides substitution parameters for the XTemplate used to create this Button s D */ - getTemplateArgs?(): any; - /** [Method] Gets the text for this Button */ - getText?(): string; - /** [Method] Returns true if the button has a menu and it is visible */ - hasVisibleMenu?(): boolean; - /** [Method] Hides this button s menu if it has one */ - hideMenu?(): Ext.button.IButton; - /** [Method] inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] See comments in onFocus Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Sets this button s glyph - * @param glyph any the numeric charCode or string charCode/font-family. This parameter expects a format consistent with that of glyph - */ - setGlyph?( glyph?:any ): any; - setGlyph?( glyph?:number ): Ext.button.IButton; - setGlyph?( glyph?:string ): Ext.button.IButton; - /** [Method] Assigns this Button s click handler - * @param handler Function The function to call when the button is clicked - * @param scope Object The scope (this reference) in which the handler function is executed. Defaults to this Button. - */ - setHandler?( handler?:any, scope?:any ): Ext.button.IButton; - /** [Method] Sets the href of the embedded anchor element to the passed URL - * @param href String The URL to set in the anchor element. - */ - setHref?( href?:string ): void; - /** [Method] Sets the background image inline style of the button - * @param icon String The path to an image to display in the button - */ - setIcon?( icon?:string ): Ext.button.IButton; - /** [Method] Sets the CSS class that provides a background image to use as the button s icon - * @param cls String The CSS class providing the icon image - */ - setIconCls?( cls?:string ): Ext.button.IButton; - /** [Method] Sets the href of the link dynamically according to the params passed and any baseParams configured - * @param params Object Parameters to use in the href URL. - */ - setParams?( params?:any ): void; - /** [Method] Method to change the scale of the button - * @param scale String The scale to change to. - */ - setScale?( scale?:string ): void; - /** [Method] Sets this Button s text - * @param text String The button text - */ - setText?( text?:string ): Ext.button.IButton; - /** [Method] Sets the text alignment for this button - * @param align String The new alignment of the button text. See textAlign. - */ - setTextAlign?( align?:string ): void; - /** [Method] Sets the tooltip for this Button - * @param tooltip any This may be: String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip Object : A configuration object for Ext.tip.QuickTipManager.register. - */ - setTooltip?( tooltip?:any ): Ext.button.IButton; - /** [Method] inherit docs Sets the UI for the component - * @param ui String The new UI for the component. - */ - setUI?( ui?:string ): void; - /** [Method] Shows this button s menu if it has one - * @param fromEvent Object - */ - showMenu?( fromEvent?:any ): void; - /** [Method] If a state it passed it becomes the pressed state otherwise the current state is toggled - * @param state Boolean Force a particular state - * @param suppressEvent Boolean True to stop events being fired when calling this method. - */ - toggle?( state?:boolean, suppressEvent?:boolean ): Ext.button.IButton; - } -} -declare module Ext.button { - export interface ICycle extends Ext.button.ISplit { - /** [Config Option] (Function) A callback function that will be invoked each time the active menu item in the button's menu has changed. ... */ - changeHandler?: any; - /** [Config Option] (Number/String) The charCode to be used as the static icon for this button. ... */ - forceGlyph?: any; - /** [Config Option] (String) A css class which sets an image to be used as the static icon for this button. ... */ - forceIcon?: string; - /** [Config Option] (Object[]) An array of Ext.menu.CheckItem config objects to be used when creating the button's menu items (e.g., {text:'Foo', ic... */ - items?: Object[]; - /** [Config Option] (String) A static string to prepend before the active item's text when displayed as the button's text (only applies when showT... */ - prependText?: string; - /** [Config Option] (Boolean) True to display the active item's text as the button text. ... */ - showText?: boolean; - /** [Property] (Ext.menu.Menu) */ - menu?: Ext.menu.IMenu; - /** [Method] Gets the currently active menu item */ - getActiveItem?(): Ext.menu.ICheckItem; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Sets the button s active menu item - * @param item Ext.menu.ICheckItem The item to activate - * @param suppressEvent Boolean True to prevent the button's change event from firing. - */ - setActiveItem?( item?:Ext.menu.ICheckItem, suppressEvent?:boolean ): void; - /** [Method] This is normally called internally on button click but can be called externally to advance the button s active item */ - toggleSelected?(): void; - } -} -declare module Ext { - export interface ICycleButton extends Ext.button.ISplit { - /** [Config Option] (Function) A callback function that will be invoked each time the active menu item in the button's menu has changed. ... */ - changeHandler?: any; - /** [Config Option] (Number/String) The charCode to be used as the static icon for this button. ... */ - forceGlyph?: any; - /** [Config Option] (String) A css class which sets an image to be used as the static icon for this button. ... */ - forceIcon?: string; - /** [Config Option] (Object[]) An array of Ext.menu.CheckItem config objects to be used when creating the button's menu items (e.g., {text:'Foo', ic... */ - items?: Object[]; - /** [Config Option] (String) A static string to prepend before the active item's text when displayed as the button's text (only applies when showT... */ - prependText?: string; - /** [Config Option] (Boolean) True to display the active item's text as the button text. ... */ - showText?: boolean; - /** [Property] (Ext.menu.Menu) */ - menu?: Ext.menu.IMenu; - /** [Method] Gets the currently active menu item */ - getActiveItem?(): Ext.menu.ICheckItem; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Sets the button s active menu item - * @param item Ext.menu.ICheckItem The item to activate - * @param suppressEvent Boolean True to prevent the button's change event from firing. - */ - setActiveItem?( item?:Ext.menu.ICheckItem, suppressEvent?:boolean ): void; - /** [Method] This is normally called internally on button click but can be called externally to advance the button s active item */ - toggleSelected?(): void; - } -} -declare module Ext.button { - export interface IManager extends Ext.IBase { - } - export class Manager { - } -} -declare module Ext { - export interface IButtonToggleManager extends Ext.IBase { - } - export class ButtonToggleManager { - } -} -declare module Ext.button { - export interface ISplit extends Ext.button.IButton { - /** [Config Option] (Function) A function called when the arrow button is clicked (can be used instead of click event) ... */ - arrowHandler?: any; - /** [Config Option] (String) */ - arrowTooltip?: string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Sets this button s arrow click handler - * @param handler Function The function to call when the arrow is clicked. - * @param scope Object Scope for the function passed above. - */ - setArrowHandler?( handler?:any, scope?:any ): void; - } -} -declare module Ext { - export interface ISplitButton extends Ext.button.IButton { - /** [Config Option] (Function) A function called when the arrow button is clicked (can be used instead of click event) ... */ - arrowHandler?: any; - /** [Config Option] (String) */ - arrowTooltip?: string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Sets this button s arrow click handler - * @param handler Function The function to call when the arrow is clicked. - * @param scope Object Scope for the function passed above. - */ - setArrowHandler?( handler?:any, scope?:any ): void; - } -} -declare module Ext.chart.axis { - export interface IAbstract extends Ext.IBase { - /** [Config Option] (String[]) The fields of model to bind to this axis. ... */ - fields?: string[]; - /** [Config Option] (Ext.chart.Label) */ - label?: Ext.chart.ILabel; - } -} -declare module Ext.chart.axis { - export interface IAxis extends Ext.chart.axis.IAbstract { - /** [Config Option] (Boolean) Whether to adjust the label at the end of the axis. ... */ - adjustEnd?: boolean; - /** [Config Option] (Number) The size of the dash marker. ... */ - dashSize?: number; - /** [Config Option] (Boolean/Object) The grid configuration enables you to set a background grid for an axis. ... */ - grid?: any; - /** [Config Option] (Number) Offset axis position. ... */ - length?: number; - /** [Config Option] (Number) If minimum and maximum are specified it forces the number of major ticks to the specified value. ... */ - majorTickSteps?: number; - /** [Config Option] (Number) The number of small ticks between two major ticks. ... */ - minorTickSteps?: number; - /** [Config Option] (String) Where to set the axis. ... */ - position?: string; - /** [Config Option] (String) */ - title?: string; - /** [Config Option] (Number) Offset axis width. ... */ - width?: number; - /** [Method] Renders the axis into the screen and updates its position - * @param init Object - */ - drawAxis?( init?:any ): void; - /** [Method] Renders an horizontal and or vertical grid into the Surface */ - drawGrid?(): void; - /** [Method] Renders the labels in the axes */ - drawLabel?(): void; - /** [Method] Updates the title of this axis - * @param title String - */ - setTitle?( title?:string ): void; - } -} -declare module Ext.chart { - export interface IAxis extends Ext.chart.axis.IAbstract { - /** [Config Option] (Boolean) Whether to adjust the label at the end of the axis. ... */ - adjustEnd?: boolean; - /** [Config Option] (Number) The size of the dash marker. ... */ - dashSize?: number; - /** [Config Option] (Boolean/Object) The grid configuration enables you to set a background grid for an axis. ... */ - grid?: any; - /** [Config Option] (Number) Offset axis position. ... */ - length?: number; - /** [Config Option] (Number) If minimum and maximum are specified it forces the number of major ticks to the specified value. ... */ - majorTickSteps?: number; - /** [Config Option] (Number) The number of small ticks between two major ticks. ... */ - minorTickSteps?: number; - /** [Config Option] (String) Where to set the axis. ... */ - position?: string; - /** [Config Option] (String) */ - title?: string; - /** [Config Option] (Number) Offset axis width. ... */ - width?: number; - /** [Method] Renders the axis into the screen and updates its position - * @param init Object - */ - drawAxis?( init?:any ): void; - /** [Method] Renders an horizontal and or vertical grid into the Surface */ - drawGrid?(): void; - /** [Method] Renders the labels in the axes */ - drawLabel?(): void; - /** [Method] Updates the title of this axis - * @param title String - */ - setTitle?( title?:string ): void; - } -} -declare module Ext.chart.axis { - export interface ICategory extends Ext.chart.axis.IAxis { - /** [Config Option] (Boolean) Indicates whether or not to calculate the number of categories (ticks and labels) when there is not enough room to di... */ - calculateCategoryCount?: boolean; - /** [Config Option] (String) */ - categoryNames?: string; - } -} -declare module Ext.chart { - export interface ICategoryAxis extends Ext.chart.axis.IAxis { - /** [Config Option] (Boolean) Indicates whether or not to calculate the number of categories (ticks and labels) when there is not enough room to di... */ - calculateCategoryCount?: boolean; - /** [Config Option] (String) */ - categoryNames?: string; - } -} -declare module Ext.chart.axis { - export interface IGauge extends Ext.chart.axis.IAbstract { - /** [Config Option] (Number) The offset positioning of the tick marks and labels in pixels. ... */ - margin?: number; - /** [Config Option] (Number) */ - maximum?: number; - /** [Config Option] (Number) */ - minimum?: number; - /** [Config Option] (Number) */ - steps?: number; - /** [Config Option] (String) */ - title?: string; - /** [Method] Updates the title of this axis - * @param title String - */ - setTitle?( title?:string ): void; - } -} -declare module Ext.chart.axis { - export interface INumeric extends Ext.chart.axis.IAxis { - /** [Config Option] (Boolean) Indicates whether to extend maximum beyond data's maximum to the nearest majorUnit. ... */ - adjustMaximumByMajorUnit?: boolean; - /** [Config Option] (Boolean) Indicates whether to extend the minimum beyond data's minimum to the nearest majorUnit. ... */ - adjustMinimumByMajorUnit?: boolean; - /** [Config Option] (Boolean) If true, the values of the chart will be rendered only if they belong between minimum and maximum If false, all value... */ - constrain?: boolean; - /** [Config Option] (Number) The number of decimals to round the value to. ... */ - decimals?: number; - /** [Config Option] (Number) The maximum value drawn by the axis. ... */ - maximum?: number; - /** [Config Option] (Number) The minimum value drawn by the axis. ... */ - minimum?: number; - /** [Config Option] (String) Indicates the position of the axis relative to the chart ... */ - position?: string; - } -} -declare module Ext.chart { - export interface INumericAxis extends Ext.chart.axis.IAxis { - /** [Config Option] (Boolean) Indicates whether to extend maximum beyond data's maximum to the nearest majorUnit. ... */ - adjustMaximumByMajorUnit?: boolean; - /** [Config Option] (Boolean) Indicates whether to extend the minimum beyond data's minimum to the nearest majorUnit. ... */ - adjustMinimumByMajorUnit?: boolean; - /** [Config Option] (Boolean) If true, the values of the chart will be rendered only if they belong between minimum and maximum If false, all value... */ - constrain?: boolean; - /** [Config Option] (Number) The number of decimals to round the value to. ... */ - decimals?: number; - /** [Config Option] (Number) The maximum value drawn by the axis. ... */ - maximum?: number; - /** [Config Option] (Number) The minimum value drawn by the axis. ... */ - minimum?: number; - /** [Config Option] (String) Indicates the position of the axis relative to the chart ... */ - position?: string; - } -} -declare module Ext.chart.axis { - export interface IRadial extends Ext.chart.axis.INumeric { - /** [Config Option] (Number) The maximum value drawn by the axis. ... */ - maximum?: number; - /** [Config Option] (String) End Definitions Indicates the position of the axis relative to the chart ... */ - position?: string; - /** [Config Option] (Number) The number of circles to draw outward from the center. ... */ - steps?: number; - /** [Method] Renders the labels in the axes */ - drawLabel?(): void; - } -} -declare module Ext.chart.axis { - export interface ITime extends Ext.chart.axis.INumeric { - /** [Config Option] (Boolean) If true, the values of the chart will be rendered only if they belong between the fromDate and toDate. ... */ - constrain?: boolean; - /** [Config Option] (String/Boolean) Indicates the format the date will be rendered on. ... */ - dateFormat?: any; - /** [Config Option] (Date) The starting date for the time axis. ... */ - fromDate?: any; - /** [Config Option] (Array) An array with two components: The first is the unit of the step (day, month, year, etc). ... */ - step?: any[]; - /** [Config Option] (Date) The ending date for the time axis. ... */ - toDate?: any; - } -} -declare module Ext.chart { - export interface ITimeAxis extends Ext.chart.axis.INumeric { - /** [Config Option] (Boolean) If true, the values of the chart will be rendered only if they belong between the fromDate and toDate. ... */ - constrain?: boolean; - /** [Config Option] (String/Boolean) Indicates the format the date will be rendered on. ... */ - dateFormat?: any; - /** [Config Option] (Date) The starting date for the time axis. ... */ - fromDate?: any; - /** [Config Option] (Array) An array with two components: The first is the unit of the step (day, month, year, etc). ... */ - step?: any[]; - /** [Config Option] (Date) The ending date for the time axis. ... */ - toDate?: any; - } -} -declare module Ext.chart { - export interface ICallout extends Ext.IBase { - } -} -declare module Ext.chart { - export interface IChart extends Ext.draw.IComponent,Ext.chart.IMask,Ext.chart.INavigation,Ext.chart.theme.ITheme,Ext.util.IBindable,Ext.util.IObservable { - /** [Config Option] (Boolean/Object) True for the default animation (easing: 'ease' and duration: 500) or a standard animation config object to be used fo... */ - animate?: any; - /** [Config Option] (Ext.chart.axis.Axis[]) Array of Axis instances or config objects. ... */ - axes?: Ext.chart.axis.IAxis[]; - /** [Config Option] (Object/Boolean) The chart background. ... */ - background?: any; - /** [Config Option] (Object[]) Define a set of gradients that can be used as fill property in sprites. ... */ - gradients?: Object[]; - /** [Config Option] (Number) The amount of inset padding in pixels for the chart. ... */ - insetPadding?: number; - /** [Config Option] (Boolean/Object) True for the default legend display or a legend config object. ... */ - legend?: any; - /** [Config Option] (Ext.chart.series.Series[]) Array of Series instances or config objects. ... */ - series?: Ext.chart.series.ISeries[]; - /** [Config Option] (Ext.data.Store) */ - store?: Ext.data.IStore; - /** [Config Option] (String) The name of the theme to be used. ... */ - theme?: string; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] overrides the component method to set the correct dimensions to the chart - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] set the store after rendering the chart */ - afterRender?(): void; - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Redraws the chart - * @param resize Boolean flag which changes the default origin points of the chart for animations. - */ - redraw?( resize?:boolean ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Restores the zoom to the original value */ - restoreZoom?(): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Saves the chart by either triggering a download or returning a string containing the chart data as SVG - * @param config Object The configuration to be passed to the exporter. See the export method for the appropriate exporter for the relevant configuration options - */ - save?( config?:any ): any; - /** [Method] Zooms the chart to the specified selection range - * @param zoomConfig Object - */ - setZoom?( zoomConfig?:any ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.chart { - export interface IHighlight extends Ext.IBase { - /** [Config Option] (Boolean/Object) Set to true to enable highlighting using the default highlight attributes. ... */ - highlight?: any; - /** [Property] (Object) The default properties to apply as a highight. ... */ - highlightCfg?: any; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart { - export interface ILabel extends Ext.IBase { - /** [Config Option] (Object) Object with the following properties: ... */ - label?: any; - /** [Method] Called each time a new label is created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] Called for updating the position of the label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart { - export interface ILegend extends Ext.IBase { - /** [Config Option] (String) Fill style for the legend box ... */ - boxFill?: string; - /** [Config Option] (String) Style of the stroke for the legend box ... */ - boxStroke?: string; - /** [Config Option] (String) Width of the stroke for the legend box ... */ - boxStrokeWidth?: string; - /** [Config Option] (Number) Sets the z-index for the legend. ... */ - boxZIndex?: number; - /** [Config Option] (Number) Amount of space between legend items ... */ - itemSpacing?: number; - /** [Config Option] (String) Color to be used for the legend labels, eg '#000' ... */ - labelColor?: string; - /** [Config Option] (String) Font to be used for the legend labels, eg '12px Helvetica' ... */ - labelFont?: string; - /** [Config Option] (Number) Amount of padding between the legend box's border and its items ... */ - padding?: number; - /** [Config Option] (String) The position of the legend in relation to the chart. ... */ - position?: string; - /** [Config Option] (Boolean) If set to true the legend will be refreshed when the chart is. ... */ - update?: boolean; - /** [Config Option] (Boolean) Whether or not the legend should be displayed. ... */ - visible?: boolean; - /** [Config Option] (Number) X-position of the legend box. ... */ - x?: number; - /** [Config Option] (Number) Y-position of the legend box. ... */ - y?: number; - /** [Property] (Boolean) Whether the legend box is oriented vertically, i.e. ... */ - isVertical?: boolean; - /** [Method] toggle - * @param show Boolean Whether to show or hide the legend. - */ - toggle?( show?:boolean ): void; - } -} -declare module Ext.chart { - export interface ILegendItem extends Ext.draw.ICompositeSprite { - /** [Method] Creates all the individual sprites for this legend item - * @param config Object - */ - createLegend?( config?:any ): void; - /** [Method] Update the positions of all this item s sprites to match the root position of the legend box - * @param relativeTo Object If specified, this object's 'x' and 'y' values will be used as the reference point for the relative positioning. Defaults to the Legend. - */ - updatePosition?( relativeTo?:any ): void; - } -} -declare module Ext.chart { - export interface IMask extends Ext.IBase { - /** [Config Option] (Boolean/String) Enables selecting a region on chart. ... */ - mask?: any; - } -} -declare module Ext.chart { - export interface IMaskLayer extends Ext.IComponent { - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext.chart { - export interface INavigation extends Ext.IBase { - /** [Method] Restores the zoom to the original value */ - restoreZoom?(): void; - /** [Method] Zooms the chart to the specified selection range - * @param zoomConfig Object - */ - setZoom?( zoomConfig?:any ): void; - } -} -declare module Ext.chart.series { - export interface IArea extends Ext.chart.series.ICartesian { - /** [Config Option] (Object) Append styling properties to this object for it to override theme properties. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns the color of the series to be displayed as color for the series legend item - * @param item Object Info about the item; same format as returned by getItemForPoint - */ - getLegendColor?( item?:any ): void; - /** [Method] Highlight the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - highlightItem?( item?:any ): void; - /** [Method] Highlight this entire series - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightSeries?( item?:any ): void; - /** [Method] Called each time a new label is created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] Called for updating the position of the label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlights the specified item - * @param item Object Info about the item; same format as returned by getItemForPoint - */ - unHighlightItem?( item?:any ): void; - /** [Method] UnHighlight this entire series - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - unHighlightSeries?( item?:any ): void; - } -} -declare module Ext.chart.series { - export interface IBar extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (Number) The gutter space between groups of bars, as a percentage of the bar width ... */ - groupGutter?: number; - /** [Config Option] (Number) The gutter space between single bars, as a percentage of the bar width ... */ - gutter?: number; - /** [Config Option] (Boolean) If set to true then bars for multiple yField values will be rendered stacked on top of one another. ... */ - stacked?: boolean; - /** [Config Option] (Object) Style properties that will override the theming series styles. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns a string with the color to be used for the series legend item - * @param index Object - */ - getLegendColor?( index?:any ): void; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] handled when creating a label - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback used when placing a label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart { - export interface IBarChart extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (Number) The gutter space between groups of bars, as a percentage of the bar width ... */ - groupGutter?: number; - /** [Config Option] (Number) The gutter space between single bars, as a percentage of the bar width ... */ - gutter?: number; - /** [Config Option] (Boolean) If set to true then bars for multiple yField values will be rendered stacked on top of one another. ... */ - stacked?: boolean; - /** [Config Option] (Object) Style properties that will override the theming series styles. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns a string with the color to be used for the series legend item - * @param index Object - */ - getLegendColor?( index?:any ): void; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] handled when creating a label - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback used when placing a label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart { - export interface IBarSeries extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (Number) The gutter space between groups of bars, as a percentage of the bar width ... */ - groupGutter?: number; - /** [Config Option] (Number) The gutter space between single bars, as a percentage of the bar width ... */ - gutter?: number; - /** [Config Option] (Boolean) If set to true then bars for multiple yField values will be rendered stacked on top of one another. ... */ - stacked?: boolean; - /** [Config Option] (Object) Style properties that will override the theming series styles. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns a string with the color to be used for the series legend item - * @param index Object - */ - getLegendColor?( index?:any ): void; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] handled when creating a label - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback used when placing a label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart { - export interface IStackedBarChart extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (Number) The gutter space between groups of bars, as a percentage of the bar width ... */ - groupGutter?: number; - /** [Config Option] (Number) The gutter space between single bars, as a percentage of the bar width ... */ - gutter?: number; - /** [Config Option] (Boolean) If set to true then bars for multiple yField values will be rendered stacked on top of one another. ... */ - stacked?: boolean; - /** [Config Option] (Object) Style properties that will override the theming series styles. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns a string with the color to be used for the series legend item - * @param index Object - */ - getLegendColor?( index?:any ): void; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] handled when creating a label - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback used when placing a label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart.series { - export interface ICartesian extends Ext.chart.series.ISeries { - /** [Config Option] (String/String[]) The position of the axis to bind the values to. ... */ - axis?: any; - /** [Config Option] (String) */ - xField?: string; - /** [Config Option] (String/String[]) */ - yField?: any; - /** [Method] Iterates over a given record s values for each of this series s yFields executing a given function for each value - * @param record Ext.data.IModel - * @param fn Function - * @param scope Object - */ - eachYValue?( record?:Ext.data.IModel, fn?:any, scope?:any ): void; - /** [Method] Calculate the min and max values for this series s xField */ - getMinMaxXValues?(): any[]; - /** [Method] Calculate the min and max values for this series s yField s */ - getMinMaxYValues?(): any[]; - /** [Method] Returns an array of functions each of which returns the value of the yField corresponding to function s index in the */ - getYValueAccessors?(): any[]; - /** [Method] Returns the number of yField values taking into account fields combined via legend drag drop */ - getYValueCount?(): number; - } -} -declare module Ext.chart { - export interface ICartesianChart extends Ext.chart.series.ISeries { - /** [Config Option] (String/String[]) The position of the axis to bind the values to. ... */ - axis?: any; - /** [Config Option] (String) */ - xField?: string; - /** [Config Option] (String/String[]) */ - yField?: any; - /** [Method] Iterates over a given record s values for each of this series s yFields executing a given function for each value - * @param record Ext.data.IModel - * @param fn Function - * @param scope Object - */ - eachYValue?( record?:Ext.data.IModel, fn?:any, scope?:any ): void; - /** [Method] Calculate the min and max values for this series s xField */ - getMinMaxXValues?(): any[]; - /** [Method] Calculate the min and max values for this series s yField s */ - getMinMaxYValues?(): any[]; - /** [Method] Returns an array of functions each of which returns the value of the yField corresponding to function s index in the */ - getYValueAccessors?(): any[]; - /** [Method] Returns the number of yField values taking into account fields combined via legend drag drop */ - getYValueCount?(): number; - } -} -declare module Ext.chart { - export interface ICartesianSeries extends Ext.chart.series.ISeries { - /** [Config Option] (String/String[]) The position of the axis to bind the values to. ... */ - axis?: any; - /** [Config Option] (String) */ - xField?: string; - /** [Config Option] (String/String[]) */ - yField?: any; - /** [Method] Iterates over a given record s values for each of this series s yFields executing a given function for each value - * @param record Ext.data.IModel - * @param fn Function - * @param scope Object - */ - eachYValue?( record?:Ext.data.IModel, fn?:any, scope?:any ): void; - /** [Method] Calculate the min and max values for this series s xField */ - getMinMaxXValues?(): any[]; - /** [Method] Calculate the min and max values for this series s yField s */ - getMinMaxYValues?(): any[]; - /** [Method] Returns an array of functions each of which returns the value of the yField corresponding to function s index in the */ - getYValueAccessors?(): any[]; - /** [Method] Returns the number of yField values taking into account fields combined via legend drag drop */ - getYValueCount?(): number; - } -} -declare module Ext.chart.series { - export interface IColumn extends Ext.chart.series.IBar { - /** [Config Option] (String) The position of the axis to bind the values to. ... */ - axis?: string; - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - } -} -declare module Ext.chart { - export interface IColumnChart extends Ext.chart.series.IBar { - /** [Config Option] (String) The position of the axis to bind the values to. ... */ - axis?: string; - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - } -} -declare module Ext.chart { - export interface IColumnSeries extends Ext.chart.series.IBar { - /** [Config Option] (String) The position of the axis to bind the values to. ... */ - axis?: string; - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - } -} -declare module Ext.chart { - export interface IStackedColumnChart extends Ext.chart.series.IBar { - /** [Config Option] (String) The position of the axis to bind the values to. ... */ - axis?: string; - /** [Config Option] (Boolean) Whether to set the visualization as column chart or horizontal bar chart. ... */ - column?: boolean; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (Number/Object) Padding between the left/right axes and the bars. ... */ - xPadding?: any; - /** [Config Option] (Number/Object) Padding between the top/bottom axes and the bars. ... */ - yPadding?: any; - } -} -declare module Ext.chart.series { - export interface IGauge extends Ext.chart.series.ISeries { - /** [Config Option] (String) The store record field name to be used for the pie angles. ... */ - angleField?: string; - /** [Config Option] (Boolean/Number) Use the entire disk or just a fraction of it for the gauge. ... */ - donut?: any; - /** [Config Option] (Number) The duration for the pie slice highlight effect. ... */ - highlightDuration?: number; - /** [Config Option] (Boolean) Use the Gauge Series as an area series or add a needle to it. ... */ - needle?: boolean; - /** [Config Option] (Boolean) Whether to add the pie chart elements as legend items. ... */ - showInLegend?: boolean; - /** [Config Option] (Object) An object containing styles for overriding series styles from Theming. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns the color of the series to be displayed as color for the series legend item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - getLegendColor?( item?:any ): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Sets the Gauge chart to the current specified value - * @param value Object - */ - setValue?( value?:any ): void; - } -} -declare module Ext.chart.series { - export interface ILine extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) If true, the area below the line will be filled in using the eefill and opacity config properties. ... */ - fill?: boolean; - /** [Config Option] (Object) The display style for the markers. ... */ - markerConfig?: any; - /** [Config Option] (Number) The offset distance from the cursor position to the line series to trigger events (then used for highlighting series,... */ - selectionTolerance?: number; - /** [Config Option] (Boolean) Whether markers should be displayed at the data points along the line. ... */ - showMarkers?: boolean; - /** [Config Option] (Boolean/Number) If set to true or a non-zero number, the line will be smoothed/rounded around its points; otherwise straight line seg... */ - smooth?: any; - /** [Config Option] (Object) An object containing style properties for the visualization lines and fill. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] called when a label is to be created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] called when a label is to be created - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart { - export interface ILineChart extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) If true, the area below the line will be filled in using the eefill and opacity config properties. ... */ - fill?: boolean; - /** [Config Option] (Object) The display style for the markers. ... */ - markerConfig?: any; - /** [Config Option] (Number) The offset distance from the cursor position to the line series to trigger events (then used for highlighting series,... */ - selectionTolerance?: number; - /** [Config Option] (Boolean) Whether markers should be displayed at the data points along the line. ... */ - showMarkers?: boolean; - /** [Config Option] (Boolean/Number) If set to true or a non-zero number, the line will be smoothed/rounded around its points; otherwise straight line seg... */ - smooth?: any; - /** [Config Option] (Object) An object containing style properties for the visualization lines and fill. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] called when a label is to be created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] called when a label is to be created - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart { - export interface ILineSeries extends Ext.chart.series.ICartesian { - /** [Config Option] (Boolean) If true, the area below the line will be filled in using the eefill and opacity config properties. ... */ - fill?: boolean; - /** [Config Option] (Object) The display style for the markers. ... */ - markerConfig?: any; - /** [Config Option] (Number) The offset distance from the cursor position to the line series to trigger events (then used for highlighting series,... */ - selectionTolerance?: number; - /** [Config Option] (Boolean) Whether markers should be displayed at the data points along the line. ... */ - showMarkers?: boolean; - /** [Config Option] (Boolean/Number) If set to true or a non-zero number, the line will be smoothed/rounded around its points; otherwise straight line seg... */ - smooth?: any; - /** [Config Option] (Object) An object containing style properties for the visualization lines and fill. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] called when a label is to be created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] called when a label is to be created - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart.series { - export interface IPie extends Ext.chart.series.ISeries { - /** [Config Option] (String) The store record field name to be used for the pie angles. ... */ - angleField?: string; - /** [Config Option] (Array) */ - colorSet?: any[]; - /** [Config Option] (Boolean/Number) Whether to set the pie chart as donut chart. ... */ - donut?: any; - /** [Config Option] (String) */ - field?: string; - /** [Config Option] (Number) The duration for the pie slice highlight effect. ... */ - highlightDuration?: number; - /** [Config Option] (String) The store record field name to be used for the pie slice lengths. ... */ - lengthField?: string; - /** [Config Option] (Boolean) Whether to add the pie chart elements as legend items. ... */ - showInLegend?: boolean; - /** [Config Option] (Object) An object containing styles for overriding series styles from Theming. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (String) */ - xField?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns the color of the series to be displayed as color for the series legend item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - getLegendColor?( item?:any ): void; - /** [Method] Highlight the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - highlightItem?( item?:any ): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlights the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - unHighlightItem?( item?:any ): void; - } -} -declare module Ext.chart { - export interface IPieChart extends Ext.chart.series.ISeries { - /** [Config Option] (String) The store record field name to be used for the pie angles. ... */ - angleField?: string; - /** [Config Option] (Array) */ - colorSet?: any[]; - /** [Config Option] (Boolean/Number) Whether to set the pie chart as donut chart. ... */ - donut?: any; - /** [Config Option] (String) */ - field?: string; - /** [Config Option] (Number) The duration for the pie slice highlight effect. ... */ - highlightDuration?: number; - /** [Config Option] (String) The store record field name to be used for the pie slice lengths. ... */ - lengthField?: string; - /** [Config Option] (Boolean) Whether to add the pie chart elements as legend items. ... */ - showInLegend?: boolean; - /** [Config Option] (Object) An object containing styles for overriding series styles from Theming. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (String) */ - xField?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns the color of the series to be displayed as color for the series legend item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - getLegendColor?( item?:any ): void; - /** [Method] Highlight the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - highlightItem?( item?:any ): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlights the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - unHighlightItem?( item?:any ): void; - } -} -declare module Ext.chart { - export interface IPieSeries extends Ext.chart.series.ISeries { - /** [Config Option] (String) The store record field name to be used for the pie angles. ... */ - angleField?: string; - /** [Config Option] (Array) */ - colorSet?: any[]; - /** [Config Option] (Boolean/Number) Whether to set the pie chart as donut chart. ... */ - donut?: any; - /** [Config Option] (String) */ - field?: string; - /** [Config Option] (Number) The duration for the pie slice highlight effect. ... */ - highlightDuration?: number; - /** [Config Option] (String) The store record field name to be used for the pie slice lengths. ... */ - lengthField?: string; - /** [Config Option] (Boolean) Whether to add the pie chart elements as legend items. ... */ - showInLegend?: boolean; - /** [Config Option] (Object) An object containing styles for overriding series styles from Theming. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (String) */ - xField?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] Returns the color of the series to be displayed as color for the series legend item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - getLegendColor?( item?:any ): void; - /** [Method] Highlight the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - highlightItem?( item?:any ): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Un highlights the specified item - * @param item Object {Object} Info about the item; same format as returned by getItemForPoint - */ - unHighlightItem?( item?:any ): void; - } -} -declare module Ext.chart.series { - export interface IRadar extends Ext.chart.series.ISeries { - /** [Config Option] (Object) The display style for the markers. ... */ - markerConfig?: any; - /** [Config Option] (Boolean) Whether to show this series in the legend. ... */ - showInLegend?: boolean; - /** [Config Option] (Boolean) Whether markers should be displayed at the data points of the series. ... */ - showMarkers?: boolean; - /** [Config Option] (Object) An object containing styles for overriding series styles from Theming. ... */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Config Option] (String) */ - xField?: string; - /** [Config Option] (String) */ - yField?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart.series { - export interface IScatter extends Ext.chart.series.ICartesian { - /** [Config Option] (Object) */ - markerConfig?: any; - /** [Config Option] (Object) */ - style?: any; - /** [Config Option] (String) End Definitions The type of series. ... */ - type?: string; - /** [Method] Draws the series for the current chart */ - drawSeries?(): void; - /** [Method] callback for when creating a label sprite - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] callback for when placing a label sprite - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - } -} -declare module Ext.chart.series { - export interface ISeries extends Ext.IBase,Ext.chart.ICallout,Ext.chart.IHighlight,Ext.chart.ILabel,Ext.chart.ITip,Ext.util.IObservable { - /** [Config Option] (Boolean/Object) If set to true it will highlight the markers or the series when hovering with the mouse. ... */ - highlight?: any; - /** [Config Option] (Object) An (optional) object with event callbacks. ... */ - listeners?: any; - /** [Config Option] (Function) A function that can be overridden to set custom styling properties to each rendered element. ... */ - renderer?: any; - /** [Config Option] (Array) */ - shadowAttributes?: any[]; - /** [Config Option] (Boolean) Whether to show this series in the legend. ... */ - showInLegend?: boolean; - /** [Config Option] (Object) Add tooltips to the visualization's markers. ... */ - tips?: any; - /** [Config Option] (String) */ - title?: string; - /** [Config Option] (String) The type of series. ... */ - type?: string; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Iterate over each of the records for this series - * @param fn Function The function to execute for each record. - * @param scope Object Scope for the fn. - */ - eachRecord?( fn?:any, scope?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] For a given x y point relative to the Surface find a corresponding item from this series if any - * @param x Number - * @param y Number - */ - getItemForPoint?( x?:number, y?:number ): any; - /** [Method] Returns a string with the color to be used for the series legend item - * @param index Object - */ - getLegendColor?( index?:any ): void; - /** [Method] Return the number of records being displayed in this series */ - getRecordCount?(): void; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Hides all the elements in the series */ - hideAll?(): void; - /** [Method] Highlight the given series item - * @param item Object Info about the item; same format as returned by getItemForPoint. - */ - highlightItem?( item?:any ): void; - /** [Method] Determines whether the series item at the given index has been excluded i e - * @param index Object - */ - isExcluded?( index?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Called each time a new label is created - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element created (i.e the first created label, second created label, etc). - * @param display Boolean The display type. May be false if the label is hidden - */ - onCreateLabel?( storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean ): Ext.draw.ISprite; - /** [Method] Called for updating the position of the label - * @param label Ext.draw.ISprite The sprite label. - * @param storeItem Ext.data.IModel The element of the store that is related to the label sprite. - * @param item Object The item related to the label sprite. An item is an object containing the position of the shape used to describe the visualization and also pointing to the actual shape (circle, rectangle, path, etc). - * @param i Number The index of the element to be updated (i.e. whether it is the first, second, third from the labelGroup) - * @param display Boolean The display type. May be false if the label is hidden - * @param animate Boolean A boolean value to set or unset animations for the labels. - * @param index Number The series index. - */ - onPlaceLabel?( label?:Ext.draw.ISprite, storeItem?:Ext.data.IModel, item?:any, i?:number, display?:boolean, animate?:boolean, index?:number ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Changes the value of the title for the series - * @param index Number - * @param title String - */ - setTitle?( index?:number, title?:string ): void; - /** [Method] Shows all the elements in the series */ - showAll?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Un highlight any existing highlights */ - unHighlightItem?(): void; - } -} -declare module Ext.chart { - export interface IShape extends Ext.IBase { - } - export class Shape { - } -} -declare module Ext.chart.theme { - export interface IBase extends Ext.IBase { - } -} -declare module Ext.chart.theme { - export interface ITheme { - } -} -declare module Ext.chart { - export interface ITip extends Ext.IBase { - } -} -declare module Ext.chart { - export interface ITipSurface extends Ext.draw.IComponent { - } -} -declare module Ext { - export interface IClass { - /** [Config Option] (String[]) List of short aliases for class names. ... */ - alias?: string[]; - /** [Config Option] (String/String[]) Defines alternate names for this class. ... */ - alternateClassName?: any; - /** [Config Option] (Object) List of configuration options with their default values, for which automatically accessor methods are generated. ... */ - config?: any; - /** [Config Option] (String) The parent class that this class extends. ... */ - extend?: string; - /** [Config Option] (Object) List of inheritable static methods for this class. ... */ - inheritableStatics?: any; - /** [Config Option] (String[]/Object) List of classes to mix into this class. ... */ - mixins?: any; - /** [Config Option] (String[]) List of classes that have to be loaded before instantiating this class. ... */ - requires?: string[]; - /** [Config Option] (Boolean) When set to true, the class will be instantiated as singleton. ... */ - singleton?: boolean; - /** [Config Option] (Object) List of static methods for this class. ... */ - statics?: any; - /** [Config Option] (String[]) List of optional classes to load together with this class. ... */ - uses?: string[]; - } -} -declare module Ext { - export interface IClassManager { - } - export class ClassManager { - /** [Method] Adds a batch of class name to alias mappings - * @param aliases Object The set of mappings of the form className : [values...] - */ - static addNameAliasMappings( aliases?:any ): Ext.IClassManager; - /** [Method] - * @param alternates Object The set of mappings of the form className : [values...] - */ - static addNameAlternateMappings( alternates?:any ): Ext.IClassManager; - /** [Method] Retrieve a class by its name - * @param name String - */ - static get( name?:string ): Ext.IClass; - /** [Method] Get the aliases of a class by the class name - * @param name String - */ - static getAliasesByName( name?:string ): any[]; - /** [Method] Get a reference to the class by its alias - * @param alias String - */ - static getByAlias( alias?:string ): Ext.IClass; - /** [Method] Get the class of the provided object returns null if it s not an instance of any class created with Ext define - * @param object Object - */ - static getClass( object?:any ): Ext.IClass; - /** [Method] Returns the displayName property or className or object - * @param object Object - */ - static getDisplayName( object?:any ): string; - /** [Method] Get the name of the class by its reference or its instance getName is usually invoked by the shorthand Ext getClass - * @param object any - */ - static getName( object?:any ): string; - /** [Method] Get the name of a class by its alias - * @param alias String - */ - static getNameByAlias( alias?:string ): string; - /** [Method] Get the name of a class by its alternate name - * @param alternate String - */ - static getNameByAlternate( alternate?:string ): string; - /** [Method] Converts a string expression to an array of matching class names - * @param expression String - */ - static getNamesByExpression( expression?:string ): string[]; - /** [Method] Instantiate a class by its alias - * @param alias String - * @param args Object... Additional arguments after the alias will be passed to the class constructor. - */ - static instantiateByAlias( alias:string, ...args:any[] ): any; - /** [Method] Checks if a class has already been created - * @param className String - */ - static isCreated( className?:string ): boolean; - /** [Method] Sets a name reference to a class - * @param name String - * @param value Object - */ - static set( name?:string, value?:any ): Ext.IClassManager; - /** [Method] Register the alias for a class - * @param cls any a reference to a class or a className - * @param alias any Alias to use when referring to this class - */ - static setAlias( cls?:any, alias?:any ): any; - static setAlias( cls?:Ext.IClass, alias?:string ): Ext.IClassManager; - static setAlias( cls?:string, alias?:string ): Ext.IClassManager; - /** [Method] Creates a namespace and assign the value to the created object Ext ClassManager setNamespace MyCompany pkg Example - * @param name String - * @param value Object - */ - static setNamespace( name?:string, value?:any ): void; - } -} -declare module Ext { - export interface IComponent extends Ext.IAbstractComponent,Ext.util.IFloating { - /** [Config Option] (Boolean) true to use overflow:'auto' on the components layout element and show scroll bars automatically when necessary, false... */ - autoScroll?: boolean; - /** [Config Option] (Number/String) Defines the column width inside column layout. ... */ - columnWidth?: any; - /** [Config Option] (Ext.util.Region/Ext.Element) A Region (or an element from which a Region measurement will be read) which is used to constrain the component. ... */ - constrainTo?: any; - /** [Config Option] (String) The default Ext.Element#getAlignToXY anchor position value for this menu relative to its element of origin. ... */ - defaultAlign?: string; - /** [Config Option] (Boolean) Specify as true to float the Component outside of the document flow using CSS absolute positioning. ... */ - floating?: boolean; - /** [Config Option] (Boolean) When inside FormPanel, any component configured with formBind: true will be enabled/disabled depending on the validit... */ - formBind?: boolean; - /** [Config Option] (String) Possible values are: * 'auto' to enable automatic horizontal scrollbar (overflow-x: 'auto'). ... */ - overflowX?: string; - /** [Config Option] (String) Possible values are: * 'auto' to enable automatic vertical scrollbar (overflow-y: 'auto'). ... */ - overflowY?: string; - /** [Config Option] ("north"/"south"/"east"/"west"/"center") Defines the region inside border layout. ... */ - region?: any; - /** [Config Option] (Boolean/Object) Specify as true to apply a Resizer to this Component after rendering. ... */ - resizable?: any; - /** [Config Option] (String) A valid Ext.resizer.Resizer handles config string. ... */ - resizeHandles?: string; - /** [Config Option] (Boolean) True to automatically call toFront when the show method is called on an already visible, floating component. ... */ - toFrontOnShow?: boolean; - /** [Property] (Ext.Container) Only present for floating Components which were inserted as child items of Containers. ... */ - floatParent?: Ext.IContainer; - /** [Property] (Object) An object property which provides unified information as to which dimensions are scrollable based upon the autoScroll... */ - scrollFlags?: any; - /** [Property] (Ext.ZIndexManager) Only present for floating Components after they have been rendered. ... */ - zIndexManager?: Ext.IZIndexManager; - /** [Property] (Ext.Container) Only present for floating Components which were inserted as child items of Containers, and which have a floating Cont... */ - zIndexParent?: Ext.IContainer; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Invoked after the Component has been hidden - * @param callback Function - * @param scope Object - */ - afterHide?( callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Template method called after a Component has been positioned - * @param x Number - * @param y Number - */ - afterSetPosition?( x?:number, y?:number ): void; - /** [Method] Invoked after the Component is shown after onShow is called - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - afterShow?( animateTarget?:string, callback?:any, scope?:any ): void; - afterShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Invoked before the Component is shown */ - beforeShow?(): void; - /** [Method] Bubbles up the component container heirarchy calling the specified function with each component - * @param fn Function The function to call - * @param scope Object The scope of the function. Defaults to current node. - * @param args Array The args to call the function with. Defaults to passing the current component. - */ - bubble?( fn?:any, scope?:any, args?:any[] ): Ext.IComponent; - /** [Method] Cancel any deferred focus on this component */ - cancelFocus?(): void; - /** [Method] Center this Component in its container */ - center?(): Ext.IComponent; - /** [Method] Clone the current component using the original config values passed into this instance by default - * @param overrides Object A new config containing any properties to override in the cloned version. An id property can be passed on this object, otherwise one will be generated to avoid duplicates. - */ - cloneConfig?( overrides?:any ): Ext.IComponent; - /** [Method] Moves this floating Component into a constrain region - * @param constrainTo String The Element or Region into which this Component is to be constrained. Defaults to the element into which this floating Component was rendered. - */ - doConstrain?( constrainTo?:string ): void; - doConstrain?( constrainTo?:HTMLElement ): void; - doConstrain?( constrainTo?:Ext.IElement ): void; - doConstrain?( constrainTo?:Ext.util.IRegion ): void; - /** [Method] Find a container above this component at any level by a custom function - * @param fn Function The custom function to call with the arguments (container, this component). - */ - findParentBy?( fn?:any ): Ext.container.IContainer; - /** [Method] Find a container above this component at any level by xtype or class See also the up method - * @param xtype any The xtype string for a component, or the class of the component directly - */ - findParentByType?( xtype?:any ): any; - findParentByType?( xtype?:string ): Ext.container.IContainer; - findParentByType?( xtype?:Ext.IClass ): Ext.container.IContainer; - /** [Method] Try to focus this component - * @param selectText any If applicable, true to also select the text in this component - * @param delay any Delay the focus this number of milliseconds (true for 10 milliseconds). - */ - focus?( selectText?:any, delay?:any ): any; - focus?( selectText?:boolean, delay?:boolean ): Ext.IComponent; - focus?( selectText?:boolean, delay?:number ): Ext.IComponent; - /** [Method] Implements an upward event bubbling policy */ - getBubbleTarget? (): Ext.IContainer; - /** [Method] Retrieves the top level element representing this component */ - getEl?(): Ext.dom.IElement; - /** [Method] Retrieves the id of this component */ - getId?(): string; - /** [Method] Gets the current XY position of the component s underlying element - * @param local Boolean If true the element's left and top are returned instead of page XY. - */ - getPosition?( local?:boolean ): number[]; - /** [Method] Used by ComponentQuery and the up method to find the owning Component in the linkage hierarchy */ - getRefOwner?(): void; - /** [Method] Gets the xtype for this component as registered with Ext ComponentManager */ - getXType?(): string; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Method to manage awareness of when components are added to their respective Container firing an added event - * @param container Ext.container.IContainer Container which holds the component. - * @param pos Number Position at which the component was added. - */ - onAdded?( container?:Ext.container.IContainer, pos?:number ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Invoked after the afterShow method is complete - * @param callback Function - * @param scope Object - */ - onShowComplete?( callback?:any, scope?:any ): void; - /** [Method] Scrolls this Component s target element by the passed delta values optionally animating - * @param deltaX any Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties. - * @param deltaY any Either the y delta, or an animate flag or config object. - * @param animate any Animate flag/config object if the delta values were passed separately. - */ - scrollBy?( deltaX?:any, deltaY?:any, animate?:any ): void; - /** [Method] This method is called internally by Ext ZIndexManager to signal that a floating Component has either been moved to th - * @param active Boolean True to activate the Component, false to deactivate it. - * @param newActive Ext.IComponent The newly active Component which is taking over topmost zIndex position. - */ - setActive?( active?:boolean, newActive?:Ext.IComponent ): void; - /** [Method] Sets the overflow on the content element of the component - * @param scroll Boolean True to allow the Component to auto scroll. - */ - setAutoScroll?( scroll?:boolean ): Ext.IComponent; - /** [Method] This method allows you to show or hide a LoadMask on top of this component - * @param load any True to show the default LoadMask, a config object that will be passed to the LoadMask constructor, or a message String to show. False to hide the current LoadMask. - * @param targetEl Boolean True to mask the targetEl of this Component instead of the this.el. For example, setting this to true on a Panel will cause only the body to be masked. - */ - setLoading?( load?:any, targetEl?:boolean ): Ext.ILoadMask; - /** [Method] Sets the overflow x y on the content element of the component - * @param overflowX String The overflow-x value. - * @param overflowY String The overflow-y value. - */ - setOverflowXY?( overflowX?:string, overflowY?:string ): Ext.IComponent; - /** [Method] Sets the page XY position of the component - * @param x any The new x position or an array of [x,y]. - * @param y any The new y position. - * @param animate any True to animate the Component into its new position. You may also pass an animation configuration. - */ - setPagePosition?( x?:any, y?:any, animate?:any ): any; - setPagePosition?( x?:number, y?:number, animate?:any ): Ext.IComponent; - setPagePosition?( x?:number[], y?:number, animate?:any ): Ext.IComponent; - /** [Method] Sets the left and top of the component - * @param x any The new left, an array of [x,y], or animation config object containing x and y properties. - * @param y Number The new top. - * @param animate any If true, the Component is animated into its new position. You may also pass an animation configuration. - */ - setPosition?( x?:any, y?:number, animate?:any ): Ext.IComponent; - /** [Method] Shows this Component rendering it first if autoRender or floating are true - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening. - * @param callback any A callback function to call after the Component is displayed. Only necessary if animation was specified. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - show?( animateTarget?:any, callback?:any, scope?:any ): any; - show?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - show?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] Displays component at specific xy position - * @param x any The new x position or array of [x,y]. - * @param y any The new y position - * @param animate any True to animate the Component into its new position. You may also pass an animation configuration. - */ - showAt?( x?:any, y?:any, animate?:any ): any; - showAt?( x?:number, y?:number, animate?:any ): Ext.IComponent; - showAt?( x?:number[], y?:number, animate?:any ): Ext.IComponent; - /** [Method] Shows this component by the specified Component or Element - * @param component any The Ext.Component or Ext.Element to show the component by. - * @param position any Alignment position as used by Ext.util.Positionable.getAlignToXY. Defaults to defaultAlign. - * @param offsets any Alignment offsets as used by Ext.util.Positionable.getAlignToXY. - */ - showBy?( component?:any, position?:any, offsets?:any ): any; - showBy?( component?:Ext.IComponent, position?:string, offsets?:number[] ): Ext.IComponent; - showBy?( component?:Ext.IElement, position?:string, offsets?:number[] ): Ext.IComponent; - /** [Method] Sends this Component to the back of lower z index than any other visible windows */ - toBack?(): Ext.IComponent; - /** [Method] Brings this floating Component to the front of any other visible floating Components managed by the same ZIndexManag - * @param preventFocus Boolean Specify true to prevent the Component from being focused. - */ - toFront?( preventFocus?:boolean ): Ext.IComponent; - /** [Method] Sets the current box measurements of the component s underlying element - * @param box Object An object in the format {x, y, width, height} - */ - updateBox?( box?:any ): Ext.IComponent; - } -} -declare module Ext { - export interface IComponentLoader extends Ext.IElementLoader { - /** [Config Option] (Boolean/Object) True or a Ext.LoadMask configuration to enable masking during loading. ... */ - loadMask?: any; - /** [Config Option] (Boolean) True to parse any inline script tags in the response. ... */ - scripts?: boolean; - /** [Config Option] (Ext.Component/String) The target Ext.Component for the loader. ... */ - target?: any; - /** [Method] Set a Ext Component as the target of this loader - * @param target String The component to be the target of this loader. If a string is passed it will be looked up via its id. - */ - setTarget?( target?:string ): void; - setTarget?( target?:Ext.IComponent ): void; - } -} -declare module Ext { - export interface IComponentManager extends Ext.IAbstractManager { - } - export class ComponentManager { - /** [Method] Creates a new Component from the specified config object using the config object s xtype to determine the class to in - * @param config Object A configuration object for the Component you wish to create. - * @param defaultType String The xtype to use if the config object does not contain a xtype. (Optional if the config contains a xtype). - */ - static create( config?:any, defaultType?:string ): Ext.IComponent; - /** [Method] Registers a new item constructor keyed by a type key - * @param type String The mnemonic string by which the class may be looked up. - * @param cls Function The new instance class. - */ - static registerType( type?:string, cls?:any ): void; - } -} -declare module Ext { - export interface IComponentMgr extends Ext.IAbstractManager { - } - export class ComponentMgr { - /** [Method] Creates a new Component from the specified config object using the config object s xtype to determine the class to in - * @param config Object A configuration object for the Component you wish to create. - * @param defaultType String The xtype to use if the config object does not contain a xtype. (Optional if the config contains a xtype). - */ - static create( config?:any, defaultType?:string ): Ext.IComponent; - /** [Method] Registers a new item constructor keyed by a type key - * @param type String The mnemonic string by which the class may be looked up. - * @param cls Function The new instance class. - */ - static registerType( type?:string, cls?:any ): void; - } -} -declare module Ext { - export interface IComponentQuery extends Ext.IBase { - } - export class ComponentQuery { - /** [Method] Tests whether the passed Component matches the selector string - * @param component Ext.IComponent The Component to test - * @param selector String The selector string to test against. - */ - static is( component?:Ext.IComponent, selector?:string ): boolean; - /** [Method] Returns an array of matched Components from within the passed root object - * @param selector String The selector string to filter returned Components - * @param root Ext.container.IContainer The Container within which to perform the query. If omitted, all Components within the document are included in the search. This parameter may also be an array of Components to filter according to the selector. - */ - static query( selector?:string, root?:Ext.container.IContainer ): Ext.IComponent[]; - } -} -declare module Ext.container { - export interface IAbstractContainer extends Ext.IComponent { - /** [Config Option] (String/Number) A string component id or the numeric index of the component that should be initially activated within the container's... */ - activeItem?: any; - /** [Config Option] (Boolean) If true the container will automatically destroy any contained component that is removed from it, else destruction mu... */ - autoDestroy?: boolean; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String[]) An array of events that, when fired, should be bubbled to any parent container. ... */ - bubbleEvents?: string[]; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Object/Function) This option is a means of applying default settings to all added items whether added through the items config or via ... */ - defaults?: any; - /** [Config Option] (Boolean) True to move any component to the detachedBody when the component is removed from this container. ... */ - detachOnRemove?: boolean; - /** [Config Option] (Object/Object[]) A single item, or an array of child Components to be added to this container Unless configured with a layout, a Cont... */ - items?: any; - /** [Config Option] (Ext.enums.Layout/Object) Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specifie... */ - layout?: any; - /** [Config Option] (Ext.XTemplate/String/String[]) End Definitions An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Boolean) If true, suspend calls to doLayout. ... */ - suspendLayout?: boolean; - /** [Method] Adds Component s to this Container - * @param component any Either one or more Components to add or an Array of Components to add. See items for additional information. - */ - add?( component?:any ): any; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Invoked after the Container has laid out and rendered if necessary its child Components - * @param layout Ext.layout.container.IContainer - */ - afterLayout?( layout?:Ext.layout.container.IContainer ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Cascades down the component container heirarchy from this component passed in the first call calling the specified - * @param fn Function The function to call - * @param scope Object The scope of the function (defaults to current component) - * @param args Array The args to call the function with. The current component always passed as the last argument. - */ - cascade?( fn?:any, scope?:any, args?:any[] ): Ext.IContainer; - /** [Method] Retrieves the first direct child of this container which matches the passed selector or component - * @param selector any An Ext.ComponentQuery selector. If no selector is specified, the first child will be returned. - */ - child?( selector?:any ): any; - child?( selector?:string ): any; - child?( selector?:Ext.IComponent ): any; - /** [Method] Determines whether the passed Component is either an immediate child of this Container or whether it is a descendant - * @param comp Ext.IComponent The Component to test. - * @param deep Boolean Pass true to test for the Component being a descendant at any level. - */ - contains?( comp?:Ext.IComponent, deep?:boolean ): boolean; - /** [Method] Inherit docs Disable all immediate children that was previously disabled Override disable because onDisable only gets - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): Ext.container.IAbstractContainer; - /** [Method] Manually force this container s layout to be recalculated */ - doLayout?(): Ext.container.IContainer; - /** [Method] Retrieves the first descendant of this container which matches the passed selector - * @param selector any An Ext.ComponentQuery selector or Ext.Component. If no selector is specified, the first child will be returned. - */ - down?( selector?:any ): any; - down?( selector?:string ): any; - down?( selector?:Ext.IComponent ): any; - /** [Method] Examines this container s items property and gets a direct child component of this container - * @param comp any This parameter may be any of the following: a String : representing the itemId or id of the child component. a Number : representing the position of the child component within the items property For additional information see Ext.util.MixedCollection.get. - */ - getComponent?( comp?:any ): any; - getComponent?( comp?:string ): Ext.IComponent; - getComponent?( comp?:number ): Ext.IComponent; - /** [Method] Returns the layout instance currently associated with this Container */ - getLayout?(): Ext.layout.container.IContainer; - /** [Method] Used by ComponentQuery child and down to retrieve all of the items which can potentially be considered a child of th - * @param deep Object - */ - getRefItems?( deep?:any ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Inserts a Component into this Container at a specified index - * @param index Number The index at which the Component will be inserted into the Container's items collection - * @param component any The child Component to insert. Ext uses lazy rendering, and will only render the inserted Component should it become necessary. A Component config object may be passed in order to avoid the overhead of constructing a real Component object if lazy rendering might mean that the inserted Component will not be rendered immediately. To take advantage of this 'lazy instantiation', set the Ext.Component.xtype config property to the registered type of the Component wanted. For a list of all available xtypes, see Ext.enums.Widget. - */ - insert?( index?:number, component?:any ): Ext.IComponent; - /** [Method] Determines whether this Container is an ancestor of the passed Component - * @param possibleDescendant Ext.IComponent The Component to test for presence within this Container's subtree. - */ - isAncestor?( possibleDescendant?:Ext.IComponent ): void; - /** [Method] Moves a Component within the Container - * @param fromIdx Number The index the Component you wish to move is currently at. - * @param toIdx Number The new index for the Component. - */ - move?( fromIdx?:number, toIdx?:number ): Ext.IComponent; - /** [Method] This method is invoked after a new Component has been added - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] This method is invoked before adding a new child Component - * @param item Ext.IComponent - */ - onBeforeAdd?( item?:Ext.IComponent ): void; - /** [Method] Called after the component is moved this method is empty by default but can be implemented by any subclass that need - * @param x Number The new x position. - * @param y Number The new y position. - */ - onPosition?( x?:number, y?:number ): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] Allows addition of behavior to the resize operation - * @param width Object - * @param height Object - * @param oldWidth Object - * @param oldHeight Object - */ - onResize?( width?:any, height?:any, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Retrieves all descendant components which match the passed selector - * @param selector String Selector complying to an Ext.ComponentQuery selector. If no selector is specified all items will be returned. - */ - query?( selector?:string ): Ext.IComponent[]; - /** [Method] Retrieves all descendant components which match the passed function - * @param fn Function The matcher function. It will be called with a single argument, the component being tested. - * @param scope Object The scope in which to run the function. If not specified, it will default to the active component. - */ - queryBy?( fn?:any, scope?:any ): Ext.IComponent[]; - /** [Method] Finds a component at any level under this container matching the id itemId - * @param id String The id to find - */ - queryById?( id?:string ): Ext.IComponent; - /** [Method] Removes a component from this container - * @param component any The component reference or id to remove. - * @param autoDestroy any True to automatically invoke the removed Component's Ext.Component.destroy function. Defaults to the value of this Container's autoDestroy config. - */ - remove?( component?:any, autoDestroy?:any ): any; - remove?( component?:Ext.IComponent, autoDestroy?:boolean ): Ext.IComponent; - remove?( component?:string, autoDestroy?:boolean ): Ext.IComponent; - /** [Method] Removes all components from this container - * @param autoDestroy Boolean True to automatically invoke the removed Component's Ext.Component.destroy function. Defaults to the value of this Container's autoDestroy config. - */ - removeAll?( autoDestroy?:boolean ): Ext.IComponent[]; - } -} -declare module Ext.container { - export interface IButtonGroup extends Ext.panel.IPanel { - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Number) The columns configuration property passed to the configured layout manager. ... */ - columns?: number; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Boolean) True to apply a frame to the panel. ... */ - frame?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specifie... */ - layout?: any; - /** [Config Option] (String) The alignment of the title text within the available space between the icon and the tools. ... */ - titleAlign?: string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private This method is invoked before adding a new child Component - * @param item Ext.IComponent - */ - onBeforeAdd?( item?:Ext.IComponent ): void; - } -} -declare module Ext { - export interface IButtonGroup extends Ext.panel.IPanel { - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Number) The columns configuration property passed to the configured layout manager. ... */ - columns?: number; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Boolean) True to apply a frame to the panel. ... */ - frame?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specifie... */ - layout?: any; - /** [Config Option] (String) The alignment of the title text within the available space between the icon and the tools. ... */ - titleAlign?: string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private This method is invoked before adding a new child Component - * @param item Ext.IComponent - */ - onBeforeAdd?( item?:Ext.IComponent ): void; - } -} -declare module Ext.container { - export interface IContainer extends Ext.container.IAbstractContainer { - /** [Config Option] (Number/Object) Defines the anchoring size of container. ... */ - anchorSize?: any; - /** [Method] Return the immediate child Component in which the passed element is located - * @param el any The element to test (or ID of element). - * @param deep any If true, returns the deepest descendant Component which contains the passed element. - */ - getChildByElement?( el?:any, deep?:any ): any; - getChildByElement?( el?:Ext.IElement, deep?:boolean ): Ext.IComponent; - getChildByElement?( el?:HTMLElement, deep?:boolean ): Ext.IComponent; - getChildByElement?( el?:string, deep?:boolean ): Ext.IComponent; - } -} -declare module Ext { - export interface IContainer extends Ext.container.IAbstractContainer { - /** [Config Option] (Number/Object) Defines the anchoring size of container. ... */ - anchorSize?: any; - /** [Method] Return the immediate child Component in which the passed element is located - * @param el any The element to test (or ID of element). - * @param deep any If true, returns the deepest descendant Component which contains the passed element. - */ - getChildByElement?( el?:any, deep?:any ): any; - getChildByElement?( el?:Ext.IElement, deep?:boolean ): Ext.IComponent; - getChildByElement?( el?:HTMLElement, deep?:boolean ): Ext.IComponent; - getChildByElement?( el?:string, deep?:boolean ): Ext.IComponent; - } -} -declare module Ext.container { - export interface IDockingContainer extends Ext.IBase { - /** [Config Option] (Object) This object holds the default weights applied to dockedItems that have no weight. ... */ - defaultDockWeights?: any; - /** [Method] Adds docked item s to the container - * @param component any The Component or array of components to add. The components must include a 'dock' parameter on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left'). - * @param pos Number The index at which the Component will be added - */ - addDocked?( component?:any, pos?:number ): Ext.IComponent[]; - /** [Method] Finds a docked component by id itemId or position - * @param comp any The id, itemId or position of the docked component (see getComponent for details) - */ - getDockedComponent?( comp?:any ): any; - getDockedComponent?( comp?:string ): Ext.IComponent; - getDockedComponent?( comp?:number ): Ext.IComponent; - /** [Method] Retrieves an array of all currently docked Components - * @param selector String A ComponentQuery selector string to filter the returned items. - * @param beforeBody Boolean An optional flag to limit the set of items to only those before the body (true) or after the body (false). All components are returned by default. - */ - getDockedItems?( selector?:string, beforeBody?:boolean ): Ext.IComponent[]; - /** [Method] Inserts docked item s to the panel at the indicated position - * @param pos Number The index at which the Component will be inserted - * @param component any The Component or array of components to add. The components must include a 'dock' paramater on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left'). - */ - insertDocked?( pos?:number, component?:any ): void; - /** [Method] Invoked after a docked item is added to the Panel - * @param component Ext.IComponent - */ - onDockedAdd?( component?:Ext.IComponent ): void; - /** [Method] Invoked after a docked item is removed from the Panel - * @param component Ext.IComponent - */ - onDockedRemove?( component?:Ext.IComponent ): void; - /** [Method] Removes the docked item from the panel - * @param item Ext.IComponent The Component to remove. - * @param autoDestroy Boolean Destroy the component after removal. - */ - removeDocked?( item?:Ext.IComponent, autoDestroy?:boolean ): void; - } -} -declare module Ext.container { - export interface IMonitor extends Ext.IBase { - } -} -declare module Ext.container { - export interface IViewport extends Ext.container.IContainer { - /** [Property] (Boolean) true in this class to identify an object as an instantiated Viewport, or subclass thereof. ... */ - isViewport?: boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - } -} -declare module Ext { - export interface IViewport extends Ext.container.IContainer { - /** [Property] (Boolean) true in this class to identify an object as an instantiated Viewport, or subclass thereof. ... */ - isViewport?: boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - } -} -declare module Ext.data { - export interface IAbstractStore extends Ext.IBase,Ext.util.IObservable,Ext.util.ISortable { - /** [Config Option] (Boolean/Object) If data is not specified, and if autoLoad is true or an Object, this store's load method is automatically called afte... */ - autoLoad?: any; - /** [Config Option] (Boolean) True to automatically sync the Store with its Proxy after every edit to one of its Records. ... */ - autoSync?: boolean; - /** [Config Option] (String) Sets the updating behavior based on batch synchronization. ... */ - batchUpdateMode?: string; - /** [Config Option] (Object[]) This may be used in place of specifying a model configuration. ... */ - fields?: Object[]; - /** [Config Option] (Boolean) If true, any filters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - filterOnLoad?: boolean; - /** [Config Option] (Object[]/Function[]) Array of Filters for this store. ... */ - filters?: any; - /** [Config Option] (String) Name of the Model associated with this store. ... */ - model?: string; - /** [Config Option] (String/Ext.data.proxy.Proxy/Object) The Proxy to use for this Store. ... */ - proxy?: any; - /** [Config Option] (Boolean) True to defer any filtering operation to the server. ... */ - remoteFilter?: boolean; - /** [Config Option] (Boolean) True to defer any sorting operation to the server. ... */ - remoteSort?: boolean; - /** [Config Option] (Boolean) If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - sortOnLoad?: boolean; - /** [Config Option] (Boolean) Configure as true to have the filters saved when a client grid saves its state. ... */ - statefulFilters?: boolean; - /** [Config Option] (String) Unique identifier for this store. ... */ - storeId?: string; - /** [Property] (String) The string type of the Proxy to create if none is specified. ... */ - defaultProxyType?: string; - /** [Property] (Boolean) True if the Store has already been destroyed. ... */ - isDestroyed?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Store, or subclass thereof. ... */ - isStore?: boolean; - /** [Property] (Ext.data.Model[]) Temporary cache in which removed model instances are kept until successfully synchronised with a Proxy, at which poin... */ - removed?: Ext.data.IModel[]; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns a comparator function which compares two items and returns 1 0 or 1 depending on the currently defined set */ - generateComparator?(): void; - /** [Method] Gets the first sorter from the sorters collection excluding any groupers that may be in place */ - getFirstSorter?(): Ext.util.ISorter; - /** [Method] Gets all records added or updated since the last commit */ - getModifiedRecords?(): Ext.data.IModel[]; - /** [Method] Returns all Model instances that are either currently a phantom e g */ - getNewRecords?(): Ext.data.IModel[]; - /** [Method] Returns the proxy currently attached to this proxy instance */ - getProxy?(): Ext.data.proxy.IProxy; - /** [Method] Returns any records that have been removed from the store but not yet destroyed on the proxy */ - getRemovedRecords?(): Ext.data.IModel[]; - /** [Method] Returns all Model instances that have been updated in the Store but not yet synchronized with the Proxy */ - getUpdatedRecords?(): Ext.data.IModel[]; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Performs initialization of this mixin */ - initSortable?(): void; - /** [Method] Returns true if the Store is currently performing a load operation */ - isLoading?(): boolean; - /** [Method] Loads the Store using its configured proxy - * @param options Object config object. This is passed into the Operation object that is created and then sent to the proxy's Ext.data.proxy.Proxy.read function - */ - load?( options?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Reloads the store using the last options passed to the load method - * @param options Object A config object which contains options which may override the options passed to the previous load call. - */ - reload?( options?:any ): void; - /** [Method] Removes all records from the store */ - removeAll?(): void; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes automatically syncing the Store with its Proxy */ - resumeAutoSync?(): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the Store s Proxy by string config object or Proxy instance - * @param proxy any The new Proxy, which can be either a type string, a configuration object or an Ext.data.proxy.Proxy instance - */ - setProxy?( proxy?:any ): Ext.data.proxy.IProxy; - /** [Method] Sorts the data in the Store by one or more of its properties - * @param sorters any Either a string name of one of the fields in this Store's configured Model, or an array of sorter configurations. - * @param direction any The overall direction to sort the data by. - */ - sort?( sorters?:any, direction?:any ): any; - sort?( sorters?:string, direction?:string ): Ext.util.ISorter[]; - sort?( sorters?:Ext.util.ISorter[], direction?:string ): Ext.util.ISorter[]; - /** [Method] Suspends automatically syncing the Store with its Proxy */ - suspendAutoSync?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Synchronizes the store with its proxy - * @param options Object Object containing one or more properties supported by the sync method (these get passed along to the underlying proxy's batch method): - */ - sync?( options?:any ): Ext.data.IStore; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IArrayStore extends Ext.data.IStore { - /** [Method] Loads an array of data straight into the Store - * @param data any Array of data to load. Any non-model instances will be cast into model instances first. - * @param append Boolean true to add the records to the existing records in the store, false to remove the old ones first. - */ - loadData?( data?:any, append?:boolean ): void; - } -} -declare module Ext.data.association { - export interface IAssociation extends Ext.IBase { - /** [Config Option] (String) The string name of the model that is being associated with. ... */ - associatedModel?: string; - /** [Config Option] (String) The name of the property in the data to read the association from. ... */ - associationKey?: string; - /** [Config Option] (String) The string name of the model that is being associated with. ... */ - model?: string; - /** [Config Option] (String) The string name of the model that owns the association. ... */ - ownerModel?: string; - /** [Config Option] (String) The name of the primary key on the associated model. ... */ - primaryKey?: string; - /** [Config Option] (Ext.data.reader.Reader) */ - reader?: Ext.data.reader.IReader; - /** [Property] (String) The name of the model is on the other end of the association (e.g. ... */ - associatedName?: string; - /** [Property] (String) */ - ownerName?: string; - /** [Method] Get a specialized reader for reading associated data */ - getReader?(): Ext.data.reader.IReader; - } -} -declare module Ext.data { - export interface IAssociation extends Ext.IBase { - /** [Config Option] (String) The string name of the model that is being associated with. ... */ - associatedModel?: string; - /** [Config Option] (String) The name of the property in the data to read the association from. ... */ - associationKey?: string; - /** [Config Option] (String) The string name of the model that is being associated with. ... */ - model?: string; - /** [Config Option] (String) The string name of the model that owns the association. ... */ - ownerModel?: string; - /** [Config Option] (String) The name of the primary key on the associated model. ... */ - primaryKey?: string; - /** [Config Option] (Ext.data.reader.Reader) */ - reader?: Ext.data.reader.IReader; - /** [Property] (String) The name of the model is on the other end of the association (e.g. ... */ - associatedName?: string; - /** [Property] (String) */ - ownerName?: string; - /** [Method] Get a specialized reader for reading associated data */ - getReader?(): Ext.data.reader.IReader; - } -} -declare module Ext.data.association { - export interface IBelongsTo extends Ext.data.association.IAssociation { - /** [Config Option] (String) The name of the foreign key on the owner model that links it to the associated model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the getter function that will be added to the local model's prototype. ... */ - getterName?: string; - /** [Config Option] (String) The name of the setter function that will be added to the local model's prototype. ... */ - setterName?: string; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data { - export interface IBelongsToAssociation extends Ext.data.association.IAssociation { - /** [Config Option] (String) The name of the foreign key on the owner model that links it to the associated model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the getter function that will be added to the local model's prototype. ... */ - getterName?: string; - /** [Config Option] (String) The name of the setter function that will be added to the local model's prototype. ... */ - setterName?: string; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data.association { - export interface IHasMany extends Ext.data.association.IAssociation { - /** [Config Option] (Boolean) True to automatically load the related store from a remote source when instantiated. ... */ - autoLoad?: boolean; - /** [Config Option] (String) Optionally overrides the default filter that is set up on the associated Store. ... */ - filterProperty?: string; - /** [Config Option] (String) The name of the foreign key on the associated model that links it to the owner model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the function to create on the owner model to retrieve the child store. ... */ - name?: string; - /** [Config Option] (Object) Optional configuration object that will be passed to the generated Store. ... */ - storeConfig?: any; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data { - export interface IHasManyAssociation extends Ext.data.association.IAssociation { - /** [Config Option] (Boolean) True to automatically load the related store from a remote source when instantiated. ... */ - autoLoad?: boolean; - /** [Config Option] (String) Optionally overrides the default filter that is set up on the associated Store. ... */ - filterProperty?: string; - /** [Config Option] (String) The name of the foreign key on the associated model that links it to the owner model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the function to create on the owner model to retrieve the child store. ... */ - name?: string; - /** [Config Option] (Object) Optional configuration object that will be passed to the generated Store. ... */ - storeConfig?: any; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data.association { - export interface IHasOne extends Ext.data.association.IAssociation { - /** [Config Option] (String) The name of the foreign key on the owner model that links it to the associated model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the getter function that will be added to the local model's prototype. ... */ - getterName?: string; - /** [Config Option] (String) The name of the setter function that will be added to the local model's prototype. ... */ - setterName?: string; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data { - export interface IHasOneAssociation extends Ext.data.association.IAssociation { - /** [Config Option] (String) The name of the foreign key on the owner model that links it to the associated model. ... */ - foreignKey?: string; - /** [Config Option] (String) The name of the getter function that will be added to the local model's prototype. ... */ - getterName?: string; - /** [Config Option] (String) The name of the setter function that will be added to the local model's prototype. ... */ - setterName?: string; - /** [Config Option] (String) The type configuration can be used when creating associations using a configuration object. ... */ - type?: string; - } -} -declare module Ext.data { - export interface IBatch extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) True to immediately start processing the batch as soon as it is constructed (defaults to false) ... */ - autoStart?: boolean; - /** [Config Option] (Boolean) True to pause the execution of the batch if any operation encounters an exception (defaults to false). ... */ - pauseOnException?: boolean; - /** [Property] (Number) The index of the current operation being executed. ... */ - current?: number; - /** [Property] (Ext.data.Operation[]) Ordered array of operations that raised an exception during the most recent batch execution and did not successfully ... */ - exceptions?: Ext.data.IOperation[]; - /** [Property] (Boolean) True if this batch has encountered an exception. ... */ - hasException?: boolean; - /** [Property] (Boolean) True if this batch has been executed completely. ... */ - isComplete?: boolean; - /** [Property] (Boolean) True if the batch is currently running. ... */ - isRunning?: boolean; - /** [Property] (Ext.data.Operation[]) */ - operations?: Ext.data.IOperation[]; - /** [Property] (Number) The total number of operations in this batch. ... */ - total?: number; - /** [Method] Adds a new operation to this batch at the end of the operations array - * @param operation Object The Operation object - */ - add?( operation?:any ): Ext.data.IBatch; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Pauses execution of the batch but does not cancel the current operation */ - pause?(): Ext.data.IBatch; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Kicks off execution of the batch continuing from the current operation */ - retry?(): Ext.data.IBatch; - /** [Method] Executes an operation by its numeric index in the operations array - * @param index Number The operation index to run - */ - runOperation?( index?:number ): Ext.data.IBatch; - /** [Method] Kicks off execution of the batch continuing from the next operation if the previous operation encountered an excepti - * @param index Object - */ - start?( index?:any ): Ext.data.IBatch; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IBufferStore extends Ext.data.IStore { - /** [Config Option] (Boolean) If true, any filters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - filterOnLoad?: boolean; - /** [Config Option] (Boolean) If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - sortOnLoad?: boolean; - } -} -declare module Ext.data { - export interface IConnection extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) Whether this request should abort any pending requests. ... */ - autoAbort?: boolean; - /** [Config Option] (Boolean) True if the response should be treated as binary data. ... */ - binary?: boolean; - /** [Config Option] (Boolean) True to enable CORS support on the XHR object. ... */ - cors?: boolean; - /** [Config Option] (Object) */ - defaultHeaders?: any; - /** [Config Option] (Boolean) True to add a unique cache-buster param to GET requests. ... */ - disableCaching?: boolean; - /** [Config Option] (String) Change the parameter which is sent went disabling caching through a cache buster. ... */ - disableCachingParam?: string; - /** [Config Option] (Object) */ - extraParams?: any; - /** [Config Option] (String) The default HTTP method to be used for requests. ... */ - method?: string; - /** [Config Option] (Number) The timeout in milliseconds to be used for requests. ... */ - timeout?: number; - /** [Config Option] (Boolean) True to set withCredentials = true on the XHR object ... */ - withCredentials?: boolean; - /** [Method] Aborts an active request - * @param request Object Defaults to the last request - */ - abort?( request?:any ): void; - /** [Method] Aborts all active requests */ - abortAll?(): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Determines whether this object has a request outstanding - * @param request Object Defaults to the last transaction - */ - isLoading?( request?:any ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Checks if the response status was successful - * @param status Number The status code - */ - parseStatus?( status?:number ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Sends an HTTP request to a remote server - * @param options Object An object which may contain the following properties: (The options object may also contain any other property which might be needed to perform postprocessing in a callback because it is passed to callback functions.) - */ - request?( options?:any ): any; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets various options such as the url params for the request - * @param options Object The initial options - * @param scope Object The scope to execute in - */ - setOptions?( options?:any, scope?:any ): any; - /** [Method] Template method for overriding method - * @param options Object - * @param method String - */ - setupMethod?( options?:any, method?:string ): string; - /** [Method] Template method for overriding params - * @param options Object - * @param params String - */ - setupParams?( options?:any, params?:string ): string; - /** [Method] Template method for overriding url - * @param options Object - * @param url String - */ - setupUrl?( options?:any, url?:string ): string; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Uploads a form using a hidden iframe - * @param form String The form to upload - * @param url String The url to post to - * @param params String Any extra parameters to pass - * @param options Object The initial options - */ - upload?( form?:string, url?:string, params?:string, options?:any ): void; - upload?( form?:HTMLElement, url?:string, params?:string, options?:any ): void; - upload?( form?:Ext.IElement, url?:string, params?:string, options?:any ): void; - } -} -declare module Ext.data { - export interface IDirectStore extends Ext.data.IStore { - } -} -declare module Ext.data { - export interface IErrors extends Ext.util.IMixedCollection { - /** [Method] Returns all of the errors for the given field - * @param fieldName String The field to get errors for - */ - getByField?( fieldName?:string ): Object[]; - /** [Method] Returns true if there are no errors in the collection */ - isValid?(): boolean; - } -} -declare module Ext.data { - export interface IField extends Ext.IBase { - /** [Config Option] (Function) A function which converts the value provided by the Reader into an object that will be stored in the Model. ... */ - convert?: any; - /** [Config Option] (String) Serves as a default for the dateReadFormat and dateWriteFormat config options. ... */ - dateFormat?: string; - /** [Config Option] (String) Used when converting received data into a Date when the type is specified as "date". ... */ - dateReadFormat?: string; - /** [Config Option] (String) Used to provide a custom format when serializing dates with a Ext.data.writer.Writer. ... */ - dateWriteFormat?: string; - /** [Config Option] (Object) The default value used when the creating an instance from a raw data object, and the property referenced by the mappi... */ - defaultValue?: any; - /** [Config Option] (String/Number) (Optional) A path expression for use by the Ext.data.reader.Reader implementation that is creating the Model to extra... */ - mapping?: any; - /** [Config Option] (String) The name by which the field is referenced within the Model. ... */ - name?: string; - /** [Config Option] (Boolean) False to exclude this field from the Ext.data.Model.modified fields in a model. ... */ - persist?: boolean; - /** [Config Option] (Function) A function which converts the Model's value for this Field into a form which can be used by whatever Writer is being ... */ - serialize?: any; - /** [Config Option] (String) Initial direction to sort ("ASC" or "DESC"). ... */ - sortDir?: string; - /** [Config Option] (Function/String) A function which converts a Field's value to a comparable value in order to ensure correct sort ordering. ... */ - sortType?: any; - /** [Config Option] (String/Object) The data type for automatic conversion from received data to the stored value if convert has not been specified. ... */ - type?: any; - /** [Config Option] (Boolean) Use when converting received data into a INT, FLOAT, boolean or STRING type. ... */ - useNull?: boolean; - } -} -declare module Ext.data.flash { - export interface IBinaryXhr extends Ext.IBase { - /** [Property] (number) The connection's simulated readyState. ... */ - readyState?: number; - /** [Property] (Array) */ - responseBytes?: any[]; - /** [Property] (number) Connection status code returned by flash or the server. ... */ - status?: number; - /** [Property] (String) Status text (if any) returned by flash or the server. ... */ - statusText?: string; - /** [Method] Abort this connection */ - abort?(): void; - /** [Method] As in XMLHttpRequest */ - getAllResponseHeaders?(): void; - /** [Method] As in XMLHttpRequest - * @param header Object - */ - getResponseHeader?( header?:any ): void; - /** [Method] As in XMLHttpRequest */ - onreadystatechange?(): void; - /** [Method] As in XMLHttpRequest - * @param method Object - * @param url Object - * @param async Object - * @param user Object - * @param password Object - */ - open?( method?:any, url?:any, async?:any, user?:any, password?:any ): void; - /** [Method] As in XMLHttpRequest - * @param mimeType Object - */ - overrideMimeType?( mimeType?:any ): void; - /** [Method] Initiate the request - * @param body Array an array of byte values to send. - */ - send?( body?:any[] ): void; - /** [Method] As in XMLHttpRequest - * @param header Object - * @param value Object - */ - setRequestHeader?( header?:any, value?:any ): void; - } -} -declare module Ext.data { - export interface IGroup extends Ext.util.IObservable { - } -} -declare module Ext.data { - export interface IIdGenerator extends Ext.IBase { - /** [Config Option] (String) The id by which to register a new instance. ... */ - id?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated IdGenerator, or subclass thereof. ... */ - isGenerator?: boolean; - /** [Method] Generates and returns the next id */ - generate?(): string; - } -} -declare module Ext.data { - export interface IJsonP extends Ext.IBase { - } - export class JsonP { - /** [Method] Abort a request - * @param request any The request to abort - */ - static abort( request?:any ): void; - /** [Method] Makes a JSONP request - * @param options Object An object which may contain the following properties. Note that options will take priority over any defaults that are specified in the class. url : String The URL to request. params : Object (Optional)An object containing a series of key value pairs that will be sent along with the request. timeout : Number (Optional) See timeout callbackKey : String (Optional) See callbackKey callbackName : String (Optional) The function name to use for this request. By default this name will be auto-generated: Ext.data.JsonP.callback1, Ext.data.JsonP.callback2, etc. Setting this option to "my_name" will force the function name to be Ext.data.JsonP.my_name. Use this if you want deterministic behavior, but be careful - the callbackName should be different in each JsonP request that you make. disableCaching : Boolean (Optional) See disableCaching disableCachingParam : String (Optional) See disableCachingParam success : Function (Optional) A function to execute if the request succeeds. failure : Function (Optional) A function to execute if the request fails. callback : Function (Optional) A function to execute when the request completes, whether it is a success or failure. scope : Object (Optional)The scope in which to execute the callbacks: The "this" object for the callback function. Defaults to the browser window. - */ - static request( options?:any ): any; - } -} -declare module Ext.data { - export interface IJsonPStore extends Ext.data.IStore { - } -} -declare module Ext.data { - export interface IJsonStore extends Ext.data.IStore { - } -} -declare module Ext.data { - export interface IModel extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Object[]) */ - associations?: Object[]; - /** [Config Option] (String/Object/String[]/Object[]) */ - belongsTo?: any; - /** [Config Option] (String) The name of a property that is used for submitting this Model's unique client-side identifier to the server when mult... */ - clientIdProperty?: string; - /** [Config Option] (String) The string type of the default Model Proxy. ... */ - defaultProxyType?: string; - /** [Config Option] (Object[]/String[]) The fields for this model. ... */ - fields?: any; - /** [Config Option] (String/Object/String[]/Object[]) */ - hasMany?: any; - /** [Config Option] (String/Object/Ext.data.Field) The name of the field treated as this Model's unique id. ... */ - idProperty?: any; - /** [Config Option] (String/Object) The id generator to use for this model. ... */ - idgen?: any; - /** [Config Option] (String) The name of the property on this Persistable object that its data is saved to. ... */ - persistenceProperty?: string; - /** [Config Option] (String/Object/Ext.data.proxy.Proxy) */ - proxy?: any; - /** [Config Option] (Object[]) */ - validations?: Object[]; - /** [Property] (Boolean) True if this Record has been modified. ... */ - dirty?: boolean; - /** [Property] (Boolean) Internal flag used to track whether or not the model instance is currently being edited. ... */ - editing?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Model, or subclass thereof. ... */ - isModel?: boolean; - /** [Property] (Object) */ - modified?: any; - /** [Property] (Boolean) True when the record does not yet exist in a server-side database (see setDirty). ... */ - phantom?: boolean; - /** [Property] (Object) */ - raw?: any; - /** [Property] (Ext.data.Store) The Store to which this instance belongs. ... */ - store?: Ext.data.IStore; - /** [Property] (Ext.data.Store[]) */ - stores?: Ext.data.IStore[]; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Begins an edit */ - beginEdit?(): void; - /** [Method] Cancels all changes made in the current edit operation */ - cancelEdit?(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Usually called by the Ext data Store which owns the model instance - * @param silent Boolean Pass true to skip notification of the owning store of the change. - * @param modifiedFieldNames String[] Array of field names changed during sync with server if known. Omit or pass null if unknown. An empty array means that it is known that no fields were modified by the server's response. Defaults to false. - */ - commit?( silent?:boolean, modifiedFieldNames?:string[] ): void; - /** [Method] Creates a copy clone of this Model instance - * @param id String A new id, defaults to the id of the instance being copied. See id. To generate a phantom instance with a new id use: var rec = record.copy(); // clone the record Ext.data.Model.id(rec); // automatically generate a unique sequential id - */ - copy?( id?:string ): Ext.data.IModel; - /** [Method] Destroys the model using the configured proxy - * @param options Object Options to pass to the proxy. Config object for Ext.data.Operation. - */ - destroy?( options?:any ): Ext.data.IModel; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Ends an edit - * @param silent Boolean True to not notify the store of the change - * @param modifiedFieldNames String[] Array of field names changed during edit. - */ - endEdit?( silent?:boolean, modifiedFieldNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the value of the given field - * @param fieldName String The field to fetch the value for - */ - get?( fieldName?:string ): any; - /** [Method] Gets all of the data from this Models loaded associations */ - getAssociatedData?(): any; - /** [Method] Gets a hash of only the fields that have been modified since this Model was created or commited */ - getChanges?(): any; - /** [Method] Gets all values for each field in this model and returns an object containing the current data - * @param includeAssociated Boolean True to also include associated data. Defaults to false. - */ - getData?( includeAssociated?:boolean ): any; - /** [Method] Returns the unique ID allocated to this model instance as defined by idProperty */ - getId?(): any; - /** [Method] Returns the configured Proxy for this Model */ - getProxy?(): Ext.data.proxy.IProxy; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Returns true if the passed field name has been modified since the load or last commit - * @param fieldName String Ext.data.Field.name - */ - isModified?( fieldName?:string ): boolean; - /** [Method] Checks if the model is valid */ - isValid?(): boolean; - /** [Method] Tells this model instance that it has been added to a store - * @param store Ext.data.IStore The store to which this model has been added. - */ - join?( store?:Ext.data.IStore ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Usually called by the Ext data Store to which this model instance has been joined - * @param silent Boolean True to skip notification of the owning store of the change. Defaults to false. - */ - reject?( silent?:boolean ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Saves the model instance using the configured proxy - * @param options Object Options to pass to the proxy. Config object for Ext.data.Operation. - */ - save?( options?:any ): Ext.data.IModel; - /** [Method] Sets the given field to the given value marks the instance as dirty - * @param fieldName any The field to set, or an object containing key/value pairs - * @param newValue Object The value to set - */ - set?( fieldName?:any, newValue?:any ): string[]; - /** [Method] Marks this Record as dirty */ - setDirty?(): void; - /** [Method] Sets the model instance s id field to the given id - * @param id Number The new id - */ - setId?( id?:number ): void; - setId?( id?:string ): void; - /** [Method] Sets the Proxy to use for this model - * @param proxy any The proxy - */ - setProxy?( proxy?:any ): Ext.data.proxy.IProxy; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Tells this model instance that it has been removed from the store - * @param store Ext.data.IStore The store from which this model has been removed. - */ - unjoin?( store?:Ext.data.IStore ): void; - /** [Method] Validates the current data against all of its configured validations */ - validate?(): Ext.data.IErrors; - } -} -declare module Ext.data { - export interface IRecord extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Object[]) */ - associations?: Object[]; - /** [Config Option] (String/Object/String[]/Object[]) */ - belongsTo?: any; - /** [Config Option] (String) The name of a property that is used for submitting this Model's unique client-side identifier to the server when mult... */ - clientIdProperty?: string; - /** [Config Option] (String) The string type of the default Model Proxy. ... */ - defaultProxyType?: string; - /** [Config Option] (Object[]/String[]) The fields for this model. ... */ - fields?: any; - /** [Config Option] (String/Object/String[]/Object[]) */ - hasMany?: any; - /** [Config Option] (String/Object/Ext.data.Field) The name of the field treated as this Model's unique id. ... */ - idProperty?: any; - /** [Config Option] (String/Object) The id generator to use for this model. ... */ - idgen?: any; - /** [Config Option] (String) The name of the property on this Persistable object that its data is saved to. ... */ - persistenceProperty?: string; - /** [Config Option] (String/Object/Ext.data.proxy.Proxy) */ - proxy?: any; - /** [Config Option] (Object[]) */ - validations?: Object[]; - /** [Property] (Boolean) True if this Record has been modified. ... */ - dirty?: boolean; - /** [Property] (Boolean) Internal flag used to track whether or not the model instance is currently being edited. ... */ - editing?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Model, or subclass thereof. ... */ - isModel?: boolean; - /** [Property] (Object) */ - modified?: any; - /** [Property] (Boolean) True when the record does not yet exist in a server-side database (see setDirty). ... */ - phantom?: boolean; - /** [Property] (Object) */ - raw?: any; - /** [Property] (Ext.data.Store) The Store to which this instance belongs. ... */ - store?: Ext.data.IStore; - /** [Property] (Ext.data.Store[]) */ - stores?: Ext.data.IStore[]; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Begins an edit */ - beginEdit?(): void; - /** [Method] Cancels all changes made in the current edit operation */ - cancelEdit?(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Usually called by the Ext data Store which owns the model instance - * @param silent Boolean Pass true to skip notification of the owning store of the change. - * @param modifiedFieldNames String[] Array of field names changed during sync with server if known. Omit or pass null if unknown. An empty array means that it is known that no fields were modified by the server's response. Defaults to false. - */ - commit?( silent?:boolean, modifiedFieldNames?:string[] ): void; - /** [Method] Creates a copy clone of this Model instance - * @param id String A new id, defaults to the id of the instance being copied. See id. To generate a phantom instance with a new id use: var rec = record.copy(); // clone the record Ext.data.Model.id(rec); // automatically generate a unique sequential id - */ - copy?( id?:string ): Ext.data.IModel; - /** [Method] Destroys the model using the configured proxy - * @param options Object Options to pass to the proxy. Config object for Ext.data.Operation. - */ - destroy?( options?:any ): Ext.data.IModel; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Ends an edit - * @param silent Boolean True to not notify the store of the change - * @param modifiedFieldNames String[] Array of field names changed during edit. - */ - endEdit?( silent?:boolean, modifiedFieldNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the value of the given field - * @param fieldName String The field to fetch the value for - */ - get?( fieldName?:string ): any; - /** [Method] Gets all of the data from this Models loaded associations */ - getAssociatedData?(): any; - /** [Method] Gets a hash of only the fields that have been modified since this Model was created or commited */ - getChanges?(): any; - /** [Method] Gets all values for each field in this model and returns an object containing the current data - * @param includeAssociated Boolean True to also include associated data. Defaults to false. - */ - getData?( includeAssociated?:boolean ): any; - /** [Method] Returns the unique ID allocated to this model instance as defined by idProperty */ - getId?(): any; - /** [Method] Returns the configured Proxy for this Model */ - getProxy?(): Ext.data.proxy.IProxy; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Returns true if the passed field name has been modified since the load or last commit - * @param fieldName String Ext.data.Field.name - */ - isModified?( fieldName?:string ): boolean; - /** [Method] Checks if the model is valid */ - isValid?(): boolean; - /** [Method] Tells this model instance that it has been added to a store - * @param store Ext.data.IStore The store to which this model has been added. - */ - join?( store?:Ext.data.IStore ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Usually called by the Ext data Store to which this model instance has been joined - * @param silent Boolean True to skip notification of the owning store of the change. Defaults to false. - */ - reject?( silent?:boolean ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Saves the model instance using the configured proxy - * @param options Object Options to pass to the proxy. Config object for Ext.data.Operation. - */ - save?( options?:any ): Ext.data.IModel; - /** [Method] Sets the given field to the given value marks the instance as dirty - * @param fieldName any The field to set, or an object containing key/value pairs - * @param newValue Object The value to set - */ - set?( fieldName?:any, newValue?:any ): string[]; - /** [Method] Marks this Record as dirty */ - setDirty?(): void; - /** [Method] Sets the model instance s id field to the given id - * @param id Number The new id - */ - setId?( id?:number ): void; - setId?( id?:string ): void; - /** [Method] Sets the Proxy to use for this model - * @param proxy any The proxy - */ - setProxy?( proxy?:any ): Ext.data.proxy.IProxy; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Tells this model instance that it has been removed from the store - * @param store Ext.data.IStore The store from which this model has been removed. - */ - unjoin?( store?:Ext.data.IStore ): void; - /** [Method] Validates the current data against all of its configured validations */ - validate?(): Ext.data.IErrors; - } -} -declare module Ext.data { - export interface INodeInterface extends Ext.IBase { - /** [Config Option] (Boolean) Set to false to deny dragging of this node. ... */ - allowDrag?: boolean; - /** [Config Option] (Boolean) Set to false to deny dropping on this node. ... */ - allowDrop?: boolean; - /** [Config Option] (Boolean) Set to true or false to show a checkbox alongside this node. ... */ - checked?: boolean; - /** [Config Option] (Ext.data.NodeInterface[]) */ - children?: Ext.data.INodeInterface[]; - /** [Config Option] (String) */ - cls?: string; - /** [Config Option] (Number) The number of parents this node has. ... */ - depth?: number; - /** [Config Option] (Boolean) Set to true to allow for expanding/collapsing of this node. ... */ - expandable?: boolean; - /** [Config Option] (Boolean) True if the node is expanded. ... */ - expanded?: boolean; - /** [Config Option] (String) */ - href?: string; - /** [Config Option] (String) Target for link. ... */ - hrefTarget?: string; - /** [Config Option] (String) */ - icon?: string; - /** [Config Option] (String) */ - iconCls?: string; - /** [Config Option] (Number) The position of the node inside its parent. ... */ - index?: number; - /** [Config Option] (Boolean) */ - isFirst?: boolean; - /** [Config Option] (Boolean) */ - isLast?: boolean; - /** [Config Option] (Boolean) Set to true to indicate that this child can have no children. ... */ - leaf?: boolean; - /** [Config Option] (Boolean) True if the node has finished loading. ... */ - loaded?: boolean; - /** [Config Option] (Boolean) True if the node is currently loading. ... */ - loading?: boolean; - /** [Config Option] (String) */ - parentId?: string; - /** [Config Option] (Number) */ - qshowDelay?: number; - /** [Config Option] (String) */ - qtip?: string; - /** [Config Option] (String) */ - qtitle?: string; - /** [Config Option] (Boolean) */ - root?: boolean; - /** [Config Option] (String) */ - text?: string; - /** [Property] (Ext.data.NodeInterface[]) An array of this nodes children. ... */ - childNodes?: Ext.data.INodeInterface[]; - /** [Property] (Ext.data.NodeInterface) A reference to this node's first child node. ... */ - firstChild?: Ext.data.INodeInterface; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Node, or subclass thereof. ... */ - isNode?: boolean; - /** [Property] (Ext.data.NodeInterface) A reference to this node's last child node. ... */ - lastChild?: Ext.data.INodeInterface; - /** [Property] (Ext.data.NodeInterface) A reference to this node's next sibling node. ... */ - nextSibling?: Ext.data.INodeInterface; - /** [Property] (Ext.data.NodeInterface) A reference to this node's parent node. ... */ - parentNode?: Ext.data.INodeInterface; - /** [Property] (Ext.data.NodeInterface) A reference to this node's previous sibling node. ... */ - previousSibling?: Ext.data.INodeInterface; - /** [Method] Inserts node s as the last child node of this node - * @param node any The node or Array of nodes to append - */ - appendChild?( node?:any ): any; - appendChild?( node?:Ext.data.INodeInterface ): Ext.data.INodeInterface; - appendChild?( node?:Ext.data.INodeInterface[] ): Ext.data.INodeInterface; - /** [Method] Bubbles up the tree from this node calling the specified function with each node - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Node. - * @param args Array The args to call the function with. Defaults to passing the current Node. - */ - bubble?( fn?:any, scope?:any, args?:any[] ): void; - /** [Method] Cascades down the tree from this node calling the specified function with each node - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Node. - * @param args Array The args to call the function with. Defaults to passing the current Node. - */ - cascadeBy?( fn?:any, scope?:any, args?:any[] ): void; - /** [Method] Collapse this node - * @param recursive Boolean True to recursively collapse all the children - * @param callback Function The function to execute once the collapse completes - * @param scope Object The scope to run the callback in - */ - collapse?( recursive?:boolean, callback?:any, scope?:any ): void; - /** [Method] Collapse all the children of this node - * @param recursive Function True to recursively collapse all the children - * @param callback Function The function to execute once all the children are collapsed - * @param scope Object The scope to run the callback in - */ - collapseChildren?( recursive?:any, callback?:any, scope?:any ): void; - /** [Method] Returns true if this node is an ancestor at any point of the passed node - * @param node Ext.data.INodeInterface - */ - contains?( node?:Ext.data.INodeInterface ): boolean; - /** [Method] Creates a copy clone of this Node - * @param id String A new id, defaults to this Node's id. - * @param deep Boolean True to recursively copy all child Nodes into the new Node. False to copy without child Nodes. - */ - copy?( id?:string, deep?:boolean ): Ext.data.INodeInterface; - /** [Method] Ensures that the passed object is an instance of a Record with the NodeInterface applied - * @param node Object - */ - createNode?( node?:any ): Ext.data.INodeInterface; - /** [Method] Destroys the node - * @param silent Object - */ - destroy?( silent?:any ): void; - /** [Method] Interates the child nodes of this node calling the specified function with each node - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Node in iteration. - * @param args Array The args to call the function with. Defaults to passing the current Node. - */ - eachChild?( fn?:any, scope?:any, args?:any[] ): void; - /** [Method] Expand this node - * @param recursive Boolean True to recursively expand all the children - * @param callback Function The function to execute once the expand completes - * @param scope Object The scope to run the callback in - */ - expand?( recursive?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand all the children of this node - * @param recursive Boolean True to recursively expand all the children - * @param callback Function The function to execute once all the children are expanded - * @param scope Object The scope to run the callback in - */ - expandChildren?( recursive?:boolean, callback?:any, scope?:any ): void; - /** [Method] Finds the first child that has the attribute with the specified value - * @param attribute String The attribute name - * @param value Object The value to search for - * @param deep Boolean True to search through nodes deeper than the immediate children - */ - findChild?( attribute?:string, value?:any, deep?:boolean ): Ext.data.INodeInterface; - /** [Method] Finds the first child by a custom function - * @param fn Function A function which must return true if the passed Node is the required Node. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Node being tested. - * @param deep Boolean True to search through nodes deeper than the immediate children - */ - findChildBy?( fn?:any, scope?:any, deep?:boolean ): Ext.data.INodeInterface; - /** [Method] Returns the child node at the specified index - * @param index Number - */ - getChildAt?( index?:number ): Ext.data.INodeInterface; - /** [Method] Returns depth of this node the root node has a depth of 0 */ - getDepth?(): number; - /** [Method] Returns the tree this node is in */ - getOwnerTree?(): Ext.tree.IPanel; - /** [Method] Gets the hierarchical path from the root of the current node - * @param field String The field to construct the path from. Defaults to the model idProperty. - * @param separator String A separator to use. - */ - getPath?( field?:string, separator?:string ): string; - /** [Method] Returns true if this node has one or more child nodes else false */ - hasChildNodes?(): boolean; - /** [Method] Returns the index of a child node - * @param node Ext.data.INodeInterface - */ - indexOf?( node?:Ext.data.INodeInterface ): number; - /** [Method] Returns the index of a child node that matches the id - * @param id String The id of the node to find - */ - indexOfId?( id?:string ): number; - /** [Method] Inserts the first node before the second node in this nodes childNodes collection - * @param node Ext.data.INodeInterface The node to insert - * @param refNode Ext.data.INodeInterface The node to insert before (if null the node is appended) - */ - insertBefore?( node?:Ext.data.INodeInterface, refNode?:Ext.data.INodeInterface ): Ext.data.INodeInterface; - /** [Method] Inserts a node into this node - * @param index Number The zero-based index to insert the node at - * @param node Ext.data.INodeInterface The node to insert - */ - insertChild?( index?:number, node?:Ext.data.INodeInterface ): Ext.data.INodeInterface; - /** [Method] Returns true if the passed node is an ancestor at any point of this node - * @param node Ext.data.INodeInterface - */ - isAncestor?( node?:Ext.data.INodeInterface ): boolean; - /** [Method] Returns true if this node has one or more child nodes or if the expandable node attribute is explicitly specified as */ - isExpandable?(): boolean; - /** [Method] Returns true if this node is expaned */ - isExpanded?(): boolean; - /** [Method] Returns true if this node is a leaf */ - isLeaf?(): boolean; - /** [Method] Returns true if this node is loaded */ - isLoaded?(): boolean; - /** [Method] Returns true if this node is loading */ - isLoading?(): boolean; - /** [Method] Returns true if this node is the root node */ - isRoot?(): boolean; - /** [Method] Returns true if this node is visible */ - isVisible?(): boolean; - /** [Method] Removes this node from its parent - * @param destroy Boolean True to destroy the node upon removal. - */ - remove?( destroy?:boolean ): Ext.data.INodeInterface; - /** [Method] Removes all child nodes from this node - * @param destroy Boolean True to destroy the node upon removal. - */ - removeAll?( destroy?:boolean ): Ext.data.INodeInterface; - /** [Method] Removes a child node from this node - * @param node Ext.data.INodeInterface The node to remove - * @param destroy Boolean True to destroy the node upon removal. - */ - removeChild?( node?:Ext.data.INodeInterface, destroy?:boolean ): Ext.data.INodeInterface; - /** [Method] Replaces one child node in this node with another - * @param newChild Ext.data.INodeInterface The replacement node - * @param oldChild Ext.data.INodeInterface The node to replace - */ - replaceChild?( newChild?:Ext.data.INodeInterface, oldChild?:Ext.data.INodeInterface ): Ext.data.INodeInterface; - /** [Method] Creates an object representation of this node including its children */ - serialize?(): void; - /** [Method] Sorts this nodes children using the supplied sort function - * @param fn Function A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order. - * @param recursive Boolean True to apply this sort recursively - * @param suppressEvent Boolean True to not fire a sort event. - */ - sort?( fn?:any, recursive?:boolean, suppressEvent?:boolean ): void; - /** [Method] Updates general data of this node like isFirst isLast depth - * @param commit Boolean - * @param info Object The info to update. May contain any of the following - */ - updateInfo?( commit?:boolean, info?:any ): void; - } -} -declare module Ext.data { - export interface INodeStore extends Ext.data.IStore { - /** [Config Option] (Ext.data.Model) The Record you want to bind this Store to. ... */ - node?: Ext.data.IModel; - /** [Config Option] (Boolean) Set this to true if you want this NodeStore to represent all the descendents of the node in its flat data collection. ... */ - recursive?: boolean; - /** [Config Option] (Boolean) False to not include the root node in this Stores collection. ... */ - rootVisible?: boolean; - /** [Config Option] (Ext.data.TreeStore) */ - treeStore?: Ext.data.ITreeStore; - /** [Property] (Number) Recursion level counter. ... */ - isExpandingOrCollapsing?: number; - /** [Property] (Boolean) true in this class to identify an object as an instantiated NodeStore, or subclass thereof. ... */ - isNodeStore?: boolean; - /** [Method] NodeStores are never buffered or paged */ - getTotalCount?(): number; - } -} -declare module Ext.data { - export interface IOperation extends Ext.IBase { - /** [Config Option] (String) The action being performed by this Operation. ... */ - action?: string; - /** [Config Option] (Ext.data.Batch) */ - batch?: Ext.data.IBatch; - /** [Config Option] (Function) Function to execute when operation completed. ... */ - callback?: any; - /** [Config Option] (Ext.util.Filter[]) Optional array of filter objects. ... */ - filters?: Ext.util.IFilter[]; - /** [Config Option] (Ext.util.Grouper[]) Optional grouping configuration. ... */ - groupers?: Ext.util.IGrouper[]; - /** [Config Option] (Number) The number of records to load. ... */ - limit?: number; - /** [Config Option] (Object) */ - params?: any; - /** [Config Option] (Object) */ - scope?: any; - /** [Config Option] (Ext.util.Sorter[]) Optional array of sorter objects. ... */ - sorters?: Ext.util.ISorter[]; - /** [Config Option] (Number) */ - start?: number; - /** [Config Option] (Boolean) True if this Operation is to be executed synchronously. ... */ - synchronous?: boolean; - /** [Property] (RegExp) The RegExp used to categorize actions that require record commits. ... */ - actionCommitRecordsRe?: RegExp; - /** [Property] (RegExp) The RegExp used to categorize actions that skip local record synchronization. ... */ - actionSkipSyncRe?: RegExp; - /** [Method] Checks whether this operation should cause writing to occur */ - allowWrite?(): boolean; - /** [Method] This method is called to commit data to this instance s records given the records in the server response - * @param serverRecords Ext.data.IModel[] An array of Ext.data.Model objects returned by the server. - */ - commitRecords?( serverRecords?:Ext.data.IModel[] ): void; - /** [Method] Returns the error string or object that was set using setException */ - getError?(): any; - /** [Method] Returns the records associated with this operation */ - getRecords?(): Ext.data.IModel[]; - /** [Method] Returns the ResultSet object if set by the Proxy */ - getResultSet?(): Ext.data.IResultSet; - /** [Method] Returns true if this Operation encountered an exception see also getError */ - hasException?(): boolean; - /** [Method] Returns true if the Operation has been completed */ - isComplete?(): boolean; - /** [Method] Returns true if the Operation has been started but has not yet completed */ - isRunning?(): boolean; - /** [Method] Returns true if the Operation has been started */ - isStarted?(): boolean; - /** [Method] Marks the Operation as completed */ - setCompleted?(): void; - /** [Method] Marks the Operation as having experienced an exception - * @param error any error string/object - */ - setException?( error?:any ): void; - /** [Method] Marks the Operation as started */ - setStarted?(): void; - /** [Method] Marks the Operation as successful */ - setSuccessful?(): void; - /** [Method] Returns true if the Operation has completed and was successful */ - wasSuccessful?(): boolean; - } -} -declare module Ext.data.proxy { - export interface IAjax extends Ext.data.proxy.IServer { - /** [Config Option] (Boolean) True to request binary data from the server. ... */ - binary?: boolean; - /** [Config Option] (Object) Any headers to add to the Ajax request. ... */ - headers?: any; - /** [Property] (Object) Mapping of action name to HTTP request method. ... */ - actionMethods?: any; - /** [Method] Returns the HTTP method name for a given request - * @param request Ext.data.IRequest The request object - */ - getMethod?( request?:Ext.data.IRequest ): string; - } -} -declare module Ext.data { - export interface IAjaxProxy extends Ext.data.proxy.IServer { - /** [Config Option] (Boolean) True to request binary data from the server. ... */ - binary?: boolean; - /** [Config Option] (Object) Any headers to add to the Ajax request. ... */ - headers?: any; - /** [Property] (Object) Mapping of action name to HTTP request method. ... */ - actionMethods?: any; - /** [Method] Returns the HTTP method name for a given request - * @param request Ext.data.IRequest The request object - */ - getMethod?( request?:Ext.data.IRequest ): string; - } -} -declare module Ext.data { - export interface IHttpProxy extends Ext.data.proxy.IServer { - /** [Config Option] (Boolean) True to request binary data from the server. ... */ - binary?: boolean; - /** [Config Option] (Object) Any headers to add to the Ajax request. ... */ - headers?: any; - /** [Property] (Object) Mapping of action name to HTTP request method. ... */ - actionMethods?: any; - /** [Method] Returns the HTTP method name for a given request - * @param request Ext.data.IRequest The request object - */ - getMethod?( request?:Ext.data.IRequest ): string; - } -} -declare module Ext.data.proxy { - export interface IClient extends Ext.data.proxy.IProxy { - /** [Property] (Boolean) true in this class to identify that requests made on this proxy are performed synchronously ... */ - isSynchronous?: boolean; - /** [Method] Abstract function that must be implemented by each ClientProxy subclass */ - clear?(): void; - } -} -declare module Ext.data { - export interface IClientProxy extends Ext.data.proxy.IProxy { - /** [Property] (Boolean) true in this class to identify that requests made on this proxy are performed synchronously ... */ - isSynchronous?: boolean; - /** [Method] Abstract function that must be implemented by each ClientProxy subclass */ - clear?(): void; - } -} -declare module Ext.data.proxy { - export interface IDirect extends Ext.data.proxy.IServer { - /** [Config Option] (Object) The same as Ext.data.proxy.Server.api, however instead of providing urls, you should provide a direct function call. ... */ - api?: any; - /** [Config Option] (Function/String) Function to call when executing a request. ... */ - directFn?: any; - /** [Config Option] (Object) Extra parameters that will be included on every read request. ... */ - extraParams?: any; - /** [Config Option] (String/String[]) Defaults to undefined. ... */ - paramOrder?: any; - /** [Config Option] (Boolean) Send parameters as a collection of named arguments. ... */ - paramsAsHash?: boolean; - /** [Method] inherit docs Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] In ServerProxy subclasses the create read update and destroy methods all pass through to doRequest - * @param operation Ext.data.IOperation The Ext.data.Operation object - * @param callback Function The callback function to call when the Operation has completed - * @param scope Object The scope in which to execute the callback - */ - doRequest?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit docs Template method to allow subclasses to specify how to get the response for the reader - * @param response Object The server response - */ - extractResponseData?( response?:any ): any; - } -} -declare module Ext.data { - export interface IDirectProxy extends Ext.data.proxy.IServer { - /** [Config Option] (Object) The same as Ext.data.proxy.Server.api, however instead of providing urls, you should provide a direct function call. ... */ - api?: any; - /** [Config Option] (Function/String) Function to call when executing a request. ... */ - directFn?: any; - /** [Config Option] (Object) Extra parameters that will be included on every read request. ... */ - extraParams?: any; - /** [Config Option] (String/String[]) Defaults to undefined. ... */ - paramOrder?: any; - /** [Config Option] (Boolean) Send parameters as a collection of named arguments. ... */ - paramsAsHash?: boolean; - /** [Method] inherit docs Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] In ServerProxy subclasses the create read update and destroy methods all pass through to doRequest - * @param operation Ext.data.IOperation The Ext.data.Operation object - * @param callback Function The callback function to call when the Operation has completed - * @param scope Object The scope in which to execute the callback - */ - doRequest?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit docs Template method to allow subclasses to specify how to get the response for the reader - * @param response Object The server response - */ - extractResponseData?( response?:any ): any; - } -} -declare module Ext.data.proxy { - export interface IJsonP extends Ext.data.proxy.IServer { - /** [Config Option] (Boolean) True to automatically append the request's params to the generated url. ... */ - autoAppendParams?: boolean; - /** [Config Option] (String) See Ext.data.JsonP.callbackKey. ... */ - callbackKey?: string; - /** [Config Option] (String) The HTTP parameter name to use when passing records to the server and the Json writer is not configured to encode rec... */ - recordParam?: string; - /** [Method] Aborts the current server request if one is currently running */ - abort?(): void; - /** [Method] Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] Encodes an array of records into a value suitable to be added to the request params as the recordParam parameter - * @param records Ext.data.IModel[] The records array - */ - encodeRecords?( records?:Ext.data.IModel[] ): any[]; - } -} -declare module Ext.data { - export interface IScriptTagProxy extends Ext.data.proxy.IServer { - /** [Config Option] (Boolean) True to automatically append the request's params to the generated url. ... */ - autoAppendParams?: boolean; - /** [Config Option] (String) See Ext.data.JsonP.callbackKey. ... */ - callbackKey?: string; - /** [Config Option] (String) The HTTP parameter name to use when passing records to the server and the Json writer is not configured to encode rec... */ - recordParam?: string; - /** [Method] Aborts the current server request if one is currently running */ - abort?(): void; - /** [Method] Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] Encodes an array of records into a value suitable to be added to the request params as the recordParam parameter - * @param records Ext.data.IModel[] The records array - */ - encodeRecords?( records?:Ext.data.IModel[] ): any[]; - } -} -declare module Ext.data.proxy { - export interface ILocalStorage extends Ext.data.proxy.IWebStorage { - } -} -declare module Ext.data { - export interface ILocalStorageProxy extends Ext.data.proxy.IWebStorage { - } -} -declare module Ext.data.proxy { - export interface IMemory extends Ext.data.proxy.IClient { - /** [Config Option] (Object) */ - data?: any; - /** [Config Option] (Boolean) Configure as true to enable this MemoryProxy to honour a read operation's start and limit options. ... */ - enablePaging?: boolean; - /** [Method] Abstract function that must be implemented by each ClientProxy subclass */ - clear?(): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Reads data from the configured data object - * @param operation Ext.data.IOperation The read Operation - * @param callback Function The callback to call when reading has completed - * @param scope Object The scope to call the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IMemoryProxy extends Ext.data.proxy.IClient { - /** [Config Option] (Object) */ - data?: any; - /** [Config Option] (Boolean) Configure as true to enable this MemoryProxy to honour a read operation's start and limit options. ... */ - enablePaging?: boolean; - /** [Method] Abstract function that must be implemented by each ClientProxy subclass */ - clear?(): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Reads data from the configured data object - * @param operation Ext.data.IOperation The read Operation - * @param callback Function The callback to call when reading has completed - * @param scope Object The scope to call the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Currently this is a hard coded method that simply commits any records and sets the operation to successful then call - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data.proxy { - export interface IProxy extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) True to batch actions of a particular type when synchronizing the store. ... */ - batchActions?: boolean; - /** [Config Option] (String) Comma-separated ordering 'create', 'update' and 'destroy' actions when batching. ... */ - batchOrder?: string; - /** [Config Option] (String/Ext.data.Model) The name of the Model to tie to this Proxy. ... */ - model?: any; - /** [Config Option] (Object/String/Ext.data.reader.Reader) The Ext.data.reader.Reader to use to decode the server's response or data read from client. ... */ - reader?: any; - /** [Config Option] (Object/String/Ext.data.writer.Writer) The Ext.data.writer.Writer to use to encode any request sent to the server or saved to client. ... */ - writer?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Proxy, or subclass thereof. ... */ - isProxy?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs a batch of Operations in the order specified by batchOrder - * @param options Object Object containing one or more properties supported by the batch method: - */ - batch?( options?:any ): Ext.data.IBatch; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Performs the given create operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the model attached to this Proxy */ - getModel?(): Ext.data.IModel; - /** [Method] Returns the reader currently attached to this proxy instance */ - getReader?(): Ext.data.reader.IReader; - /** [Method] Returns the writer currently attached to this proxy instance */ - getWriter?(): Ext.data.writer.IWriter; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the model associated with this proxy - * @param model String The new model. Can be either the model name string, or a reference to the model's constructor - * @param setOnStore Boolean Sets the new model on the associated Store, if one is present - */ - setModel?( model?:string, setOnStore?:boolean ): void; - setModel?( model?:Ext.data.IModel, setOnStore?:boolean ): void; - /** [Method] Sets the Proxy s Reader by string config object or Reader instance - * @param reader any The new Reader, which can be either a type string, a configuration object or an Ext.data.reader.Reader instance - */ - setReader?( reader?:any ): Ext.data.reader.IReader; - /** [Method] Sets the Proxy s Writer by string config object or Writer instance - * @param writer any The new Writer, which can be either a type string, a configuration object or an Ext.data.writer.Writer instance - */ - setWriter?( writer?:any ): Ext.data.writer.IWriter; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IDataProxy extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) True to batch actions of a particular type when synchronizing the store. ... */ - batchActions?: boolean; - /** [Config Option] (String) Comma-separated ordering 'create', 'update' and 'destroy' actions when batching. ... */ - batchOrder?: string; - /** [Config Option] (String/Ext.data.Model) The name of the Model to tie to this Proxy. ... */ - model?: any; - /** [Config Option] (Object/String/Ext.data.reader.Reader) The Ext.data.reader.Reader to use to decode the server's response or data read from client. ... */ - reader?: any; - /** [Config Option] (Object/String/Ext.data.writer.Writer) The Ext.data.writer.Writer to use to encode any request sent to the server or saved to client. ... */ - writer?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Proxy, or subclass thereof. ... */ - isProxy?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs a batch of Operations in the order specified by batchOrder - * @param options Object Object containing one or more properties supported by the batch method: - */ - batch?( options?:any ): Ext.data.IBatch; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Performs the given create operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the model attached to this Proxy */ - getModel?(): Ext.data.IModel; - /** [Method] Returns the reader currently attached to this proxy instance */ - getReader?(): Ext.data.reader.IReader; - /** [Method] Returns the writer currently attached to this proxy instance */ - getWriter?(): Ext.data.writer.IWriter; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the model associated with this proxy - * @param model String The new model. Can be either the model name string, or a reference to the model's constructor - * @param setOnStore Boolean Sets the new model on the associated Store, if one is present - */ - setModel?( model?:string, setOnStore?:boolean ): void; - setModel?( model?:Ext.data.IModel, setOnStore?:boolean ): void; - /** [Method] Sets the Proxy s Reader by string config object or Reader instance - * @param reader any The new Reader, which can be either a type string, a configuration object or an Ext.data.reader.Reader instance - */ - setReader?( reader?:any ): Ext.data.reader.IReader; - /** [Method] Sets the Proxy s Writer by string config object or Writer instance - * @param writer any The new Writer, which can be either a type string, a configuration object or an Ext.data.writer.Writer instance - */ - setWriter?( writer?:any ): Ext.data.writer.IWriter; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IProxy extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) True to batch actions of a particular type when synchronizing the store. ... */ - batchActions?: boolean; - /** [Config Option] (String) Comma-separated ordering 'create', 'update' and 'destroy' actions when batching. ... */ - batchOrder?: string; - /** [Config Option] (String/Ext.data.Model) The name of the Model to tie to this Proxy. ... */ - model?: any; - /** [Config Option] (Object/String/Ext.data.reader.Reader) The Ext.data.reader.Reader to use to decode the server's response or data read from client. ... */ - reader?: any; - /** [Config Option] (Object/String/Ext.data.writer.Writer) The Ext.data.writer.Writer to use to encode any request sent to the server or saved to client. ... */ - writer?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Proxy, or subclass thereof. ... */ - isProxy?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs a batch of Operations in the order specified by batchOrder - * @param options Object Object containing one or more properties supported by the batch method: - */ - batch?( options?:any ): Ext.data.IBatch; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Performs the given create operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the model attached to this Proxy */ - getModel?(): Ext.data.IModel; - /** [Method] Returns the reader currently attached to this proxy instance */ - getReader?(): Ext.data.reader.IReader; - /** [Method] Returns the writer currently attached to this proxy instance */ - getWriter?(): Ext.data.writer.IWriter; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the model associated with this proxy - * @param model String The new model. Can be either the model name string, or a reference to the model's constructor - * @param setOnStore Boolean Sets the new model on the associated Store, if one is present - */ - setModel?( model?:string, setOnStore?:boolean ): void; - setModel?( model?:Ext.data.IModel, setOnStore?:boolean ): void; - /** [Method] Sets the Proxy s Reader by string config object or Reader instance - * @param reader any The new Reader, which can be either a type string, a configuration object or an Ext.data.reader.Reader instance - */ - setReader?( reader?:any ): Ext.data.reader.IReader; - /** [Method] Sets the Proxy s Writer by string config object or Writer instance - * @param writer any The new Writer, which can be either a type string, a configuration object or an Ext.data.writer.Writer instance - */ - setWriter?( writer?:any ): Ext.data.writer.IWriter; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data.proxy { - export interface IRest extends Ext.data.proxy.IAjax { - /** [Config Option] (Boolean) True to automatically append the ID of a Model instance when performing a request based on that single instance. ... */ - appendId?: boolean; - /** [Config Option] (Boolean) True to batch actions of a particular type when synchronizing the store. ... */ - batchActions?: boolean; - /** [Config Option] (String) Optional data format to send to the server when making any request (e.g. ... */ - format?: string; - /** [Property] (Object) Mapping of action name to HTTP request method. ... */ - actionMethods?: any; - /** [Method] Specialized version of buildUrl that incorporates the appendId and format options into the generated url - * @param request Object - */ - buildUrl?( request?:any ): string; - } -} -declare module Ext.data { - export interface IRestProxy extends Ext.data.proxy.IAjax { - /** [Config Option] (Boolean) True to automatically append the ID of a Model instance when performing a request based on that single instance. ... */ - appendId?: boolean; - /** [Config Option] (Boolean) True to batch actions of a particular type when synchronizing the store. ... */ - batchActions?: boolean; - /** [Config Option] (String) Optional data format to send to the server when making any request (e.g. ... */ - format?: string; - /** [Property] (Object) Mapping of action name to HTTP request method. ... */ - actionMethods?: any; - /** [Method] Specialized version of buildUrl that incorporates the appendId and format options into the generated url - * @param request Object - */ - buildUrl?( request?:any ): string; - } -} -declare module Ext.data.proxy { - export interface IServer extends Ext.data.proxy.IProxy { - /** [Config Option] (Object) Specific urls to call on CRUD action methods "create", "read", "update" and "destroy". ... */ - api?: any; - /** [Config Option] (String) The name of the cache param added to the url when using noCache. ... */ - cacheString?: string; - /** [Config Option] (String) The name of the direction parameter to send in a request. ... */ - directionParam?: string; - /** [Config Option] (Object) Extra parameters that will be included on every request. ... */ - extraParams?: any; - /** [Config Option] (String) The name of the 'filter' parameter to send in a request. ... */ - filterParam?: string; - /** [Config Option] (String) The name of the direction parameter to send in a request. ... */ - groupDirectionParam?: string; - /** [Config Option] (String) The name of the 'group' parameter to send in a request. ... */ - groupParam?: string; - /** [Config Option] (String) The name of the parameter which carries the id of the entity being operated upon. ... */ - idParam?: string; - /** [Config Option] (String) The name of the 'limit' parameter to send in a request. ... */ - limitParam?: string; - /** [Config Option] (Boolean) Disable caching by adding a unique parameter name to the request. ... */ - noCache?: boolean; - /** [Config Option] (String) The name of the 'page' parameter to send in a request. ... */ - pageParam?: string; - /** [Config Option] (Boolean) Enabling simpleGroupMode in conjunction with remoteGroup will only send one group property and a direction when a rem... */ - simpleGroupMode?: boolean; - /** [Config Option] (Boolean) Enabling simpleSortMode in conjunction with remoteSort will only send one sort property and a direction when a remote... */ - simpleSortMode?: boolean; - /** [Config Option] (String) The name of the 'sort' parameter to send in a request. ... */ - sortParam?: string; - /** [Config Option] (String) The name of the 'start' parameter to send in a request. ... */ - startParam?: string; - /** [Config Option] (Number) The number of milliseconds to wait for a response. ... */ - timeout?: number; - /** [Config Option] (String) */ - url?: string; - /** [Method] Optional callback function which can be used to clean up after a request has been completed - * @param request Ext.data.IRequest The Request object - * @param success Boolean True if the request was successful - */ - afterRequest?( request?:Ext.data.IRequest, success?:boolean ): void; - /** [Method] Creates an Request object from Operation - * @param operation Ext.data.IOperation The operation to execute - */ - buildRequest?( operation?:Ext.data.IOperation ): Ext.data.IRequest; - /** [Method] Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] in a ServerProxy all four CRUD operations are executed in the same manner so we delegate to doRequest in each case - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] In ServerProxy subclasses the create read update and destroy methods all pass through to doRequest - * @param operation Ext.data.IOperation The Ext.data.Operation object - * @param callback Function The callback function to call when the Operation has completed - * @param scope Object The scope in which to execute the callback - */ - doRequest?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Encodes the array of Ext util Filter objects into a string to be sent in the request url - * @param filters Ext.util.IFilter[] The array of Filter objects - */ - encodeFilters?( filters?:Ext.util.IFilter[] ): string; - /** [Method] Encodes the array of Ext util Sorter objects into a string to be sent in the request url - * @param sorters Ext.util.ISorter[] The array of Sorter objects - */ - encodeSorters?( sorters?:Ext.util.ISorter[] ): string; - /** [Method] Template method to allow subclasses to specify how to get the response for the reader - * @param response Object The server response - */ - extractResponseData?( response?:any ): any; - /** [Method] Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Sets a value in the underlying extraParams - * @param name String The key for the new value - * @param value Object The value - */ - setExtraParam?( name?:string, value?:any ): void; - /** [Method] Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IServerProxy extends Ext.data.proxy.IProxy { - /** [Config Option] (Object) Specific urls to call on CRUD action methods "create", "read", "update" and "destroy". ... */ - api?: any; - /** [Config Option] (String) The name of the cache param added to the url when using noCache. ... */ - cacheString?: string; - /** [Config Option] (String) The name of the direction parameter to send in a request. ... */ - directionParam?: string; - /** [Config Option] (Object) Extra parameters that will be included on every request. ... */ - extraParams?: any; - /** [Config Option] (String) The name of the 'filter' parameter to send in a request. ... */ - filterParam?: string; - /** [Config Option] (String) The name of the direction parameter to send in a request. ... */ - groupDirectionParam?: string; - /** [Config Option] (String) The name of the 'group' parameter to send in a request. ... */ - groupParam?: string; - /** [Config Option] (String) The name of the parameter which carries the id of the entity being operated upon. ... */ - idParam?: string; - /** [Config Option] (String) The name of the 'limit' parameter to send in a request. ... */ - limitParam?: string; - /** [Config Option] (Boolean) Disable caching by adding a unique parameter name to the request. ... */ - noCache?: boolean; - /** [Config Option] (String) The name of the 'page' parameter to send in a request. ... */ - pageParam?: string; - /** [Config Option] (Boolean) Enabling simpleGroupMode in conjunction with remoteGroup will only send one group property and a direction when a rem... */ - simpleGroupMode?: boolean; - /** [Config Option] (Boolean) Enabling simpleSortMode in conjunction with remoteSort will only send one sort property and a direction when a remote... */ - simpleSortMode?: boolean; - /** [Config Option] (String) The name of the 'sort' parameter to send in a request. ... */ - sortParam?: string; - /** [Config Option] (String) The name of the 'start' parameter to send in a request. ... */ - startParam?: string; - /** [Config Option] (Number) The number of milliseconds to wait for a response. ... */ - timeout?: number; - /** [Config Option] (String) */ - url?: string; - /** [Method] Optional callback function which can be used to clean up after a request has been completed - * @param request Ext.data.IRequest The Request object - * @param success Boolean True if the request was successful - */ - afterRequest?( request?:Ext.data.IRequest, success?:boolean ): void; - /** [Method] Creates an Request object from Operation - * @param operation Ext.data.IOperation The operation to execute - */ - buildRequest?( operation?:Ext.data.IOperation ): Ext.data.IRequest; - /** [Method] Generates a url based on a given Ext data Request object - * @param request Ext.data.IRequest The request object - */ - buildUrl?( request?:Ext.data.IRequest ): string; - /** [Method] in a ServerProxy all four CRUD operations are executed in the same manner so we delegate to doRequest in each case - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] In ServerProxy subclasses the create read update and destroy methods all pass through to doRequest - * @param operation Ext.data.IOperation The Ext.data.Operation object - * @param callback Function The callback function to call when the Operation has completed - * @param scope Object The scope in which to execute the callback - */ - doRequest?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Encodes the array of Ext util Filter objects into a string to be sent in the request url - * @param filters Ext.util.IFilter[] The array of Filter objects - */ - encodeFilters?( filters?:Ext.util.IFilter[] ): string; - /** [Method] Encodes the array of Ext util Sorter objects into a string to be sent in the request url - * @param sorters Ext.util.ISorter[] The array of Sorter objects - */ - encodeSorters?( sorters?:Ext.util.ISorter[] ): string; - /** [Method] Template method to allow subclasses to specify how to get the response for the reader - * @param response Object The server response - */ - extractResponseData?( response?:any ): any; - /** [Method] Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Sets a value in the underlying extraParams - * @param name String The key for the new value - * @param value Object The value - */ - setExtraParam?( name?:string, value?:any ): void; - /** [Method] Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data.proxy { - export interface ISessionStorage extends Ext.data.proxy.IWebStorage { - } -} -declare module Ext.data { - export interface ISessionStorageProxy extends Ext.data.proxy.IWebStorage { - } -} -declare module Ext.data.proxy { - export interface IWebStorage extends Ext.data.proxy.IClient { - /** [Config Option] (String) */ - id?: string; - /** [Property] (Object) Cached map of records already retrieved by this Proxy. ... */ - cache?: any; - /** [Method] Destroys all records stored in the proxy and removes all keys and values used to support the proxy from the storage o */ - clear?(): void; - /** [Method] inherit docs Performs the given create operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit docs Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Saves the given record in the Proxy - * @param record Ext.data.IModel The model instance - * @param id String The id to save the record under (defaults to the value of the record's getId() function) - */ - setRecord?( record?:Ext.data.IModel, id?:string ): void; - /** [Method] inherit docs Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IWebStorageProxy extends Ext.data.proxy.IClient { - /** [Config Option] (String) */ - id?: string; - /** [Property] (Object) Cached map of records already retrieved by this Proxy. ... */ - cache?: any; - /** [Method] Destroys all records stored in the proxy and removes all keys and values used to support the proxy from the storage o */ - clear?(): void; - /** [Method] inherit docs Performs the given create operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - create?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit Performs the given destroy operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - destroy?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] inherit docs Performs the given read operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - read?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - /** [Method] Saves the given record in the Proxy - * @param record Ext.data.IModel The model instance - * @param id String The id to save the record under (defaults to the value of the record's getId() function) - */ - setRecord?( record?:Ext.data.IModel, id?:string ): void; - /** [Method] inherit docs Performs the given update operation - * @param operation Ext.data.IOperation The Operation to perform - * @param callback Function Callback function to be called when the Operation has completed (whether successful or not) - * @param scope Object Scope to execute the callback function in - */ - update?( operation?:Ext.data.IOperation, callback?:any, scope?:any ): void; - } -} -declare module Ext.data.reader { - export interface IArray extends Ext.data.reader.IJson { - /** [Config Option] (String) Name of the property from which to retrieve the success attribute, the value of which indicates whether a given reque... */ - successProperty?: string; - /** [Config Option] (String) For Array Reader, methods in the base which use these properties must not see the defaults Name of the property from... */ - totalProperty?: string; - } -} -declare module Ext.data { - export interface IArrayReader extends Ext.data.reader.IJson { - /** [Config Option] (String) Name of the property from which to retrieve the success attribute, the value of which indicates whether a given reque... */ - successProperty?: string; - /** [Config Option] (String) For Array Reader, methods in the base which use these properties must not see the defaults Name of the property from... */ - totalProperty?: string; - } -} -declare module Ext.data.reader { - export interface IJson extends Ext.data.reader.IReader { - /** [Config Option] (String) Name of the property from which to retrieve the metaData attribute. ... */ - metaProperty?: string; - /** [Config Option] (String) The optional location within the JSON response that the record data itself can be found at. ... */ - record?: string; - /** [Config Option] (String) The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configu... */ - root?: string; - /** [Config Option] (Boolean) True to ensure that field names/mappings are treated as literals when reading values. ... */ - useSimpleAccessors?: boolean; - /** [Property] (Object) A copy of this.rawData. ... */ - jsonData?: any; - /** [Method] inherit docs Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Reads a JSON object and returns a ResultSet - * @param data Object The raw JSON data - */ - readRecords?( data?:any ): Ext.data.IResultSet; - } -} -declare module Ext.data { - export interface IJsonReader extends Ext.data.reader.IReader { - /** [Config Option] (String) Name of the property from which to retrieve the metaData attribute. ... */ - metaProperty?: string; - /** [Config Option] (String) The optional location within the JSON response that the record data itself can be found at. ... */ - record?: string; - /** [Config Option] (String) The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configu... */ - root?: string; - /** [Config Option] (Boolean) True to ensure that field names/mappings are treated as literals when reading values. ... */ - useSimpleAccessors?: boolean; - /** [Property] (Object) A copy of this.rawData. ... */ - jsonData?: any; - /** [Method] inherit docs Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Reads a JSON object and returns a ResultSet - * @param data Object The raw JSON data - */ - readRecords?( data?:any ): Ext.data.IResultSet; - } -} -declare module Ext.data.reader { - export interface IReader extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) Name of the property within a row object that contains a record identifier value. ... */ - idProperty?: string; - /** [Config Option] (Boolean) True to automatically parse models nested within other models in a response object. ... */ - implicitIncludes?: boolean; - /** [Config Option] (String) The name of the property which contains a response message. ... */ - messageProperty?: string; - /** [Config Option] (Boolean) True to extract the records from a data packet even if the successProperty returns false. ... */ - readRecordsOnFailure?: boolean; - /** [Config Option] (String) The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configu... */ - root?: string; - /** [Config Option] (String) Name of the property from which to retrieve the success attribute, the value of which indicates whether a given reque... */ - successProperty?: string; - /** [Config Option] (String) Name of the property from which to retrieve the total number of records in the dataset. ... */ - totalProperty?: string; - /** [Property] (Object) The raw meta data that was most recently read, if any. ... */ - metaData?: any; - /** [Property] (Object) The raw data object that was last passed to readRecords. ... */ - rawData?: any; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Reads the given response object - * @param response Object The response object. This may be either an XMLHttpRequest object or a plain JS object - */ - read?( response?:any ): Ext.data.IResultSet; - /** [Method] Abstracts common functionality used by all Reader subclasses - * @param data Object The raw data object - */ - readRecords?( data?:any ): Ext.data.IResultSet; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IDataReader extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) Name of the property within a row object that contains a record identifier value. ... */ - idProperty?: string; - /** [Config Option] (Boolean) True to automatically parse models nested within other models in a response object. ... */ - implicitIncludes?: boolean; - /** [Config Option] (String) The name of the property which contains a response message. ... */ - messageProperty?: string; - /** [Config Option] (Boolean) True to extract the records from a data packet even if the successProperty returns false. ... */ - readRecordsOnFailure?: boolean; - /** [Config Option] (String) The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configu... */ - root?: string; - /** [Config Option] (String) Name of the property from which to retrieve the success attribute, the value of which indicates whether a given reque... */ - successProperty?: string; - /** [Config Option] (String) Name of the property from which to retrieve the total number of records in the dataset. ... */ - totalProperty?: string; - /** [Property] (Object) The raw meta data that was most recently read, if any. ... */ - metaData?: any; - /** [Property] (Object) The raw data object that was last passed to readRecords. ... */ - rawData?: any; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Reads the given response object - * @param response Object The response object. This may be either an XMLHttpRequest object or a plain JS object - */ - read?( response?:any ): Ext.data.IResultSet; - /** [Method] Abstracts common functionality used by all Reader subclasses - * @param data Object The raw data object - */ - readRecords?( data?:any ): Ext.data.IResultSet; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface IReader extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) Name of the property within a row object that contains a record identifier value. ... */ - idProperty?: string; - /** [Config Option] (Boolean) True to automatically parse models nested within other models in a response object. ... */ - implicitIncludes?: boolean; - /** [Config Option] (String) The name of the property which contains a response message. ... */ - messageProperty?: string; - /** [Config Option] (Boolean) True to extract the records from a data packet even if the successProperty returns false. ... */ - readRecordsOnFailure?: boolean; - /** [Config Option] (String) The name of the property which contains the data items corresponding to the Model(s) for which this Reader is configu... */ - root?: string; - /** [Config Option] (String) Name of the property from which to retrieve the success attribute, the value of which indicates whether a given reque... */ - successProperty?: string; - /** [Config Option] (String) Name of the property from which to retrieve the total number of records in the dataset. ... */ - totalProperty?: string; - /** [Property] (Object) The raw meta data that was most recently read, if any. ... */ - metaData?: any; - /** [Property] (Object) The raw data object that was last passed to readRecords. ... */ - rawData?: any; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Reads the given response object - * @param response Object The response object. This may be either an XMLHttpRequest object or a plain JS object - */ - read?( response?:any ): Ext.data.IResultSet; - /** [Method] Abstracts common functionality used by all Reader subclasses - * @param data Object The raw data object - */ - readRecords?( data?:any ): Ext.data.IResultSet; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data.reader { - export interface IXml extends Ext.data.reader.IReader { - /** [Config Option] (String) A namespace prefix that will be prepended to the field name when reading a field from an XML node. ... */ - namespace?: string; - /** [Config Option] (String) */ - record?: string; - /** [Property] (Object) Copy of rawData. ... */ - xmlData?: any; - /** [Method] Normalizes the data object - * @param data Object The raw data object - */ - getData?( data?:any ): any; - /** [Method] inherit docs Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Parses an XML document and returns a ResultSet containing the model instances - * @param doc Object Parsed XML document - */ - readRecords?( doc?:any ): Ext.data.IResultSet; - } -} -declare module Ext.data { - export interface IXmlReader extends Ext.data.reader.IReader { - /** [Config Option] (String) A namespace prefix that will be prepended to the field name when reading a field from an XML node. ... */ - namespace?: string; - /** [Config Option] (String) */ - record?: string; - /** [Property] (Object) Copy of rawData. ... */ - xmlData?: any; - /** [Method] Normalizes the data object - * @param data Object The raw data object - */ - getData?( data?:any ): any; - /** [Method] inherit docs Takes a raw response object as passed to the read method and returns the useful data segment from it - * @param response Object The response object - */ - getResponseData?( response?:any ): Ext.data.IResultSet; - /** [Method] Parses an XML document and returns a ResultSet containing the model instances - * @param doc Object Parsed XML document - */ - readRecords?( doc?:any ): Ext.data.IResultSet; - } -} -declare module Ext.data { - export interface IRequest extends Ext.IBase { - /** [Config Option] (String) The name of the action this Request represents. ... */ - action?: string; - /** [Config Option] (String) The HTTP method to use on this Request. ... */ - method?: string; - /** [Config Option] (Object) HTTP request params. ... */ - params?: any; - /** [Config Option] (String) */ - url?: string; - } -} -declare module Ext.data { - export interface IResultSet extends Ext.IBase { - /** [Config Option] (Number) The number of records in this ResultSet. ... */ - count?: number; - /** [Config Option] (Boolean) True if the records have already been loaded. ... */ - loaded?: boolean; - /** [Config Option] (Ext.data.Model[]) */ - records?: Ext.data.IModel[]; - /** [Config Option] (Boolean) True if the ResultSet loaded successfully, false if any errors were encountered. ... */ - success?: boolean; - /** [Config Option] (Number) The total number of records reported by the data source. ... */ - total?: number; - /** [Property] (Number) Copy of this.total. ... */ - totalRecords?: number; - } -} -declare module Ext.data { - export interface ISequentialIdGenerator extends Ext.data.IIdGenerator { - /** [Config Option] (String) The string to place in front of the sequential number for each generated id. ... */ - prefix?: string; - /** [Config Option] (Number) The number at which to start generating sequential id's. ... */ - seed?: number; - /** [Method] Generates and returns the next id */ - generate?(): string; - } -} -declare module Ext.data { - export interface ISortTypes extends Ext.IBase { - } - export class SortTypes { - /** [Method] Date sorting - * @param s Object The value being converted - */ - static asDate( s?:any ): number; - /** [Method] Float sorting - * @param s Object The value being converted - */ - static asFloat( s?:any ): number; - /** [Method] Integer sorting - * @param s Object The value being converted - */ - static asInt( s?:any ): number; - /** [Method] Strips all HTML tags to sort on text only - * @param s Object The value being converted - */ - static asText( s?:any ): string; - /** [Method] Case insensitive string - * @param s Object The value being converted - */ - static asUCString( s?:any ): string; - /** [Method] Strips all HTML tags to sort on text only Case insensitive - * @param s Object The value being converted - */ - static asUCText( s?:any ): string; - /** [Method] Default sort that does nothing - * @param s Object The value being converted - */ - static none( s?:any ): any; - } -} -declare module Ext.data { - export interface IStore extends Ext.data.IAbstractStore { - /** [Config Option] (Boolean) When a Store is used by only one DataView, and should only exist for the lifetime of that view, then configure the au... */ - autoDestroy?: boolean; - /** [Config Option] (Boolean) Allows the Store to prefetch and cache in a page cache, pages of Records, and to then satisfy loading requirements fr... */ - buffered?: boolean; - /** [Config Option] (Boolean) True to empty the store when loading another page via loadPage, nextPage or previousPage. ... */ - clearOnPageLoad?: boolean; - /** [Config Option] (Boolean) true to clear anything in the removed record collection when the store loads. ... */ - clearRemovedOnLoad?: boolean; - /** [Config Option] (Object[]/Ext.data.Model[]) Array of Model instances or data objects to load locally. ... */ - data?: any; - /** [Config Option] (String) The direction in which sorting should be applied when grouping. ... */ - groupDir?: string; - /** [Config Option] (String) The field by which to group data in the store. ... */ - groupField?: string; - /** [Config Option] (Ext.util.MixedCollection) */ - groupers?: Ext.util.IMixedCollection; - /** [Config Option] (Number) When buffered, the number of extra rows to keep cached on the leading side of scrolling buffer as scrolling proceeds. ... */ - leadingBufferZone?: number; - /** [Config Option] (Number) The number of records considered to form a 'page'. ... */ - pageSize?: number; - /** [Config Option] (String/Ext.data.proxy.Proxy/Object) The Proxy to use for this Store. ... */ - proxy?: any; - /** [Config Option] (Number) Valid only when used with a buffered Store. ... */ - purgePageCount?: number; - /** [Config Option] (Boolean) true if the grouping should be performed on the server side, false if it is local only. ... */ - remoteFilter?: boolean; - /** [Config Option] (Boolean) true if the grouping should apply on the server side, false if it is local only. ... */ - remoteGroup?: boolean; - /** [Config Option] (Boolean) true if the sorting should be performed on the server side, false if it is local only. ... */ - remoteSort?: boolean; - /** [Config Option] (Boolean) For local filtering only, causes sort to be called whenever filter is called, causing the sorters to be reapplied aft... */ - sortOnFilter?: boolean; - /** [Config Option] (Number) When buffered, the number of extra records to keep cached on the trailing side of scrolling buffer as scrolling proce... */ - trailingBufferZone?: number; - /** [Property] (Number) The page that the Store has most recently loaded (see loadPage) ... */ - currentPage?: number; - /** [Property] (Ext.util.MixedCollection) A pristine (unfiltered) collection of the records in this store. ... */ - snapshot?: Ext.util.IMixedCollection; - /** [Method] Adds Model instance to the Store - * @param model any An array of Model instances or Model configuration objects, or variable number of Model instance or config arguments. - */ - add?( model?:any ): Ext.data.IModel[]; - /** [Method] Adds a new Filter to this Store s filter set and by default applys the updated filter set to the Store s unfiltered - * @param filters any The set of filters to add to the current filter set. - * @param applyFilters Boolean Pass as false to add the filter but not apply the updated filter set. - */ - addFilter?( filters?:any, applyFilters?:boolean ): void; - /** [Method] Local sort only Inserts the passed Record into the Store at the index where it should go based on the current sort - * @param record Ext.data.IRecord - */ - addSorted?( record?:Ext.data.IRecord ): void; - /** [Method] Runs the aggregate function for all the records in the store - * @param fn Function The function to execute. The function is called with a single parameter, an array of records for that group. - * @param scope Object The scope to execute the function in. Defaults to the store. - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the group average being the value. The grouped parameter is only honored if the store has a groupField. - * @param args Array Any arguments to append to the function call - */ - aggregate?( fn?:any, scope?:any, grouped?:boolean, args?:any[] ): any; - /** [Method] Gets the average value in the store - * @param field String The field in each record - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the group average being the value. The grouped parameter is only honored if the store has a groupField. - */ - average?( field?:string, grouped?:boolean ): any; - /** [Method] Reverts to a view of the Record cache with no filtering applied - * @param suppressEvent Boolean If true the filter is cleared silently. For a locally filtered Store, this means that the filter collection is cleared without firing the datachanged event. For a remotely filtered Store, this means that the filter collection is cleared, but the store is not reloaded from the server. - */ - clearFilter?( suppressEvent?:boolean ): void; - /** [Method] Clear any groupers in the store */ - clearGrouping?(): void; - /** [Method] Collects unique values for a particular dataIndex from this store - * @param dataIndex String The property to collect - * @param allowNull Boolean Pass true to allow null, undefined or empty string values - * @param bypassFilter Boolean Pass true to collect from all records, even ones which are filtered. - */ - collect?( dataIndex?:string, allowNull?:boolean, bypassFilter?:boolean ): Object[]; - /** [Method] Commits all Records with outstanding changes */ - commitChanges?(): void; - /** [Method] Gets the count of items in the store - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the count for each group being the value. The grouped parameter is only honored if the store has a groupField. - */ - count?( grouped?:boolean ): number; - /** [Method] Calls the specified function for each record in the store - * @param fn Function The function to call. The Record is passed as the first parameter. Returning false aborts and exits the iteration. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current record in the iteration. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Filters the loaded set of records by a given set of filters - * @param filters any The set of filters to apply to the data. These are stored internally on the store, but the filtering itself is done on the Store's MixedCollection. See MixedCollection's filter method for filter syntax. Alternatively, pass in a property string. If no parameters are passed, the Store's existing filter set is applied. - * @param value String value to filter by (only if using a property string as the first argument) - */ - filter?( filters?:any, value?:string ): void; - /** [Method] Filters by a function - * @param fn Function The function to be called. It will be passed the following parameters: - * @param scope Object The scope (this reference) in which the function is executed. Defaults to this Store. - */ - filterBy?( fn?:any, scope?:any ): void; - /** [Method] Finds the index of the first matching Record in this store by a specific field value - * @param fieldName any The name of the Record field to test. - * @param value any Either a string that the field value should begin with, or a RegExp to test against the field. - * @param startIndex any The index to start searching at - * @param anyMatch any True to match any part of the string, not just the beginning - * @param caseSensitive any True for case sensitive comparison - * @param exactMatch any True to force exact match (^ and $ characters added to the regex). - */ - find?( fieldName?:any, value?:any, startIndex?:any, anyMatch?:any, caseSensitive?:any, exactMatch?:any ): any; - find?( fieldName?:string, value?:string, startIndex?:number, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): number; - find?( fieldName?:string, value?:RegExp, startIndex?:number, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): number; - /** [Method] Find the index of the first matching Record in this Store by a function - * @param fn Function The function to be called. It will be passed the following parameters: - * @param scope Object The scope (this reference) in which the function is executed. Defaults to this Store. - * @param startIndex Number The index to start searching at - */ - findBy?( fn?:any, scope?:any, startIndex?:number ): number; - /** [Method] Finds the index of the first matching Record in this store by a specific field value - * @param fieldName String The name of the Record field to test. - * @param value Object The value to match the field against. - * @param startIndex Number The index to start searching at - */ - findExact?( fieldName?:string, value?:any, startIndex?:number ): number; - /** [Method] Finds the first matching Record in this store by a specific field value - * @param fieldName any The name of the Record field to test. - * @param value any Either a string that the field value should begin with, or a RegExp to test against the field. - * @param startIndex any The index to start searching at - * @param anyMatch any True to match any part of the string, not just the beginning - * @param caseSensitive any True for case sensitive comparison - * @param exactMatch any True to force exact match (^ and $ characters added to the regex). - */ - findRecord?( fieldName?:any, value?:any, startIndex?:any, anyMatch?:any, caseSensitive?:any, exactMatch?:any ): any; - findRecord?( fieldName?:string, value?:string, startIndex?:number, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): Ext.data.IModel; - findRecord?( fieldName?:string, value?:RegExp, startIndex?:number, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): Ext.data.IModel; - /** [Method] Convenience function for getting the first model instance in the store - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the first record being the value. The grouped parameter is only honored if the store has a groupField. - */ - first?( grouped?:boolean ): any; - /** [Method] Get the Record at the specified index - * @param index Number The index of the Record to find. - */ - getAt?( index?:number ): Ext.data.IModel; - /** [Method] Get the Record with the specified id - * @param id Mixed The id of the Record to find. - */ - getById?( id?:any ): Ext.data.IModel; - /** [Method] Gets the number of records in store */ - getCount?(): number; - /** [Method] Returns the string to group on for a given model instance - * @param instance Ext.data.IModel The model instance - */ - getGroupString?( instance?:Ext.data.IModel ): string; - /** [Method] Returns an array containing the result of applying grouping to the records in this store - * @param groupName String Pass in an optional groupName argument to access a specific group as defined by getGroupString. - */ - getGroups?( groupName?:string ): any; - /** [Method] inherit docs Returns all Model instances that are either currently a phantom e g */ - getNewRecords?(): Ext.data.IModel[]; - /** [Method] Determines the page from a record index - * @param index Number The record index - */ - getPageFromRecordIndex?( index?:number ): number; - /** [Method] Gathers a range of Records between specified indices - * @param start Number The starting index. Defaults to zero for non buffered Stores. - * @param end Number The ending index. Defaults to the last Record for non buffered Stores. - * @param options Object Used when the Store is {@link buffered] and the range may not be available synchronously. - */ - getRange?( start?:number, end?:number, options?:any ): Ext.data.IModel[]; - /** [Method] Returns the total number of Model instances that the Proxy indicates exist */ - getTotalCount?(): number; - /** [Method] inherit docs Returns all Model instances that have been updated in the Store but not yet synchronized with the Proxy */ - getUpdatedRecords?(): Ext.data.IModel[]; - /** [Method] Groups data inside the store - * @param groupers any Either a string name of one of the fields in this Store's configured Model, or an Array of grouper configurations. - * @param direction String The overall direction to group the data by. - */ - group?( groupers?:any, direction?:string ): void; - /** [Method] Get the index of the record within the store - * @param record Ext.data.IModel The Ext.data.Model object to find. - */ - indexOf?( record?:Ext.data.IModel ): number; - /** [Method] Get the index within the store of the Record with the passed id - * @param id String The id of the Record to find. - */ - indexOfId?( id?:string ): number; - /** [Method] Get the index within the entire dataset - * @param record Ext.data.IModel The Ext.data.Model object to find. - */ - indexOfTotal?( record?:Ext.data.IModel ): number; - /** [Method] Inserts Model instances into the Store at the given index and fires the add event - * @param index Number The start index at which to insert the passed Records. - * @param records Ext.data.IModel[] An Array of Ext.data.Model objects to add to the store. - */ - insert?( index?:number, records?:Ext.data.IModel[] ): Ext.data.IModel[]; - /** [Method] Returns true if this store is currently filtered */ - isFiltered?(): boolean; - /** [Method] Checks if the store is currently grouped */ - isGrouped?(): boolean; - /** [Method] Convenience function for getting the last model instance in the store - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the last record being the value. The grouped parameter is only honored if the store has a groupField. - */ - last?( grouped?:boolean ): any; - /** [Method] Loads data into the Store via the configured proxy - * @param options any config object, passed into the Ext.data.Operation object before loading. Additionally addRecords: true can be specified to add these records to the existing records, default is to remove the Store's existing records first. - */ - load?( options?:any ): void; - /** [Method] Loads an array of data straight into the Store - * @param data any Array of data to load. Any non-model instances will be cast into model instances first. - * @param append Boolean true to add the records to the existing records in the store, false to remove the old ones first. - */ - loadData?( data?:any, append?:boolean ): void; - /** [Method] Loads a given page of data by setting the start and limit values appropriately - * @param page Number The number of the page to load. - * @param options Object See options for load. - */ - loadPage?( page?:number, options?:any ): void; - /** [Method] Loads data via the bound Proxy s reader Use this method if you are attempting to load data and want to utilize the c - * @param data Object[] The full JSON object you'd like to load into the Data store. - * @param append Boolean true to add the records to the existing records in the store, false to remove the old ones first. - */ - loadRawData?( data?:Object[], append?:boolean ): void; - /** [Method] Loads an array of model instances into the store fires the datachanged event - * @param records Ext.data.IModel[] The array of records to load - * @param options Object - */ - loadRecords?( records?:Ext.data.IModel[], options?:any ): void; - /** [Method] Gets the maximum value in the store - * @param field String The field in each record - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the maximum in the group being the value. The grouped parameter is only honored if the store has a groupField. - */ - max?( field?:string, grouped?:boolean ): any; - /** [Method] Gets the minimum value in the store - * @param field String The field in each record - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the minimum in the group being the value. The grouped parameter is only honored if the store has a groupField. - */ - min?( field?:string, grouped?:boolean ): any; - /** [Method] Loads the next page in the current data set - * @param options Object See options for load - */ - nextPage?( options?:any ): void; - /** [Method] Prefetches data into the store using its configured proxy - * @param options Object config object, passed into the Ext.data.Operation object before loading. See load - */ - prefetch?( options?:any ): void; - /** [Method] Prefetches a page of data - * @param page Number The page to prefetch - * @param options Object config object, passed into the Ext.data.Operation object before loading. See load - */ - prefetchPage?( page?:number, options?:any ): void; - /** [Method] Ensures that the specified range of rows is present in the cache - * @param start Object - * @param end Object - */ - prefetchRange?( start?:any, end?:any ): void; - /** [Method] Loads the previous page in the current data set - * @param options Object See options for load - */ - previousPage?( options?:any ): void; - /** [Method] Query all the cached records in this Store by name value pair - * @param property any The property to create the filter function for - * @param value any The string/regex to compare the property value to - * @param anyMatch any true if we don't care if the filter value is not the full value. - * @param caseSensitive any true to create a case-sensitive regex. - * @param exactMatch any true to force exact match (^ and $ characters added to the regex). Ignored if anyMatch is true. - */ - query?( property?:any, value?:any, anyMatch?:any, caseSensitive?:any, exactMatch?:any ): any; - query?( property?:string, value?:string, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): Ext.util.IMixedCollection; - query?( property?:string, value?:RegExp, anyMatch?:boolean, caseSensitive?:boolean, exactMatch?:boolean ): Ext.util.IMixedCollection; - /** [Method] Query all the cached records in this Store using a filtering function - * @param fn Function The function to be called. It will be passed the following parameters: - * @param scope Object The scope (this reference) in which the function is executed Defaults to this Store. - */ - queryBy?( fn?:any, scope?:any ): Ext.util.IMixedCollection; - /** [Method] Rejects outstanding changes on all modified records and re insert any records that were removed locally */ - rejectChanges?(): void; - /** [Method] Reloads the store using the last options passed to the load method - * @param options Object A config object which contains options which may override the options passed to the previous load call. - */ - reload?( options?:any ): void; - /** [Method] Removes the specified record s from the Store firing the remove event for each instance that is removed - * @param records Ext.data.IModel Model instance or array of instances to remove or an array of indices from which to remove records. - */ - remove?( records?:Ext.data.IModel ): void; - remove?( records?:Ext.data.IModel[] ): void; - remove?( records?:number ): void; - remove?( records?:number[] ): void; - /** [Method] Removes all items from the store - * @param silent Boolean Pass true to prevent the record bulkremove and clear events from being fired. - */ - removeAll?( silent?:boolean ): void; - /** [Method] Removes the model instance s at the given index - * @param index Number The record index - * @param count Number The number of records to delete - */ - removeAt?( index?:number, count?:number ): void; - /** [Method] Removes an individual Filter from the current filter set using the passed Filter Filter id and by default applys the - * @param toRemove Mixed The id of a Filter to remove from the filter set, or a Filter instance to remove. - * @param applyFilters Boolean Pass as false to remove the filter but not apply the updated filter set. If null is passed, all anonymous Filters (Filters with no id property) will be removed. - */ - removeFilter?( toRemove?:any, applyFilters?:boolean ): void; - /** [Method] because prefetchData is stored by index this invalidates all of the prefetchedData Sorts the data in the Store by on - * @param sorters any Either a string name of one of the fields in this Store's configured Model, or an array of sorter configurations. - * @param direction any The overall direction to sort the data by. - */ - sort?( sorters?:any, direction?:any ): any; - sort?( sorters?:string, direction?:string ): Ext.util.ISorter[]; - sort?( sorters?:Ext.util.ISorter[], direction?:string ): Ext.util.ISorter[]; - /** [Method] Sums the value of field for each record in store and returns the result - * @param field String A field in each record - * @param grouped Boolean True to perform the operation for each group in the store. The value returned will be an object literal with the key being the group name and the sum for that group being the value. The grouped parameter is only honored if the store has a groupField. - */ - sum?( field?:string, grouped?:boolean ): number; - } -} -declare module Ext.data.store { - export interface IPageMap extends Ext.util.ILruCache { - /** [Method] Returns the first record in this page map which elicits a true return value from the passed selection function - * @param fn Function The selection function to execute for each item. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to this PageMap. - */ - findBy?( fn?:any, scope?:any ): any; - } -} -declare module Ext.data { - export interface IStoreManager extends Ext.util.IMixedCollection { - } - export class StoreManager { - /** [Method] getKey implementation for MixedCollection A function which will be called passing a newly added object when the obj - * @param item Object The item for which to find the key. - */ - static getKey( item?:any ): any; - /** [Method] Gets a registered Store by id - * @param store any The id of the Store, or a Store instance, or a store configuration - */ - static lookup( store?:any ): Ext.data.IStore; - /** [Method] Registers one or more Stores with the StoreManager - * @param stores Ext.data.IStore Any number of Store instances - */ - static register( stores:Ext.data.IStore ): void; - /** [Method] Unregisters one or more Stores with the StoreManager - * @param stores any Any number of Store instances or ID-s - */ - static unregister( stores?:any ): void; - } -} -declare module Ext { - export interface IStoreManager extends Ext.util.IMixedCollection { - } - export class StoreManager { - /** [Method] getKey implementation for MixedCollection A function which will be called passing a newly added object when the obj - * @param item Object The item for which to find the key. - */ - static getKey( item?:any ): any; - /** [Method] Gets a registered Store by id - * @param store any The id of the Store, or a Store instance, or a store configuration - */ - static lookup( store?:any ): Ext.data.IStore; - /** [Method] Registers one or more Stores with the StoreManager - * @param stores Ext.data.IStore Any number of Store instances - */ - static register( stores:Ext.data.IStore ): void; - /** [Method] Unregisters one or more Stores with the StoreManager - * @param stores any Any number of Store instances or ID-s - */ - static unregister( stores?:any ): void; - } -} -declare module Ext { - export interface IStoreMgr extends Ext.util.IMixedCollection { - } - export class StoreMgr { - /** [Method] getKey implementation for MixedCollection A function which will be called passing a newly added object when the obj - * @param item Object The item for which to find the key. - */ - static getKey( item?:any ): any; - /** [Method] Gets a registered Store by id - * @param store any The id of the Store, or a Store instance, or a store configuration - */ - static lookup( store?:any ): Ext.data.IStore; - /** [Method] Registers one or more Stores with the StoreManager - * @param stores Ext.data.IStore Any number of Store instances - */ - static register( stores:Ext.data.IStore ): void; - /** [Method] Unregisters one or more Stores with the StoreManager - * @param stores any Any number of Store instances or ID-s - */ - static unregister( stores?:any ): void; - } -} -declare module Ext.data { - export interface IStoreMgr extends Ext.util.IMixedCollection { - } - export class StoreMgr { - /** [Method] getKey implementation for MixedCollection A function which will be called passing a newly added object when the obj - * @param item Object The item for which to find the key. - */ - static getKey( item?:any ): any; - /** [Method] Gets a registered Store by id - * @param store any The id of the Store, or a Store instance, or a store configuration - */ - static lookup( store?:any ): Ext.data.IStore; - /** [Method] Registers one or more Stores with the StoreManager - * @param stores Ext.data.IStore Any number of Store instances - */ - static register( stores:Ext.data.IStore ): void; - /** [Method] Unregisters one or more Stores with the StoreManager - * @param stores any Any number of Store instances or ID-s - */ - static unregister( stores?:any ): void; - } -} -declare module Ext.data { - export interface ITree extends Ext.IBase,Ext.util.IObservable { - /** [Property] (Ext.data.NodeInterface) */ - root?: Ext.data.INodeInterface; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Gets a node in this tree by its id - * @param id String - */ - getNodeById?( id?:string ): Ext.data.INodeInterface; - /** [Method] Returns the root node for this tree */ - getRootNode?(): Ext.data.INodeInterface; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Removes the root node from this tree */ - removeRootNode?(): Ext.data.INodeInterface; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the root node for this tree - * @param node Ext.data.INodeInterface - */ - setRootNode?( node?:Ext.data.INodeInterface ): Ext.data.INodeInterface; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.data { - export interface ITreeModel extends Ext.data.IModel { - } -} -declare module Ext.data { - export interface ITreeStore extends Ext.data.IAbstractStore { - /** [Config Option] (Boolean) Remove previously existing child nodes before loading. ... */ - clearOnLoad?: boolean; - /** [Config Option] (Boolean) If true, when a node is reloaded, any records in the removed record collection that were previously descendants of th... */ - clearRemovedOnLoad?: boolean; - /** [Config Option] (String) The default root id. ... */ - defaultRootId?: string; - /** [Config Option] (String) The root property to specify on the reader if one is not explicitly defined. ... */ - defaultRootProperty?: string; - /** [Config Option] (String) The default root text (if not specified)/ ... */ - defaultRootText?: string; - /** [Config Option] (Boolean) Set to true to automatically prepend a leaf sorter. ... */ - folderSort?: boolean; - /** [Config Option] (String) The name of the parameter sent to the server which contains the identifier of the node. ... */ - nodeParam?: string; - /** [Config Option] (Ext.data.Model/Ext.data.NodeInterface/Object) The root node for this store. ... */ - root?: any; - /** [Method] inherit docs Returns all Model instances that are either currently a phantom e g */ - getNewRecords?(): Ext.data.IModel[]; - /** [Method] Returns the record node by id - * @param id Object - */ - getNodeById?( id?:any ): Ext.data.INodeInterface; - /** [Method] Returns the root node for this tree */ - getRootNode?(): Ext.data.INodeInterface; - /** [Method] inherit docs Returns all Model instances that have been updated in the Store but not yet synchronized with the Proxy */ - getUpdatedRecords?(): Ext.data.IModel[]; - /** [Method] Loads the Store using its configured proxy - * @param options Object config object. This is passed into the Operation object that is created and then sent to the proxy's Ext.data.proxy.Proxy.read function. The options can also contain a node, which indicates which node is to be loaded. If not specified, it will default to the root node. - */ - load?( options?:any ): void; - /** [Method] inherit docs Removes all records from the store */ - removeAll?(): void; - /** [Method] inherit docs Sets the Store s Proxy by string config object or Proxy instance - * @param proxy any The new Proxy, which can be either a type string, a configuration object or an Ext.data.proxy.Proxy instance - */ - setProxy?( proxy?:any ): Ext.data.proxy.IProxy; - /** [Method] Sets the root node for this store - * @param root any - */ - setRootNode?( root?:any ): Ext.data.INodeInterface; - } -} -declare module Ext.data { - export interface ITypes extends Ext.IBase { - } - export class Types { - } -} -declare module Ext.data { - export interface IUuidGenerator extends Ext.data.IIdGenerator { - /** [Config Option] (Number) The Version of UUID. ... */ - version?: number; - /** [Property] (Number/Object) When created, this value is a 48-bit number. ... */ - salt?: any; - /** [Property] (Number/Object) When created, this value is a 60-bit number. ... */ - timestamp?: any; - /** [Method] Reconfigures this generator given new config properties - * @param config Object - */ - reconfigure?( config?:any ): void; - } -} -declare module Ext.data { - export interface Ivalidations extends Ext.IBase { - } - export class validations { - /** [Method] Validates that an email string is in the correct format - * @param config Object Config object - * @param email String The email address - */ - static email( config?:any, email?:string ): boolean; - /** [Method] Validates that the given value is not present in the configured list - * @param config Object Config object - * @param value String The value to validate - */ - static exclusion( config?:any, value?:string ): boolean; - /** [Method] Returns true if the given value passes validation against the configured matcher regex - * @param config Object Config object - * @param value String The value to validate - */ - static format( config?:any, value?:string ): boolean; - /** [Method] Validates that the given value is present in the configured list - * @param config Object Config object - * @param value String The value to validate - */ - static inclusion( config?:any, value?:string ): boolean; - /** [Method] Returns true if the given value is between the configured min and max values - * @param config Object Config object - * @param value String The value to validate - */ - static length( config?:any, value?:string ): boolean; - /** [Method] Validates that the given value is present - * @param config Object Config object - * @param value Object The value to validate - */ - static presence( config?:any, value?:any ): boolean; - } -} -declare module Ext.data.writer { - export interface IJson extends Ext.data.writer.IWriter { - /** [Config Option] (Boolean) Configure with false to ensure that records are always wrapped in an array, even if there is only one record being sent. ... */ - allowSingle?: boolean; - /** [Config Option] (Boolean) Configure true to send record data (all record fields if writeAllFields is true) as a JSON encoded HTTP parameter nam... */ - encode?: boolean; - /** [Config Option] (Boolean) By default, when dot-delimited field mappings are used (e.g. ... */ - expandData?: boolean; - /** [Config Option] (String) */ - root?: string; - /** [Method] The Reader classes support dot delimited data mappings for extracting nested raw data into fields so the writer must - * @param data Object - */ - getExpandedData?( data?:any ): void; - } -} -declare module Ext.data { - export interface IJsonWriter extends Ext.data.writer.IWriter { - /** [Config Option] (Boolean) Configure with false to ensure that records are always wrapped in an array, even if there is only one record being sent. ... */ - allowSingle?: boolean; - /** [Config Option] (Boolean) Configure true to send record data (all record fields if writeAllFields is true) as a JSON encoded HTTP parameter nam... */ - encode?: boolean; - /** [Config Option] (Boolean) By default, when dot-delimited field mappings are used (e.g. ... */ - expandData?: boolean; - /** [Config Option] (String) */ - root?: string; - /** [Method] The Reader classes support dot delimited data mappings for extracting nested raw data into fields so the writer must - * @param data Object - */ - getExpandedData?( data?:any ): void; - } -} -declare module Ext.data.writer { - export interface IWriter extends Ext.IBase { - /** [Config Option] (String) */ - dateFormat?: string; - /** [Config Option] (String) This property is used to read the key for each value that will be sent to the server. ... */ - nameProperty?: string; - /** [Config Option] (Boolean) True to write all fields from the record to the server. ... */ - writeAllFields?: boolean; - /** [Config Option] (Boolean) By default, each record's id is always included in the output for non-phantom records since in most cases the id will... */ - writeRecordId?: boolean; - /** [Method] Formats the data for each record before sending it to the server - * @param record Ext.data.IModel The record that we are writing to the server. - * @param operation Ext.data.IOperation An operation object. - */ - getRecordData?( record?:Ext.data.IModel, operation?:Ext.data.IOperation ): any; - /** [Method] Prepares a Proxy s Ext data Request object - * @param request Ext.data.IRequest The request object - */ - write?( request?:Ext.data.IRequest ): Ext.data.IRequest; - } -} -declare module Ext.data { - export interface IDataWriter extends Ext.IBase { - /** [Config Option] (String) */ - dateFormat?: string; - /** [Config Option] (String) This property is used to read the key for each value that will be sent to the server. ... */ - nameProperty?: string; - /** [Config Option] (Boolean) True to write all fields from the record to the server. ... */ - writeAllFields?: boolean; - /** [Config Option] (Boolean) By default, each record's id is always included in the output for non-phantom records since in most cases the id will... */ - writeRecordId?: boolean; - /** [Method] Formats the data for each record before sending it to the server - * @param record Ext.data.IModel The record that we are writing to the server. - * @param operation Ext.data.IOperation An operation object. - */ - getRecordData?( record?:Ext.data.IModel, operation?:Ext.data.IOperation ): any; - /** [Method] Prepares a Proxy s Ext data Request object - * @param request Ext.data.IRequest The request object - */ - write?( request?:Ext.data.IRequest ): Ext.data.IRequest; - } -} -declare module Ext.data { - export interface IWriter extends Ext.IBase { - /** [Config Option] (String) */ - dateFormat?: string; - /** [Config Option] (String) This property is used to read the key for each value that will be sent to the server. ... */ - nameProperty?: string; - /** [Config Option] (Boolean) True to write all fields from the record to the server. ... */ - writeAllFields?: boolean; - /** [Config Option] (Boolean) By default, each record's id is always included in the output for non-phantom records since in most cases the id will... */ - writeRecordId?: boolean; - /** [Method] Formats the data for each record before sending it to the server - * @param record Ext.data.IModel The record that we are writing to the server. - * @param operation Ext.data.IOperation An operation object. - */ - getRecordData?( record?:Ext.data.IModel, operation?:Ext.data.IOperation ): any; - /** [Method] Prepares a Proxy s Ext data Request object - * @param request Ext.data.IRequest The request object - */ - write?( request?:Ext.data.IRequest ): Ext.data.IRequest; - } -} -declare module Ext.data.writer { - export interface IXml extends Ext.data.writer.IWriter { - /** [Config Option] (String) The root to be used if documentRoot is empty and a root is required to form a valid XML document. ... */ - defaultDocumentRoot?: string; - /** [Config Option] (String) The name of the root element of the document. ... */ - documentRoot?: string; - /** [Config Option] (String) A header to use in the XML document (such as setting the encoding or version). ... */ - header?: string; - /** [Config Option] (String) The name of the node to use for each record. ... */ - record?: string; - } -} -declare module Ext.data { - export interface IXmlWriter extends Ext.data.writer.IWriter { - /** [Config Option] (String) The root to be used if documentRoot is empty and a root is required to form a valid XML document. ... */ - defaultDocumentRoot?: string; - /** [Config Option] (String) The name of the root element of the document. ... */ - documentRoot?: string; - /** [Config Option] (String) A header to use in the XML document (such as setting the encoding or version). ... */ - header?: string; - /** [Config Option] (String) The name of the node to use for each record. ... */ - record?: string; - } -} -declare module Ext.data { - export interface IXmlStore extends Ext.data.IStore { - } -} -declare module Ext { - export interface IDate { - } - export class Date { - /** [Method] Provides a convenient method for performing basic date arithmetic - * @param date Date The date to modify - * @param interval String A valid date interval enum value. - * @param value Number The amount to add to the current date. - */ - static add( date?:any, interval?:string, value?:number ): any; - /** [Method] Checks if a date falls on or between the given start and end dates - * @param date Date The date to check - * @param start Date Start date - * @param end Date End date - */ - static between( date?:any, start?:any, end?:any ): boolean; - /** [Method] Attempts to clear all time information from this Date by setting the time to midnight of the same day automatically - * @param date Date The date - * @param clone Boolean true to create a clone of this date, clear the time and return it. - */ - static clearTime( date?:any, clone?:boolean ): any; - /** [Method] Creates and returns a new Date instance with the exact same date value as the called instance - * @param date Date The date. - */ - static clone( date?:any ): any; - /** [Method] Formats a date given the supplied format string - * @param date Date The date to format - * @param format String The format string - */ - static format( date?:any, format?:string ): string; - /** [Method] Checks if the specified format contains information about anything other than the time - * @param format String The format to check - */ - static formatContainsDateInfo( format?:string ): boolean; - /** [Method] Checks if the specified format contains hour information - * @param format String The format to check - */ - static formatContainsHourInfo( format?:string ): boolean; - /** [Method] Get the numeric day number of the year adjusted for leap year - * @param date Date The date - */ - static getDayOfYear( date?:any ): number; - /** [Method] Get the number of days in the current month adjusted for leap year - * @param date Date The date - */ - static getDaysInMonth( date?:any ): number; - /** [Method] Returns the number of milliseconds between two dates - * @param dateA Date The first date. - * @param dateB Date The second date. - */ - static getElapsed( dateA?:any, dateB?:any ): number; - /** [Method] Get the date of the first day of the month in which this date resides - * @param date Date The date - */ - static getFirstDateOfMonth( date?:any ): any; - /** [Method] Get the first day of the current month adjusted for leap year - * @param date Date The date - */ - static getFirstDayOfMonth( date?:any ): number; - /** [Method] Get the offset from GMT of the current date equivalent to the format specifier O - * @param date Date The date - * @param colon Boolean true to separate the hours and minutes with a colon. - */ - static getGMTOffset( date?:any, colon?:boolean ): string; - /** [Method] Get the date of the last day of the month in which this date resides - * @param date Date The date - */ - static getLastDateOfMonth( date?:any ): any; - /** [Method] Get the last day of the current month adjusted for leap year - * @param date Date The date - */ - static getLastDayOfMonth( date?:any ): number; - /** [Method] Get the zero based JavaScript month number for the given short full month name - * @param name String The short/full month name. - */ - static getMonthNumber( name?:string ): number; - /** [Method] Get the short day name for the given day number - * @param day Number A zero-based JavaScript day number. - */ - static getShortDayName( day?:number ): string; - /** [Method] Get the short month name for the given month number - * @param month Number A zero-based JavaScript month number. - */ - static getShortMonthName( month?:number ): string; - /** [Method] Get the English ordinal suffix of the current day equivalent to the format specifier S - * @param date Date The date - */ - static getSuffix( date?:any ): string; - /** [Method] Get the timezone abbreviation of the current date equivalent to the format specifier T - * @param date Date The date - */ - static getTimezone( date?:any ): string; - /** [Method] Get the numeric ISO 8601 week number of the year - * @param date Date The date - */ - static getWeekOfYear( date?:any ): number; - /** [Method] Checks if the current date is affected by Daylight Saving Time DST - * @param date Date The date - */ - static isDST( date?:any ): boolean; - /** [Method] Compares if two dates are equal by comparing their values - * @param date1 Date - * @param date2 Date - */ - static isEqual( date1?:any, date2?:any ): boolean; - /** [Method] Checks if the current date falls within a leap year - * @param date Date The date - */ - static isLeapYear( date?:any ): boolean; - /** [Method] Checks if the passed Date parameters will cause a JavaScript Date rollover - * @param year Number 4-digit year - * @param month Number 1-based month-of-year - * @param day Number Day of month - * @param hour Number Hour - * @param minute Number Minute - * @param second Number Second - * @param millisecond Number Millisecond - */ - static isValid( year?:number, month?:number, day?:number, hour?:number, minute?:number, second?:number, millisecond?:number ): boolean; - /** [Method] Returns the current timestamp */ - static now(): number; - /** [Method] Parses the passed string using the specified date format - * @param input String The raw date string. - * @param format String The expected date string format. - * @param strict Boolean true to validate date strings while parsing (i.e. prevents JavaScript Date "rollover"). Invalid date strings will return null when parsed. - */ - static parse( input?:string, format?:string, strict?:boolean ): any; - /** [Method] Provides a convenient method for performing basic date arithmetic - * @param date Date The date to modify - * @param interval String A valid date interval enum value. - * @param value Number The amount to subtract from the current date. - */ - static subtract( date?:any, interval?:string, value?:number ): any; - /** [Method] Removes all escaping for a date format string - * @param format String The format to unescape - */ - static unescapeFormat( format?:string ): string; - } -} -declare module Ext.dd { - export interface IDD extends Ext.dd.IDragDrop { - /** [Property] (Boolean) When set to true, the utility automatically tries to scroll the browser window when a drag and drop element is dragge... */ - scroll?: boolean; - /** [Method] Sets the element to the location of the mousedown or click event maintaining the cursor location relative to the loc - * @param el HTMLElement the element to move - * @param iPageX Number the X coordinate of the mousedown or drag event - * @param iPageY Number the Y coordinate of the mousedown or drag event - */ - alignElWithMouse?( el?:HTMLElement, iPageX?:number, iPageY?:number ): void; - /** [Method] Sets up config options specific to this class */ - applyConfig?(): void; - /** [Method] Sets the pointer offset to the distance between the linked element s top left corner and the location the element was - * @param iPageX Number the X coordinate of the click - * @param iPageY Number the Y coordinate of the click - */ - autoOffset?( iPageX?:number, iPageY?:number ): void; - /** [Method] Event that fires prior to the onDrag event - * @param e Object - */ - b4Drag?( e?:any ): void; - /** [Method] Event that fires prior to the onMouseDown event - * @param e Object - */ - b4MouseDown?( e?:any ): void; - /** [Method] Saves the most recent position so that we can reset the constraints and tick marks on demand - * @param iPageX Number the current x position (this just makes it so we don't have to look it up again) - * @param iPageY Number the current y position (this just makes it so we don't have to look it up again) - */ - cachePosition?( iPageX?:number, iPageY?:number ): void; - /** [Method] Sets the pointer offset - * @param iDeltaX Number the distance from the left - * @param iDeltaY Number the distance from the top - */ - setDelta?( iDeltaX?:number, iDeltaY?:number ): void; - /** [Method] Sets the drag element to the location of the mousedown or click event maintaining the cursor location relative to th - * @param iPageX Number the X coordinate of the mousedown or drag event - * @param iPageY Number the Y coordinate of the mousedown or drag event - */ - setDragElPos?( iPageX?:number, iPageY?:number ): void; - /** [Method] toString method */ - toString?(): string; - } -} -declare module Ext.dd { - export interface IDDProxy extends Ext.dd.IDD { - /** [Property] (Boolean) By default the frame is positioned exactly where the drag element is, so we use the cursor offset provided by Ext.dd.DD. ... */ - centerFrame?: boolean; - /** [Property] (Boolean) By default we resize the drag frame to be the same size as the element we want to drag (this is to get the frame effe... */ - resizeFrame?: boolean; - /** [Method] Sets up config options specific to this class */ - applyConfig?(): void; - /** [Method] overrides Ext dd DragDrop Event that fires prior to the onMouseDown event - * @param e Object - */ - b4MouseDown?( e?:any ): void; - /** [Method] Creates the proxy element if it does not yet exist */ - createFrame?(): void; - /** [Method] overrides Ext dd DragDrop By default we try to move the element to the last location of the frame - * @param e Event the mouseup event - */ - endDrag?( e?:Event ): void; - /** [Method] Initialization for the drag frame element */ - initFrame?(): void; - /** [Method] toString method */ - toString?(): string; - } -} -declare module Ext.dd { - export interface IDDTarget extends Ext.dd.IDragDrop { - /** [Method] Overridden and disabled */ - addInvalidHandleClass?(): void; - /** [Method] Overridden and disabled */ - addInvalidHandleId?(): void; - /** [Method] Overridden and disabled */ - addInvalidHandleType?(): void; - /** [Method] Overridden and disabled */ - clearConstraints?(): void; - /** [Method] Overridden and disabled */ - clearTicks?(): void; - /** [Method] Overridden and disabled */ - endDrag?(): void; - /** [Method] Overridden and disabled */ - getDragEl?(): any; - /** [Method] Overridden and disabled */ - isValidHandleChild?(): any; - /** [Method] Overridden and disabled */ - onDrag?(): void; - /** [Method] Overridden and disabled */ - onDragDrop?(): void; - /** [Method] Overridden and disabled */ - onDragEnter?(): void; - /** [Method] Overridden and disabled */ - onDragOut?(): void; - /** [Method] Overridden and disabled */ - onDragOver?(): void; - /** [Method] Overridden and disabled */ - onInvalidDrop?(): void; - /** [Method] Overridden and disabled */ - onMouseDown?(): void; - /** [Method] Overridden and disabled */ - onMouseUp?(): void; - /** [Method] Overridden and disabled */ - removeInvalidHandleClass?(): void; - /** [Method] Overridden and disabled */ - removeInvalidHandleId?(): void; - /** [Method] Overridden and disabled */ - removeInvalidHandleType?(): void; - /** [Method] Overridden and disabled */ - resetConstraints?(): void; - /** [Method] Overridden and disabled */ - setDragElId?(): void; - /** [Method] Overridden and disabled */ - setHandleElId?(): void; - /** [Method] Overridden and disabled */ - setInitPosition?(): void; - /** [Method] Overridden and disabled */ - setOuterHandleElId?(): void; - /** [Method] Overridden and disabled */ - setXConstraint?(): void; - /** [Method] Overridden and disabled */ - setYConstraint?(): void; - /** [Method] Overridden and disabled */ - startDrag?(): void; - /** [Method] toString method */ - toString?(): string; - } -} -declare module Ext.dd { - export interface IDragDrop extends Ext.IBase { - /** [Property] (Boolean) The available property is false until the linked dom element is accessible. ... */ - available?: boolean; - /** [Property] (Object) */ - config?: any; - /** [Property] (Object) Provides default constraint padding to "constrainTo" elements. ... */ - defaultPadding?: any; - /** [Property] (Object) The group defines a logical collection of DragDrop objects that are related. ... */ - groups?: any; - /** [Property] (Boolean) By default, drags can only be initiated if the mousedown occurs in the region the linked element is. ... */ - hasOuterHandles?: boolean; - /** [Property] (String) The id of the element associated with this object. ... */ - id?: string; - /** [Property] (Boolean) Set to false to enable a DragDrop object to fire drag events while dragging over its own Element. ... */ - ignoreSelf?: boolean; - /** [Property] (String[]) */ - invalidHandleClasses?: string[]; - /** [Property] (Object) An object who's property names identify the IDs of elements to be considered invalid as drag handles. ... */ - invalidHandleIds?: any; - /** [Property] (Object) An object who's property names identify HTML tags to be considered invalid as drag handles. ... */ - invalidHandleTypes?: any; - /** [Property] (Boolean) By default, all instances can be a drop target. ... */ - isTarget?: boolean; - /** [Property] (Boolean) Maintain offsets when we resetconstraints. ... */ - maintainOffset?: boolean; - /** [Property] (Boolean) When set to true, other DD objects in cooperating DDGroups do not receive notification events when this DD object is ... */ - moveOnly?: boolean; - /** [Property] (Number[]) The padding configured for this drag and drop object for calculating the drop zone intersection with this object. ... */ - padding?: number[]; - /** [Property] (Boolean) By default the drag and drop instance will only respond to the primary button click (left button for a right-handed m... */ - primaryButtonOnly?: boolean; - /** [Property] (Number[]) Array of pixel locations the element will snap to if we specified a horizontal graduation/interval. ... */ - xTicks?: number[]; - /** [Property] (Number[]) Array of pixel locations the element will snap to if we specified a vertical graduation/interval. ... */ - yTicks?: number[]; - /** [Method] Lets you specify a css class of elements that will not initiate a drag - * @param cssClass String the class of the elements you wish to ignore - */ - addInvalidHandleClass?( cssClass?:string ): void; - /** [Method] Lets you to specify an element id for a child of a drag handle that should not initiate a drag - * @param id String the element id of the element you wish to ignore - */ - addInvalidHandleId?( id?:string ): void; - /** [Method] Allows you to specify a tag name that should not start a drag operation when clicked - * @param tagName String the type of element to exclude - */ - addInvalidHandleType?( tagName?:string ): void; - /** [Method] Adds this instance to a group of related drag drop objects - * @param sGroup String the name of the group - */ - addToGroup?( sGroup?:string ): void; - /** [Method] Applies the configuration parameters that were passed into the constructor */ - applyConfig?(): void; - /** [Method] Clears any constraints applied to this instance */ - clearConstraints?(): void; - /** [Method] Clears any tick interval defined for this instance */ - clearTicks?(): void; - /** [Method] Initializes the drag drop object s constraints to restrict movement to a certain element - * @param constrainTo String The element or element ID to constrain to. - * @param pad any Pad provides a way to specify "padding" of the constraints, and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or an object containing the sides to pad. For example: {right:10, bottom:10} - * @param inContent Boolean Constrain the draggable in the content box of the element (inside padding and borders) - */ - constrainTo?( constrainTo?:string, pad?:any, inContent?:boolean ): void; - constrainTo?( constrainTo?:HTMLElement, pad?:any, inContent?:boolean ): void; - constrainTo?( constrainTo?:Ext.IElement, pad?:any, inContent?:boolean ): void; - /** [Method] Called when we are done dragging the object - * @param e Event the mouseup event - */ - endDrag?( e?:Event ): void; - /** [Method] Returns a reference to the actual element to drag */ - getDragEl?(): any; - /** [Method] Returns a reference to the linked element */ - getEl?(): HTMLElement; - /** [Method] Sets up the DragDrop object - * @param id String the id of the linked element - * @param sGroup String the group of related items - * @param config Object configuration attributes - */ - init?( id?:string, sGroup?:string, config?:any ): void; - /** [Method] Initializes Targeting functionality only - * @param id String the id of the linked element - * @param sGroup String the group of related items - * @param config Object configuration attributes - */ - initTarget?( id?:string, sGroup?:string, config?:any ): void; - /** [Method] Returns true if this instance is locked or the drag drop mgr is locked meaning that all drag drop is disabled on th */ - isLocked?(): boolean; - /** [Method] Checks the tag exclusion list to see if this click should be ignored - * @param node HTMLElement the HTMLElement to evaluate - */ - isValidHandleChild?( node?:HTMLElement ): any; - /** [Method] Locks this instance */ - lock?(): void; - /** [Method] Override the onAvailable method to do what is needed after the initial position was determined */ - onAvailable?(): void; - /** [Method] Abstract method called during the onMouseMove event while dragging an object - * @param e Event the mousemove event - */ - onDrag?( e?:Event ): void; - /** [Method] Abstract method called when this item is dropped on another DragDrop obj - * @param e Event the mouseup event - * @param id String In POINT mode, the element id this was dropped on. In INTERSECT mode, an array of dd items this was dropped on. - */ - onDragDrop?( e?:Event, id?:string ): void; - onDragDrop?( e?:Event, id?:Ext.dd.IDragDrop[] ): void; - /** [Method] Abstract method called when this element fist begins hovering over another DragDrop obj - * @param e Event the mousemove event - * @param id String In POINT mode, the element id this is hovering over. In INTERSECT mode, an array of one or more dragdrop items being hovered over. - */ - onDragEnter?( e?:Event, id?:string ): void; - onDragEnter?( e?:Event, id?:Ext.dd.IDragDrop[] ): void; - /** [Method] Abstract method called when we are no longer hovering over an element - * @param e Event the mousemove event - * @param id String In POINT mode, the element id this was hovering over. In INTERSECT mode, an array of dd items that the mouse is no longer over. - */ - onDragOut?( e?:Event, id?:string ): void; - onDragOut?( e?:Event, id?:Ext.dd.IDragDrop[] ): void; - /** [Method] Abstract method called when this element is hovering over another DragDrop obj - * @param e Event the mousemove event - * @param id String In POINT mode, the element id this is hovering over. In INTERSECT mode, an array of dd items being hovered over. - */ - onDragOver?( e?:Event, id?:string ): void; - onDragOver?( e?:Event, id?:Ext.dd.IDragDrop[] ): void; - /** [Method] Abstract method called when this item is dropped on an area with no drop target - * @param e Event the mouseup event - */ - onInvalidDrop?( e?:Event ): void; - /** [Method] Called when a drag drop obj gets a mousedown - * @param e Event the mousedown event - */ - onMouseDown?( e?:Event ): void; - /** [Method] Called when a drag drop obj gets a mouseup - * @param e Event the mouseup event - */ - onMouseUp?( e?:Event ): void; - /** [Method] Removes this instance from the supplied interaction group - * @param sGroup String The group to drop - */ - removeFromGroup?( sGroup?:string ): void; - /** [Method] Unsets an invalid css class - * @param cssClass String the class of the element(s) you wish to re-enable - */ - removeInvalidHandleClass?( cssClass?:string ): void; - /** [Method] Unsets an invalid handle id - * @param id String the id of the element to re-enable - */ - removeInvalidHandleId?( id?:string ): void; - /** [Method] Unsets an excluded tag name set by addInvalidHandleType - * @param tagName String the type of element to unexclude - */ - removeInvalidHandleType?( tagName?:string ): void; - /** [Method] Must be called if you manually reposition a dd element - * @param maintainOffset Boolean - */ - resetConstraints?( maintainOffset?:boolean ): void; - /** [Method] Allows you to specify that an element other than the linked element will be moved with the cursor during a drag - * @param id String the id of the element that will be used to initiate the drag - */ - setDragElId?( id?:string ): void; - /** [Method] Allows you to specify a child of the linked element that should be used to initiate the drag operation - * @param id String the id of the element that will be used to initiate the drag. - */ - setHandleElId?( id?:string ): void; - /** [Method] Stores the initial placement of the linked element - * @param diffX Number the X offset, default 0 - * @param diffY Number the Y offset, default 0 - */ - setInitPosition?( diffX?:number, diffY?:number ): void; - /** [Method] Allows you to set an element outside of the linked element as a drag handle - * @param id String the id of the element that will be used to initiate the drag - */ - setOuterHandleElId?( id?:string ): void; - /** [Method] Configures the padding for the target zone in px - * @param iTop Number Top pad - * @param iRight Number Right pad - * @param iBot Number Bot pad - * @param iLeft Number Left pad - */ - setPadding?( iTop?:number, iRight?:number, iBot?:number, iLeft?:number ): void; - /** [Method] By default the element can be dragged any place on the screen - * @param iLeft Number the number of pixels the element can move to the left - * @param iRight Number the number of pixels the element can move to the right - * @param iTickSize Number parameter for specifying that the element should move iTickSize pixels at a time. - */ - setXConstraint?( iLeft?:number, iRight?:number, iTickSize?:number ): void; - /** [Method] By default the element can be dragged any place on the screen - * @param iUp Number the number of pixels the element can move up - * @param iDown Number the number of pixels the element can move down - * @param iTickSize Number parameter for specifying that the element should move iTickSize pixels at a time. - */ - setYConstraint?( iUp?:number, iDown?:number, iTickSize?:number ): void; - /** [Method] Abstract method called after a drag drop object is clicked and the drag or mousedown time thresholds have beeen met - * @param x Number X click location - * @param y Number Y click location - */ - startDrag?( x?:number, y?:number ): void; - /** [Method] toString method */ - toString?(): string; - /** [Method] Unlocks this instace */ - unlock?(): void; - /** [Method] Removes all drag and drop hooks for this element */ - unreg?(): void; - } -} -declare module Ext.dd { - export interface IDragDropElement { - /** [Method] Returns the X position of an html element - * @param el HTMLElement the element for which to get the position - */ - getPosX?( el?:HTMLElement ): number; - /** [Method] Returns the Y position of an html element - * @param el HTMLElement the element for which to get the position - */ - getPosY?( el?:HTMLElement ): number; - /** [Method] Gets the scrollLeft */ - getScrollLeft?(): number; - /** [Method] Gets the scrollTop */ - getScrollTop?(): number; - /** [Method] Returns the specified element style property - * @param el HTMLElement the element - * @param styleProp String the style property - */ - getStyle?( el?:HTMLElement, styleProp?:string ): string; - /** [Method] Recursively searches the immediate parent and all child nodes for the handle element in order to determine wheter or - * @param node HTMLElement the html element to inspect - */ - handleWasClicked?( node?:HTMLElement ): void; - /** [Method] Sets the x y position of an element to the location of the target element - * @param moveEl HTMLElement The element to move - * @param targetEl HTMLElement The position reference element - */ - moveToEl?( moveEl?:HTMLElement, targetEl?:HTMLElement ): void; - /** [Method] Numeric array sort function - * @param a Number - * @param b Number - */ - numericSort?( a?:number, b?:number ): number; - /** [Method] Swap two nodes - * @param n1 HTMLElement the first node to swap - * @param n2 HTMLElement the other node to swap - */ - swapNode?( n1?:HTMLElement, n2?:HTMLElement ): void; - } -} -declare module Ext.dd.dragdropmanager { - export interface IElementWrapper { - /** [Property] (Object) */ - css?: any; - /** [Property] (Object) */ - el?: any; - /** [Property] (Object) */ - id?: any; - } -} -declare module Ext.dd { - export interface IDragDropManager extends Ext.IBase { - } - export class DragDropManager { - /** [Method] Helper function for getting the best match from the list of drag and drop objects returned by the drag and drop event - * @param dds Ext.dd.IDragDrop[] The array of drag and drop objects targeted - */ - static getBestMatch( dds?:Ext.dd.IDragDrop[] ): Ext.dd.IDragDrop; - /** [Method] Returns the style property for the DOM element i e document getElById id style - * @param id String the id of the elment to get - */ - static getCss( id?:string ): any; - /** [Method] Returns the DragDrop instance for a given id - * @param id String the id of the DragDrop object - */ - static getDDById( id?:string ): Ext.dd.IDragDrop; - /** [Method] Returns a Region object containing the drag and drop element s position and size including the padding configured fo - * @param oDD Ext.dd.IDragDrop the drag and drop object to get the location for. - */ - static getLocation( oDD?:Ext.dd.IDragDrop ): Ext.util.IRegion; - /** [Method] Returns the drag and drop instances that are in all groups the passed in instance belongs to - * @param p_oDD Ext.dd.IDragDrop the obj to get related data for - * @param bTargetsOnly Boolean if true, only return targetable objs - */ - static getRelated( p_oDD?:Ext.dd.IDragDrop, bTargetsOnly?:boolean ): Ext.dd.IDragDrop[]; - /** [Method] Utility function to determine if a given element has been registered as a drag drop item - * @param id String the element id to check - */ - static isDragDrop( id?:string ): boolean; - /** [Method] Utility function to determine if a given element has been registered as a drag drop handle for the given Drag Drop ob - * @param id String the element id to check - */ - static isHandle( id?:string ): boolean; - /** [Method] Returns true if the specified dd target is a legal target for the specifice drag obj - * @param oDD Ext.dd.IDragDrop the drag obj - * @param oTargetDD Ext.dd.IDragDrop the target - */ - static isLegalTarget( oDD?:Ext.dd.IDragDrop, oTargetDD?:Ext.dd.IDragDrop ): boolean; - /** [Method] Is drag and drop locked */ - static isLocked(): boolean; - /** [Method] My goal is to be able to transparently determine if an object is typeof DragDrop and the exact subclass of DragDrop - * @param the Object object to evaluate - */ - static isTypeOfDD( the?:any ): boolean; - /** [Method] Lock all drag and drop functionality */ - static lock(): void; - /** [Method] Refreshes the cache of the top left and bottom right points of the drag and drop objects in the specified group s - * @param groups Object an associative array of groups to refresh - */ - static refreshCache( groups?:any ): void; - /** [Method] Each DragDrop instance must be registered with the DragDropManager - * @param oDD Ext.dd.IDragDrop the DragDrop object to register - * @param sGroup String the name of the group this element belongs to - */ - static regDragDrop( oDD?:Ext.dd.IDragDrop, sGroup?:string ): void; - /** [Method] Each DragDrop handle element must be registered - * @param sDDId String the DragDrop id this element is a handle for - * @param sHandleId String the id of the element that is the drag handle - */ - static regHandle( sDDId?:string, sHandleId?:string ): void; - /** [Method] Fired when either the drag pixel threshold or the mousedown hold time threshold has been met - * @param x Number the X position of the original mousedown - * @param y Number the Y position of the original mousedown - */ - static startDrag( x?:number, y?:number ): void; - /** [Method] Utility to stop event propagation and event default if these features are turned on - * @param e Event the event as returned by this.getEvent() - */ - static stopEvent( e?:Event ): void; - /** [Method] Unlock all drag and drop functionality */ - static unlock(): void; - /** [Method] This checks to make sure an element exists and is in the DOM - * @param el HTMLElement the element to check - */ - static verifyEl( el?:HTMLElement ): boolean; - } -} -declare module Ext.dd { - export interface IDDM extends Ext.IBase { - } - export class DDM { - /** [Method] Helper function for getting the best match from the list of drag and drop objects returned by the drag and drop event - * @param dds Ext.dd.IDragDrop[] The array of drag and drop objects targeted - */ - static getBestMatch( dds?:Ext.dd.IDragDrop[] ): Ext.dd.IDragDrop; - /** [Method] Returns the style property for the DOM element i e document getElById id style - * @param id String the id of the elment to get - */ - static getCss( id?:string ): any; - /** [Method] Returns the DragDrop instance for a given id - * @param id String the id of the DragDrop object - */ - static getDDById( id?:string ): Ext.dd.IDragDrop; - /** [Method] Returns a Region object containing the drag and drop element s position and size including the padding configured fo - * @param oDD Ext.dd.IDragDrop the drag and drop object to get the location for. - */ - static getLocation( oDD?:Ext.dd.IDragDrop ): Ext.util.IRegion; - /** [Method] Returns the drag and drop instances that are in all groups the passed in instance belongs to - * @param p_oDD Ext.dd.IDragDrop the obj to get related data for - * @param bTargetsOnly Boolean if true, only return targetable objs - */ - static getRelated( p_oDD?:Ext.dd.IDragDrop, bTargetsOnly?:boolean ): Ext.dd.IDragDrop[]; - /** [Method] Utility function to determine if a given element has been registered as a drag drop item - * @param id String the element id to check - */ - static isDragDrop( id?:string ): boolean; - /** [Method] Utility function to determine if a given element has been registered as a drag drop handle for the given Drag Drop ob - * @param id String the element id to check - */ - static isHandle( id?:string ): boolean; - /** [Method] Returns true if the specified dd target is a legal target for the specifice drag obj - * @param oDD Ext.dd.IDragDrop the drag obj - * @param oTargetDD Ext.dd.IDragDrop the target - */ - static isLegalTarget( oDD?:Ext.dd.IDragDrop, oTargetDD?:Ext.dd.IDragDrop ): boolean; - /** [Method] Is drag and drop locked */ - static isLocked(): boolean; - /** [Method] My goal is to be able to transparently determine if an object is typeof DragDrop and the exact subclass of DragDrop - * @param the Object object to evaluate - */ - static isTypeOfDD( the?:any ): boolean; - /** [Method] Lock all drag and drop functionality */ - static lock(): void; - /** [Method] Refreshes the cache of the top left and bottom right points of the drag and drop objects in the specified group s - * @param groups Object an associative array of groups to refresh - */ - static refreshCache( groups?:any ): void; - /** [Method] Each DragDrop instance must be registered with the DragDropManager - * @param oDD Ext.dd.IDragDrop the DragDrop object to register - * @param sGroup String the name of the group this element belongs to - */ - static regDragDrop( oDD?:Ext.dd.IDragDrop, sGroup?:string ): void; - /** [Method] Each DragDrop handle element must be registered - * @param sDDId String the DragDrop id this element is a handle for - * @param sHandleId String the id of the element that is the drag handle - */ - static regHandle( sDDId?:string, sHandleId?:string ): void; - /** [Method] Fired when either the drag pixel threshold or the mousedown hold time threshold has been met - * @param x Number the X position of the original mousedown - * @param y Number the Y position of the original mousedown - */ - static startDrag( x?:number, y?:number ): void; - /** [Method] Utility to stop event propagation and event default if these features are turned on - * @param e Event the event as returned by this.getEvent() - */ - static stopEvent( e?:Event ): void; - /** [Method] Unlock all drag and drop functionality */ - static unlock(): void; - /** [Method] This checks to make sure an element exists and is in the DOM - * @param el HTMLElement the element to check - */ - static verifyEl( el?:HTMLElement ): boolean; - } -} -declare module Ext.dd { - export interface IDragDropMgr extends Ext.IBase { - } - export class DragDropMgr { - /** [Method] Helper function for getting the best match from the list of drag and drop objects returned by the drag and drop event - * @param dds Ext.dd.IDragDrop[] The array of drag and drop objects targeted - */ - static getBestMatch( dds?:Ext.dd.IDragDrop[] ): Ext.dd.IDragDrop; - /** [Method] Returns the style property for the DOM element i e document getElById id style - * @param id String the id of the elment to get - */ - static getCss( id?:string ): any; - /** [Method] Returns the DragDrop instance for a given id - * @param id String the id of the DragDrop object - */ - static getDDById( id?:string ): Ext.dd.IDragDrop; - /** [Method] Returns a Region object containing the drag and drop element s position and size including the padding configured fo - * @param oDD Ext.dd.IDragDrop the drag and drop object to get the location for. - */ - static getLocation( oDD?:Ext.dd.IDragDrop ): Ext.util.IRegion; - /** [Method] Returns the drag and drop instances that are in all groups the passed in instance belongs to - * @param p_oDD Ext.dd.IDragDrop the obj to get related data for - * @param bTargetsOnly Boolean if true, only return targetable objs - */ - static getRelated( p_oDD?:Ext.dd.IDragDrop, bTargetsOnly?:boolean ): Ext.dd.IDragDrop[]; - /** [Method] Utility function to determine if a given element has been registered as a drag drop item - * @param id String the element id to check - */ - static isDragDrop( id?:string ): boolean; - /** [Method] Utility function to determine if a given element has been registered as a drag drop handle for the given Drag Drop ob - * @param id String the element id to check - */ - static isHandle( id?:string ): boolean; - /** [Method] Returns true if the specified dd target is a legal target for the specifice drag obj - * @param oDD Ext.dd.IDragDrop the drag obj - * @param oTargetDD Ext.dd.IDragDrop the target - */ - static isLegalTarget( oDD?:Ext.dd.IDragDrop, oTargetDD?:Ext.dd.IDragDrop ): boolean; - /** [Method] Is drag and drop locked */ - static isLocked(): boolean; - /** [Method] My goal is to be able to transparently determine if an object is typeof DragDrop and the exact subclass of DragDrop - * @param the Object object to evaluate - */ - static isTypeOfDD( the?:any ): boolean; - /** [Method] Lock all drag and drop functionality */ - static lock(): void; - /** [Method] Refreshes the cache of the top left and bottom right points of the drag and drop objects in the specified group s - * @param groups Object an associative array of groups to refresh - */ - static refreshCache( groups?:any ): void; - /** [Method] Each DragDrop instance must be registered with the DragDropManager - * @param oDD Ext.dd.IDragDrop the DragDrop object to register - * @param sGroup String the name of the group this element belongs to - */ - static regDragDrop( oDD?:Ext.dd.IDragDrop, sGroup?:string ): void; - /** [Method] Each DragDrop handle element must be registered - * @param sDDId String the DragDrop id this element is a handle for - * @param sHandleId String the id of the element that is the drag handle - */ - static regHandle( sDDId?:string, sHandleId?:string ): void; - /** [Method] Fired when either the drag pixel threshold or the mousedown hold time threshold has been met - * @param x Number the X position of the original mousedown - * @param y Number the Y position of the original mousedown - */ - static startDrag( x?:number, y?:number ): void; - /** [Method] Utility to stop event propagation and event default if these features are turned on - * @param e Event the event as returned by this.getEvent() - */ - static stopEvent( e?:Event ): void; - /** [Method] Unlock all drag and drop functionality */ - static unlock(): void; - /** [Method] This checks to make sure an element exists and is in the DOM - * @param el HTMLElement the element to check - */ - static verifyEl( el?:HTMLElement ): boolean; - } -} -declare module Ext.dd { - export interface IDragSource extends Ext.dd.IDDProxy { - /** [Config Option] (Boolean) If true, animates the proxy element back to the position of the handle element used to trigger the drag. ... */ - animRepair?: boolean; - /** [Config Option] (String) A named drag drop group to which this object belongs. ... */ - ddGroup?: string; - /** [Config Option] (String) The CSS class returned to the drag source when drop is allowed. ... */ - dropAllowed?: string; - /** [Config Option] (String) The CSS class returned to the drag source when drop is not allowed. ... */ - dropNotAllowed?: string; - /** [Config Option] (String) The color to use when visually highlighting the drag source in the afterRepair method after a failed drop (defaults t... */ - repairHighlightColor?: string; - /** [Method] An empty function by default but provided so that you can perform a custom action after a valid drag drop has occurr - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dropped element - */ - afterDragDrop?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action when the dragged item enters the d - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - afterDragEnter?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action after the dragged item is dragged - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - afterDragOut?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action while the dragged item is over the - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - afterDragOver?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action after an invalid drop has occurred - * @param e Event The event object - * @param id String The id of the dropped element - */ - afterInvalidDrop?( e?:Event, id?:string ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action after a valid drop has occurred by - * @param target Object The target DD - * @param e Event The event object - * @param id String The id of the dropped element - */ - afterValidDrop?( target?:any, e?:Event, id?:string ): void; - /** [Method] Sets the element to the location of the mousedown or click event maintaining the cursor location relative to the loc - * @param el HTMLElement the element to move - * @param iPageX Number the X coordinate of the mousedown or drag event - * @param iPageY Number the Y coordinate of the mousedown or drag event - */ - alignElWithMouse?( el?:HTMLElement, iPageX?:number, iPageY?:number ): void; - /** [Method] An empty function by default but provided so that you can perform a custom action before the dragged item is dropped - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - beforeDragDrop?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): boolean; - /** [Method] An empty function by default but provided so that you can perform a custom action before the dragged item enters the - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - beforeDragEnter?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): boolean; - /** [Method] An empty function by default but provided so that you can perform a custom action before the dragged item is dragged - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - beforeDragOut?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): boolean; - /** [Method] An empty function by default but provided so that you can perform a custom action while the dragged item is over the - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - beforeDragOver?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): boolean; - /** [Method] An empty function by default but provided so that you can perform a custom action after an invalid drop has occurred - * @param target Ext.dd.IDragDrop The drop target - * @param e Event The event object - * @param id String The id of the dragged element - */ - beforeInvalidDrop?( target?:Ext.dd.IDragDrop, e?:Event, id?:string ): boolean; - /** [Method] Returns the data object associated with this drag source - * @param e Object - */ - getDragData?( e?:any ): any; - /** [Method] Returns the drag source s underlying Ext dd StatusProxy */ - getProxy?(): Ext.dd.IStatusProxy; - /** [Method] Hides the drag source s Ext dd StatusProxy */ - hideProxy?(): void; - /** [Method] An empty function by default but provided so that you can perform a custom action before the initial drag event begi - * @param data Object An object containing arbitrary data to be shared with drop targets - * @param e Event The event object - */ - onBeforeDrag?( data?:any, e?:Event ): boolean; - /** [Method] An empty function by default but provided so that you can perform a custom action once the initial drag event has be - * @param x Number The x position of the click on the dragged object - * @param y Number The y position of the click on the dragged object - */ - onStartDrag?( x?:number, y?:number ): void; - } -} -declare module Ext.dd { - export interface IDragTracker extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean/Number) Specify true to defer trigger start by 1000 ms. ... */ - autoStart?: any; - /** [Config Option] (Ext.util.Region/Ext.Element) A Region (Or an element from which a Region measurement will be read) which is used to constrain the result of the ge... */ - constrainTo?: any; - /** [Config Option] (String) A DomQuery selector which identifies child elements within the DragTracker's encapsulating Element which are the trac... */ - delegate?: string; - /** [Config Option] (String) A CSS class to add to the DragTracker's target element when the element (or, if the delegate option is used, when a d... */ - overCls?: string; - /** [Config Option] (Boolean) Specify false to enable default actions on onMouseDown events. ... */ - preventDefault?: boolean; - /** [Config Option] (Boolean) Specify true to stop the mousedown event from bubbling to outer listeners from the target element (or its delegates). ... */ - stopEvent?: boolean; - /** [Config Option] (Number) Number of pixels the drag target must be moved before dragging is considered to have started. ... */ - tolerance?: number; - /** [Config Option] (Boolean) Set to true to fire mouseover and mouseout events when the mouse enters or leaves the target element. ... */ - trackOver?: boolean; - /** [Property] (Boolean) Indicates whether the user is currently dragging this tracker. ... */ - active?: boolean; - /** [Property] (HTMLElement) The element being dragged. ... */ - dragTarget?: HTMLElement; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the drag target */ - getDragTarget?(): Ext.IElement; - /** [Method] Returns the X Y offset of the current mouse position from the mousedown point - * @param constrainMode String If omitted the true mouse position is returned. May be passed as point or dragTarget. See above. - */ - getOffset?( constrainMode?:string ): number[]; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Initializes the DragTracker on a given element - * @param el Ext.IElement The element - */ - initEl?( el?:Ext.IElement ): void; - initEl?( el?:HTMLElement ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onBeforeStart?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onDrag?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onEnd?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onStart?( e?:Ext.IEventObject ): void; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.dd { - export interface IDragZone extends Ext.dd.IDragSource { - /** [Config Option] (Object/Boolean) True to register this container with the Scrollmanager for auto scrolling during drag operations. ... */ - containerScroll?: any; - /** [Config Option] (String/HTMLElement/Ext.dom.Element) An element to register with the ScrollManager if containerScroll is set. ... */ - scrollEl?: any; - /** [Property] (Object) This property contains the data representing the dragged object. ... */ - dragData?: any; - /** [Method] Called when a mousedown occurs in this container - * @param e Event The mouse down event - */ - getDragData?( e?:Event ): any; - /** [Method] Called before a repair of an invalid drop to get the XY to animate to - * @param e Event The mouse up event - */ - getRepairXY?( e?:Event ): number[]; - /** [Method] Called once drag threshold has been reached to initialize the proxy element - * @param x Number The x position of the click on the dragged object - * @param y Number The y position of the click on the dragged object - */ - onInitDrag?( x?:number, y?:number ): boolean; - } -} -declare module Ext.dd { - export interface IDropTarget extends Ext.dd.IDDTarget { - /** [Config Option] (String) A named drag drop group to which this object belongs. ... */ - ddGroup?: string; - /** [Config Option] (String) The CSS class returned to the drag source when drop is allowed. ... */ - dropAllowed?: string; - /** [Config Option] (String) The CSS class returned to the drag source when drop is not allowed. ... */ - dropNotAllowed?: string; - /** [Config Option] (String) The CSS class applied to the drop target element while the drag source is over it. ... */ - overClass?: string; - /** [Property] (Boolean) private By default, all instances can be a drop target. ... */ - isTarget?: boolean; - /** [Method] The function a Ext dd DragSource calls once to notify this drop target that the dragged item has been dropped on it - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyDrop?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] The function a Ext dd DragSource calls once to notify this drop target that the source is now over the target - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyEnter?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] The function a Ext dd DragSource calls once to notify this drop target that the source has been dragged out of the ta - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyOut?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] The function a Ext dd DragSource calls continuously while it is being dragged over the target - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyOver?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - } -} -declare module Ext.dd { - export interface IDropZone extends Ext.dd.IDropTarget { - /** [Method] Returns a custom data object associated with the DOM node that is the target of the event - * @param e Event The event - */ - getTargetFromEvent?( e?:Event ): any; - /** [Method] The function a Ext dd DragSource calls once to notify this drop zone that the dragged item has been dropped on it - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyDrop?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] The function a Ext dd DragSource calls once to notify this drop zone that the source is now over the zone - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyEnter?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] The function a Ext dd DragSource calls once to notify this drop zone that the source has been dragged out of the zone - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag zone - */ - notifyOut?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] The function a Ext dd DragSource calls continuously while it is being dragged over the drop zone - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - notifyOver?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dropped on it but not on any of its registered - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onContainerDrop?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] Called while the DropZone determines that a Ext dd DragSource is being dragged over it but not over any of its regis - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onContainerOver?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dropped onto the drop node - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeDrop?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has entered a drop node that has either been registered - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeEnter?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dragged out of the drop node without dropping - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOut?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called while the DropZone determines that a Ext dd DragSource is over a drop node that has either been registered or - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOver?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - } -} -declare module Ext.dd { - export interface IRegistry extends Ext.IBase { - } - export class Registry { - /** [Method] */ - constructor(); - /** [Method] Returns the handle registered for a DOM Node by id - * @param id any The DOM node or id to look up - */ - static getHandle( id?:any ): any; - static getHandle( id?:string ): any; - static getHandle( id?:HTMLElement ): any; - /** [Method] Returns the handle that is registered for the DOM node that is the target of the event - * @param e Event The event - */ - static getHandleFromEvent( e?:Event ): any; - /** [Method] Returns a custom data object that is registered for a DOM node by id - * @param id any The DOM node or id to look up - */ - static getTarget( id?:any ): any; - static getTarget( id?:string ): any; - static getTarget( id?:HTMLElement ): any; - /** [Method] Returns a custom data object that is registered for the DOM node that is the target of the event - * @param e Event The event - */ - static getTargetFromEvent( e?:Event ): any; - /** [Method] Registers a drag drop element - * @param element String The id or DOM node to register - * @param data Object An custom data object that will be passed between the elements that are involved in drag drop operations. You can populate this object with any arbitrary properties that your own code knows how to interpret, plus there are some specific properties known to the Registry that should be populated in the data object (if applicable): - */ - static register( element?:string, data?:any ): void; - static register( element?:HTMLElement, data?:any ): void; - /** [Method] Unregister a drag drop element - * @param element String The id or DOM node to unregister - */ - static unregister( element?:string ): void; - static unregister( element?:HTMLElement ): void; - } -} -declare module Ext.dd { - export interface IScrollManager extends Ext.IBase { - } - export class ScrollManager { - /** [Method] */ - constructor(); - /** [Method] Manually trigger a cache refresh */ - static refreshCache(): void; - /** [Method] Registers new overflow element s to auto scroll - * @param el String The id of or the element to be scrolled or an array of either - */ - static register( el?:string ): void; - static register( el?:HTMLElement ): void; - static register( el?:Ext.IElement ): void; - static register( el?:string[] ): void; - static register( el?:HTMLElement[] ): void; - static register( el?:Ext.IElement[] ): void; - /** [Method] Unregisters overflow element s so they are no longer scrolled - * @param el String The id of or the element to be removed or an array of either - */ - static unregister( el?:string ): void; - static unregister( el?:HTMLElement ): void; - static unregister( el?:Ext.IElement ): void; - static unregister( el?:string[] ): void; - static unregister( el?:HTMLElement[] ): void; - static unregister( el?:Ext.IElement[] ): void; - } -} -declare module Ext.dd { - export interface IStatusProxy extends Ext.IComponent { - /** [Config Option] (String) The CSS class to apply to the status element when drop is allowed. ... */ - dropAllowed?: string; - /** [Config Option] (String) The CSS class to apply to the status element when drop is not allowed. ... */ - dropNotAllowed?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Method] Returns the ghost element */ - getGhost?(): Ext.IElement; - /** [Method] Causes the proxy to return to its position of origin via an animation - * @param xy Number[] The XY position of the element ([x, y]) - * @param callback Function The function to call after the repair is complete. - * @param scope Object The scope (this reference) in which the callback function is executed. Defaults to the browser window. - */ - repair?( xy?:number[], callback?:any, scope?:any ): void; - /** [Method] Resets the status indicator to the default dropNotAllowed value - * @param clearGhost Boolean True to also remove all content from the ghost, false to preserve it - */ - reset?( clearGhost?:boolean ): void; - /** [Method] Updates the proxy s visual element to indicate the status of whether or not drop is allowed over the current target e - * @param cssClass String The css class for the new drop status indicator image - */ - setStatus?( cssClass?:string ): void; - /** [Method] Stops the repair animation if it s currently running */ - stop?(): void; - /** [Method] Force the Layer to sync its shadow and shim positions to the element */ - sync?(): void; - /** [Method] Updates the contents of the ghost element - * @param html String The html that will replace the current innerHTML of the ghost element, or a DOM node to append as the child of the ghost element (in which case the innerHTML will be cleared first). - */ - update?( html?:string ): void; - update?( html?:HTMLElement ): void; - } -} -declare module Ext.direct { - export interface IEvent extends Ext.IBase { - /** [Method] Return the raw data for this event */ - getData?(): any; - /** [Method] Return the name for this event */ - getName?(): string; - } -} -declare module Ext.direct { - export interface IExceptionEvent extends Ext.direct.IRemotingEvent { - } -} -declare module Ext.direct { - export interface IJsonProvider extends Ext.direct.IProvider { - /** [Method] Create an event from a response object - * @param response Object Response object - */ - createEvent?( response?:any ): Ext.direct.IEvent; - /** [Method] Creates a set of events based on the XHR response - * @param response Object The XHR response - */ - createEvents?( response?:any ): Ext.direct.IEvent[]; - } -} -declare module Ext.direct { - export interface IManager extends Ext.IBase,Ext.util.IObservable { - } - export class Manager { - /** [Method] */ - constructor(); - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds an Ext Direct Provider and creates the proxy or stub methods to execute server side methods - * @param provider any Accepts any number of Provider descriptions (an instance or config object for a Provider). Each Provider description instructs Ext.Direct how to create client-side stub methods. - */ - static addProvider( provider?:any ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Retrieves a provider by the id specified when the provider is added - * @param id String The id of the provider, or the provider instance. - */ - static getProvider( id?:string ): void; - static getProvider( id?:Ext.direct.IProvider ): void; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Parses a direct function - * @param fn any The direct function - */ - static parseMethod( fn?:any ): any; - static parseMethod( fn?:string ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Removes the provider - * @param provider any The provider instance or the id of the provider. - */ - static removeProvider( provider?:any ): any; - static removeProvider( provider?:string ): Ext.direct.IProvider; - static removeProvider( provider?:Ext.direct.IProvider ): Ext.direct.IProvider; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IDirect extends Ext.IBase,Ext.util.IObservable { - } - export class Direct { - /** [Method] */ - constructor(); - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds an Ext Direct Provider and creates the proxy or stub methods to execute server side methods - * @param provider any Accepts any number of Provider descriptions (an instance or config object for a Provider). Each Provider description instructs Ext.Direct how to create client-side stub methods. - */ - static addProvider( provider?:any ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Retrieves a provider by the id specified when the provider is added - * @param id String The id of the provider, or the provider instance. - */ - static getProvider( id?:string ): void; - static getProvider( id?:Ext.direct.IProvider ): void; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Parses a direct function - * @param fn any The direct function - */ - static parseMethod( fn?:any ): any; - static parseMethod( fn?:string ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Removes the provider - * @param provider any The provider instance or the id of the provider. - */ - static removeProvider( provider?:any ): any; - static removeProvider( provider?:string ): Ext.direct.IProvider; - static removeProvider( provider?:Ext.direct.IProvider ): Ext.direct.IProvider; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.direct { - export interface IPollingProvider extends Ext.direct.IJsonProvider { - /** [Config Option] (Object) */ - baseParams?: any; - /** [Config Option] (Number) How often to poll the server-side in milliseconds. ... */ - interval?: number; - /** [Config Option] (String/Function) The url which the PollingProvider should contact with each request. ... */ - url?: any; - /** [Method] Connect to the server side and begin the polling process */ - connect?(): void; - /** [Method] Disconnect from the server side and stop the polling process */ - disconnect?(): void; - /** [Method] Returns whether or not the server side is currently connected */ - isConnected?(): void; - } -} -declare module Ext.direct { - export interface IProvider extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) The unique id of the provider (defaults to an auto-assigned id). ... */ - id?: string; - /** [Config Option] (String[]) List of Provider events that should be relayed by Ext.direct.Manager. ... */ - relayedEvents?: string[]; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Abstract method for subclasses to implement */ - connect?(): void; - /** [Method] Abstract method for subclasses to implement */ - disconnect?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Returns whether or not the server side is currently connected */ - isConnected?(): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.direct { - export interface IRemotingEvent extends Ext.direct.IEvent { - /** [Method] Get the transaction associated with this event */ - getTransaction?(): Ext.direct.ITransaction; - } -} -declare module Ext.direct { - export interface IRemotingMethod extends Ext.IBase { - /** [Method] Takes the arguments for the Direct function and splits the arguments from the scope and the callback - * @param args Array The arguments passed to the direct call - */ - getCallData?( args?:any[] ): any; - } -} -declare module Ext.direct { - export interface IRemotingProvider extends Ext.direct.IJsonProvider { - /** [Config Option] (Object) Object literal defining the server side actions and methods. ... */ - actions?: any; - /** [Config Option] (Boolean) In versions prior to 4.2, using dotted Action names was not really meaningful, because it generated flat namespace ob... */ - disableNestedActions?: boolean; - /** [Config Option] (Number/Boolean) true or false to enable or disable combining of method calls. ... */ - enableBuffer?: any; - /** [Config Option] (String) Specify which param will hold the arguments for the method. ... */ - enableUrlEncode?: string; - /** [Config Option] (Number) Number of times to re-attempt delivery on failure of a call. ... */ - maxRetries?: number; - /** [Config Option] (String/Object) Namespace for the Remoting Provider (defaults to Ext.global). ... */ - namespace?: any; - /** [Config Option] (Number) */ - timeout?: number; - /** [Config Option] (String) Required. ... */ - url?: string; - /** [Method] Abstract method for subclasses to implement */ - connect?(): void; - /** [Method] Abstract method for subclasses to implement */ - disconnect?(): void; - /** [Method] Returns whether or not the server side is currently connected */ - isConnected?(): void; - } -} -declare module Ext.direct { - export interface ITransaction extends Ext.IBase { - /** [Config Option] (Ext.direct.Provider) */ - provider?: Ext.direct.IProvider; - } -} -declare module Ext.dom { - export interface IAbstractElement extends Ext.IBase { - /** [Property] (String) The default unit to append to CSS values where a unit isn't provided. ... */ - defaultUnit?: string; - /** [Property] (HTMLElement) */ - dom?: HTMLElement; - /** [Property] (String) */ - id?: string; - /** [Method] Adds one or more CSS classes to the element - * @param className any The CSS classes to add separated by space, or an array of classes - */ - addCls?( className?:any ): any; - addCls?( className?:string ): Ext.dom.IElement; - addCls?( className?:string[] ): Ext.dom.IElement; - /** [Method] Appends the passed element s to this element Defined in override Ext dom AbstractElement_insertion - * @param el any The id or element to insert or a DomHelper config The id of the node, a DOM Node or an existing Element. - * @param returnDom Boolean True to return the raw DOM element instead of Ext.dom.AbstractElement - */ - appendChild?( el?:any, returnDom?:boolean ): Ext.dom.IAbstractElement; - /** [Method] Appends this element to the passed element Defined in override Ext dom AbstractElement_insertion - * @param el any The new parent element. The id of the node, a DOM Node or an existing Element. - */ - appendTo?( el?:any ): any; - appendTo?( el?:string ): Ext.dom.IAbstractElement; - appendTo?( el?:HTMLElement ): Ext.dom.IAbstractElement; - appendTo?( el?:Ext.dom.IAbstractElement ): Ext.dom.IAbstractElement; - /** [Method] More flexible version of setStyle for setting style properties - * @param styles any A style specification string, e.g. "width:100px", or object in the form {width:"100px"}, or a function which returns such a specification. - */ - applyStyles?( styles?:any ): Ext.dom.IElement; - /** [Method] Selects a single direct child based on the passed CSS selector the selector should not contain an id - * @param selector String The CSS selector - * @param returnDom Boolean True to return the DOM node instead of Ext.dom.Element. - */ - child?( selector?:string, returnDom?:boolean ): any; - /** [Method] Returns true if this element is an ancestor of the passed element - * @param el any The element to check - */ - contains?( el?:any ): any; - contains?( el?:HTMLElement ): boolean; - contains?( el?:string ): boolean; - /** [Method] Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child e - * @param config Object DomHelper element config object. If no tag is specified (e.g., {tag:'input'}) then a div will be automatically generated with the specified attributes. - * @param insertBefore HTMLElement a child element of this element - * @param returnDom Boolean true to return the dom node instead of creating an Element - */ - createChild?( config?:any, insertBefore?:HTMLElement, returnDom?:boolean ): Ext.dom.IAbstractElement; - /** [Method] Alias to remove */ - destroy?(): void; - /** [Method] Selects a single child at any depth below this element based on the passed CSS selector the selector should not cont - * @param selector String The CSS selector - * @param returnDom Boolean True to return the DOM node instead of Ext.dom.Element - */ - down?( selector?:string, returnDom?:boolean ): any; - /** [Method] Looks at this node and then at parent nodes for a match of the passed simple selector e g - * @param selector any The simple selector to test - * @param limit any The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement) - * @param returnEl any True to return a Ext.Element object instead of DOM node - */ - findParent?( selector?:any, limit?:any, returnEl?:any ): any; - findParent?( selector?:string, limit?:number, returnEl?:boolean ): HTMLElement; - findParent?( selector?:string, limit?:string, returnEl?:boolean ): HTMLElement; - findParent?( selector?:string, limit?:HTMLElement, returnEl?:boolean ): HTMLElement; - findParent?( selector?:string, limit?:Ext.IElement, returnEl?:boolean ): HTMLElement; - /** [Method] Looks at parent nodes for a match of the passed simple selector e g - * @param selector any The simple selector to test - * @param limit any The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement) - * @param returnEl any True to return a Ext.Element object instead of DOM node - */ - findParentNode?( selector?:any, limit?:any, returnEl?:any ): any; - findParentNode?( selector?:string, limit?:number, returnEl?:boolean ): HTMLElement; - findParentNode?( selector?:string, limit?:string, returnEl?:boolean ): HTMLElement; - findParentNode?( selector?:string, limit?:HTMLElement, returnEl?:boolean ): HTMLElement; - findParentNode?( selector?:string, limit?:Ext.IElement, returnEl?:boolean ): HTMLElement; - /** [Method] Gets the first child skipping text nodes Defined in override Ext dom AbstractElement_traversal - * @param selector String Find the next sibling that matches the passed simple selector - * @param returnDom Boolean True to return a raw dom node instead of an Ext.dom.Element - */ - first?( selector?:string, returnDom?:boolean ): any; - /** [Method] Returns the active element in the DOM */ - getActiveElement?(): HTMLElement; - /** [Method] Returns the value of an attribute from the element s underlying DOM node - * @param name String The attribute name - * @param namespace String The namespace in which to look for the attribute - */ - getAttribute?( name?:string, namespace?:string ): string; - /** [Method] Gets the width of the border s for the specified side s Defined in override Ext dom AbstractElement_style - * @param side String Can be t, l, r, b or any combination of those to add multiple values. For example, passing 'lr' would get the border left width + the border right width. - */ - getBorderWidth?( side?:string ): number; - /** [Method] Returns a child element of this element given its id - * @param id String The id of the desired child element. - * @param asDom Boolean True to return the DOM element, false to return a wrapped Element object. - */ - getById?( id?:string, asDom?:boolean ): void; - /** [Method] Returns the innerHTML of an Element or an empty string if the element s dom no longer exists */ - getHTML?(): void; - /** [Method] Returns the offset height of the element Defined in override Ext dom AbstractElement_style - * @param contentHeight Boolean true to get the height minus borders and padding - */ - getHeight?( contentHeight?:boolean ): number; - /** [Method] Returns an object with properties top left right and bottom representing the margins of this element unless sides i - * @param sides String Any combination of l, r, t, b to get the sum of those sides - */ - getMargin?( sides?:string ): any; - /** [Method] Gets the width of the padding s for the specified side s Defined in override Ext dom AbstractElement_style - * @param side String Can be t, l, r, b or any combination of those to add multiple values. For example, passing 'lr' would get the padding left + the padding right. - */ - getPadding?( side?:string ): number; - /** [Method] Returns the size of the element - * @param contentSize Boolean true to get the width/size minus borders and padding - */ - getSize?( contentSize?:boolean ): any; - /** [Method] Returns a named style property based on computed currentStyle primary and inline style if primary is not available - * @param property any The style property (or multiple property names in an array) whose value is returned. - * @param inline any if true only inline styles will be returned. - */ - getStyle?( property?:any, inline?:any ): any; - getStyle?( property?:string, inline?:boolean ): any; - getStyle?( property?:string[], inline?:boolean ): any; - /** [Method] Returns the value of the value attribute - * @param asNumber Boolean true to parse the value as a number - */ - getValue?( asNumber?:boolean ): any; - /** [Method] Returns the dimensions of the element available to lay content out in */ - getViewSize?(): any; - /** [Method] Returns the offset width of the element Defined in override Ext dom AbstractElement_style - * @param contentWidth Boolean true to get the width minus borders and padding - */ - getWidth?( contentWidth?:boolean ): number; - /** [Method] Checks if the specified CSS class exists on this element s DOM node - * @param className String The CSS class to check for - */ - hasCls?( className?:string ): boolean; - /** [Method] Hide this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - hide?( animate?:any ): Ext.dom.IElement; - /** [Method] Inserts this element after the passed element in the DOM Defined in override Ext dom AbstractElement_insertion - * @param el any The element to insert after. The id of the node, a DOM Node or an existing Element. - */ - insertAfter?( el?:any ): any; - insertAfter?( el?:string ): Ext.dom.IAbstractElement; - insertAfter?( el?:HTMLElement ): Ext.dom.IAbstractElement; - insertAfter?( el?:Ext.dom.IAbstractElement ): Ext.dom.IAbstractElement; - /** [Method] Inserts this element before the passed element in the DOM Defined in override Ext dom AbstractElement_insertion - * @param el any The element before which this element will be inserted. The id of the node, a DOM Node or an existing Element. - */ - insertBefore?( el?:any ): any; - insertBefore?( el?:string ): Ext.dom.IAbstractElement; - insertBefore?( el?:HTMLElement ): Ext.dom.IAbstractElement; - insertBefore?( el?:Ext.dom.IAbstractElement ): Ext.dom.IAbstractElement; - /** [Method] Inserts or creates an element or DomHelper config as the first child of this element Defined in override Ext dom - * @param el any The id or element to insert or a DomHelper config to create and insert - */ - insertFirst?( el?:any ): Ext.dom.IAbstractElement; - /** [Method] Inserts an html fragment into this element Defined in override Ext dom AbstractElement_insertion - * @param where String Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd. See Ext.dom.Helper.insertHtml for details. - * @param html String The HTML fragment - * @param returnEl Boolean True to return an Ext.dom.AbstractElement - */ - insertHtml?( where?:string, html?:string, returnEl?:boolean ): any; - /** [Method] Inserts or creates the passed element or DomHelper config as a sibling of this element Defined in override Ext d - * @param el any The id, element to insert or a DomHelper config to create and insert or an array of any of those. - * @param where String 'before' or 'after' - * @param returnDom Boolean True to return the raw DOM element instead of Ext.dom.AbstractElement - */ - insertSibling?( el?:any, where?:string, returnDom?:boolean ): Ext.dom.IAbstractElement; - /** [Method] Returns true if this element matches the passed simple selector e g - * @param selector String The simple selector to test - */ - is?( selector?:string ): boolean; - /** [Method] Checks if the current value of a style is equal to a given value - * @param style String property whose value is returned. - * @param value String to check against. - */ - isStyle?( style?:string, value?:string ): boolean; - /** [Method] Returns true if the value of the given property is visually transparent - * @param prop String The style property whose value is to be tested. - */ - isTransparent?( prop?:string ): boolean; - /** [Method] Gets the last child skipping text nodes Defined in override Ext dom AbstractElement_traversal - * @param selector String Find the previous sibling that matches the passed simple selector - * @param returnDom Boolean True to return a raw dom node instead of an Ext.dom.Element - */ - last?( selector?:string, returnDom?:boolean ): any; - /** [Method] Puts a mask over this element to disable user interaction - * @param msg String A message to display in the mask - * @param msgCls String A css class to apply to the msg element - */ - mask?( msg?:string, msgCls?:string ): void; - /** [Method] Gets the next sibling skipping text nodes Defined in override Ext dom AbstractElement_traversal - * @param selector String Find the next sibling that matches the passed simple selector - * @param returnDom Boolean True to return a raw dom node instead of an Ext.dom.Element - */ - next?( selector?:string, returnDom?:boolean ): any; - /** [Method] Gets the parent node for this element optionally chaining up trying to match a selector Defined in override Ext dom - * @param selector String Find a parent node that matches the passed simple selector - * @param returnDom Boolean True to return a raw dom node instead of an Ext.dom.Element - */ - parent?( selector?:string, returnDom?:boolean ): any; - /** [Method] Gets the previous sibling skipping text nodes Defined in override Ext dom AbstractElement_traversal - * @param selector String Find the previous sibling that matches the passed simple selector - * @param returnDom Boolean True to return a raw dom node instead of an Ext.dom.Element - */ - prev?( selector?:string, returnDom?:boolean ): any; - /** [Method] Selects child nodes based on the passed CSS selector the selector should not contain an id - * @param selector String The CSS selector - */ - query?( selector?:string ): HTMLElement[]; - /** [Method] Adds one or more CSS classes to this element and removes the same class es from all siblings - * @param className any The CSS class to add, or an array of classes - */ - radioCls?( className?:any ): any; - radioCls?( className?:string ): Ext.dom.IElement; - radioCls?( className?:string[] ): Ext.dom.IElement; - /** [Method] Removes this element s dom reference */ - remove?(): void; - /** [Method] Removes one or more CSS classes from the element - * @param className any The CSS classes to remove separated by space, or an array of classes - */ - removeCls?( className?:any ): any; - removeCls?( className?:string ): Ext.dom.IElement; - removeCls?( className?:string[] ): Ext.dom.IElement; - /** [Method] Forces the browser to repaint this element Defined in override Ext dom AbstractElement_style */ - repaint?(): Ext.dom.IElement; - /** [Method] Replaces the passed element with this element Defined in override Ext dom AbstractElement_insertion - * @param el any The element to replace. The id of the node, a DOM Node or an existing Element. - */ - replace?( el?:any ): any; - replace?( el?:string ): Ext.dom.IAbstractElement; - replace?( el?:HTMLElement ): Ext.dom.IAbstractElement; - replace?( el?:Ext.dom.IAbstractElement ): Ext.dom.IAbstractElement; - /** [Method] Replaces a CSS class on the element with another - * @param oldClassName String The CSS class to replace - * @param newClassName String The replacement CSS class - */ - replaceCls?( oldClassName?:string, newClassName?:string ): Ext.dom.IElement; - /** [Method] Replaces this element with the passed element Defined in override Ext dom AbstractElement_insertion - * @param el any The new element (id of the node, a DOM Node or an existing Element) or a DomHelper config of an element to create - */ - replaceWith?( el?:any ): Ext.dom.IAbstractElement; - /** [Method] Creates a Ext CompositeElement for child nodes based on the passed CSS selector the selector should not contain an id - * @param selector String The CSS selector - * @param unique Boolean True to create a unique Ext.Element for each element. Defaults to a shared flyweight object. - */ - select?( selector?:string, unique?:boolean ): Ext.ICompositeElement; - /** [Method] Serializes a DOM form into a url encoded string Defined in override Ext dom AbstractElement_static - * @param form Object The form - */ - serializeForm?( form?:any ): string; - /** [Method] Sets the passed attributes as attributes of this element a style attribute can be a string object or function - * @param o Object The object with the attributes - * @param useSet Boolean false to override the default setAttribute to use expandos. - */ - set?( o?:any, useSet?:boolean ): Ext.dom.IElement; - /** [Method] Set the innerHTML of this element - * @param html String The new HTML - */ - setHTML?( html?:string ): Ext.IElement; - /** [Method] Set the height of this Element - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels.) A String used to set the CSS height style. Animation may not be used. - */ - setHeight?( height?:any ): any; - setHeight?( height?:number ): Ext.dom.IElement; - setHeight?( height?:string ): Ext.dom.IElement; - /** [Method] Set the size of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. A size object in the format {width: widthValue, height: heightValue}. - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:number, height?:number ): Ext.dom.IElement; - setSize?( width?:string, height?:number ): Ext.dom.IElement; - setSize?( width?:number, height?:string ): Ext.dom.IElement; - setSize?( width?:string, height?:string ): Ext.dom.IElement; - /** [Method] Wrapper for setting style properties also takes single object parameter of multiple styles - * @param property any The style property to be set, or an object of multiple styles. - * @param value String The value to apply to the given property, or null if an object was passed. - */ - setStyle?( property?:any, value?:string ): Ext.dom.IElement; - /** [Method] Use this to change the visibility mode between VISIBILITY DISPLAY OFFSETS or ASCLASS - * @param mode Object - */ - setVisibilityMode?( mode?:any ): Ext.dom.IAbstractElement; - /** [Method] Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Set the width of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. - */ - setWidth?( width?:any ): any; - setWidth?( width?:number ): Ext.dom.IElement; - setWidth?( width?:string ): Ext.dom.IElement; - /** [Method] Show this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - show?( animate?:any ): Ext.dom.IElement; - /** [Method] Toggles the specified CSS class on this element removes it if it already exists otherwise adds it - * @param className String The CSS class to toggle - */ - toggleCls?( className?:string ): Ext.dom.IElement; - /** [Method] Removes a previously applied mask */ - unmask?(): void; - /** [Method] Walks up the DOM looking for a parent node that matches the passed simple selector e g - * @param selector any The simple selector to test - * @param limit any The max depth to search as a number or an element which causes the upward traversal to stop and is not considered for inclusion as the result. (defaults to 50 || document.documentElement) - * @param returnDom any True to return the DOM node instead of Ext.dom.Element - */ - up?( selector?:any, limit?:any, returnDom?:any ): any; - up?( selector?:string, limit?:number, returnDom?:boolean ): Ext.IElement; - up?( selector?:string, limit?:string, returnDom?:boolean ): Ext.IElement; - up?( selector?:string, limit?:HTMLElement, returnDom?:boolean ): Ext.IElement; - up?( selector?:string, limit?:Ext.IElement, returnDom?:boolean ): Ext.IElement; - /** [Method] Update the innerHTML of this element - * @param html String The new HTML - */ - update?( html?:string ): Ext.dom.IElement; - /** [Method] Creates and wraps this element with another element Defined in override Ext dom AbstractElement_insertion - * @param config Object DomHelper element config object for the wrapper element or null for an empty div - * @param returnDom Boolean True to return the raw DOM element instead of Ext.dom.AbstractElement - * @param selector String A DomQuery selector to select a descendant node within the created element to use as the wrapping element. - */ - wrap?( config?:any, returnDom?:boolean, selector?:string ): any; - } -} -declare module Ext.dom { - export interface IAbstractHelper extends Ext.IBase { - /** [Method] Creates new DOM element s and appends them to el - * @param el any The context element - * @param o any The DOM object spec (and children) or raw HTML blob - * @param returnElement any true to return a Ext.Element - */ - append?( el?:any, o?:any, returnElement?:any ): any; - append?( el?:string, o?:any, returnElement?:boolean ): any; - append?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - append?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - /** [Method] Applies a style specification to an element - * @param el String The element to apply styles to - * @param styles any A style specification string e.g. 'width:100px', or object in the form {width:'100px'}, or a function which returns such a specification. - */ - applyStyles?( el?:string, styles?:any ): void; - applyStyles?( el?:HTMLElement, styles?:any ): void; - /** [Method] Converts the styles from the given object to text - * @param styles Object The object describing the styles. - * @param buffer String[] The output buffer. - */ - generateStyles?( styles?:any, buffer?:string[] ): any; - /** [Method] Creates new DOM element s and inserts them after el - * @param el any The context element - * @param o any The DOM object spec (and children) - * @param returnElement any true to return a Ext.Element - */ - insertAfter?( el?:any, o?:any, returnElement?:any ): any; - insertAfter?( el?:string, o?:any, returnElement?:boolean ): any; - insertAfter?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - insertAfter?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - /** [Method] Creates new DOM element s and inserts them before el - * @param el any The context element - * @param o any The DOM object spec (and children) or raw HTML blob - * @param returnElement any true to return a Ext.Element - */ - insertBefore?( el?:any, o?:any, returnElement?:any ): any; - insertBefore?( el?:string, o?:any, returnElement?:boolean ): any; - insertBefore?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - insertBefore?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - /** [Method] Creates new DOM element s and inserts them as the first child of el - * @param el any The context element - * @param o any The DOM object spec (and children) or raw HTML blob - * @param returnElement any true to return a Ext.Element - */ - insertFirst?( el?:any, o?:any, returnElement?:any ): any; - insertFirst?( el?:string, o?:any, returnElement?:boolean ): any; - insertFirst?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - insertFirst?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - /** [Method] Inserts an HTML fragment into the DOM - * @param where any Where to insert the html in relation to el - beforeBegin, afterBegin, beforeEnd, afterEnd. For example take the following HTML: <div>Contents</div> Using different where values inserts element to the following places: beforeBegin: <HERE><div>Contents</div> afterBegin: <div><HERE>Contents</div> beforeEnd: <div>Contents<HERE></div> afterEnd: <div>Contents</div><HERE> - * @param el any The context element - * @param html any The HTML fragment - */ - insertHtml?( where?:any, el?:any, html?:any ): any; - insertHtml?( where?:string, el?:HTMLElement, html?:string ): HTMLElement; - insertHtml?( where?:string, el?:any, html?:string ): HTMLElement; - /** [Method] Returns the markup for the passed Element s config - * @param spec Object The DOM object spec (and children) - */ - markup?( spec?:any ): string; - /** [Method] Creates new DOM element s and overwrites the contents of el with them - * @param el any The context element - * @param o any The DOM object spec (and children) or raw HTML blob - * @param returnElement any true to return a Ext.Element - */ - overwrite?( el?:any, o?:any, returnElement?:any ): any; - overwrite?( el?:string, o?:any, returnElement?:boolean ): any; - overwrite?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - overwrite?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - } -} -declare module Ext.dom { - export interface IAbstractQuery extends Ext.IBase { - /** [Method] Returns true if the passed element s match the passed simple selector e g - * @param el any An element id, element or array of elements - * @param selector any The simple selector to test - */ - is?( el?:any, selector?:any ): any; - is?( el?:string, selector?:string ): boolean; - is?( el?:HTMLElement, selector?:string ): boolean; - is?( el?:any[], selector?:string ): boolean; - /** [Method] Selects a group of elements - * @param selector any The selector/xpath query (can be a comma separated list of selectors) - * @param root any The start of the query (defaults to document). - */ - select?( selector?:any, root?:any ): any; - select?( selector?:string, root?:HTMLElement ): HTMLElement[]; - select?( selector?:string, root?:string ): HTMLElement[]; - /** [Method] Selects a single element - * @param selector any The selector/xpath query - * @param root any The start of the query (defaults to document). - */ - selectNode?( selector?:any, root?:any ): any; - selectNode?( selector?:string, root?:HTMLElement ): HTMLElement; - selectNode?( selector?:string, root?:string ): HTMLElement; - } -} -declare module Ext.dom { - export interface ICompositeElement extends Ext.dom.ICompositeElementLite { - } -} -declare module Ext { - export interface ICompositeElement extends Ext.dom.ICompositeElementLite { - } -} -declare module Ext.dom { - export interface ICompositeElementLite extends Ext.IBase { - /** [Property] (HTMLElement[]) The Array of DOM elements which this CompositeElement encapsulates. ... */ - elements?: HTMLElement[]; - /** [Property] (Boolean) true in this class to identify an object as an instantiated CompositeElement, or subclass thereof. ... */ - isComposite?: boolean; - /** [Method] Adds elements to this Composite object - * @param els any Either an Array of DOM elements to add, or another Composite object who's elements should be added. - */ - add?( els?:any ): any; - add?( els?:HTMLElement[] ): Ext.dom.ICompositeElement; - add?( els?:Ext.dom.ICompositeElement ): Ext.dom.ICompositeElement; - /** [Method] Removes all elements from this Composite - * @param removeDom Boolean True to also remove the elements from the document. - */ - clear?( removeDom?:boolean ): void; - /** [Method] Returns true if this composite contains the passed element - * @param el any The id of an element, or an Ext.Element, or an HtmlElement to find within the composite collection. - */ - contains?( el?:any ): any; - contains?( el?:string ): boolean; - contains?( el?:HTMLElement ): boolean; - contains?( el?:Ext.IElement ): boolean; - contains?( el?:number ): boolean; - /** [Method] Calls the passed function for each element in this composite - * @param fn Function The function to call. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Element. - */ - each?( fn?:any, scope?:any ): Ext.dom.ICompositeElement; - /** [Method] Clears this Composite and adds the elements passed - * @param els any Either an array of DOM elements, or another Composite from which to fill this Composite. - */ - fill?( els?:any ): any; - fill?( els?:HTMLElement[] ): Ext.dom.ICompositeElement; - fill?( els?:Ext.dom.ICompositeElement ): Ext.dom.ICompositeElement; - /** [Method] Filters this composite to only elements that match the passed selector - * @param selector any A string CSS selector or a comparison function. The comparison function will be called with the following arguments: - */ - filter?( selector?:any ): any; - filter?( selector?:string ): Ext.dom.ICompositeElement; - /** [Method] Returns the first Element */ - first?(): Ext.dom.IElement; - /** [Method] Returns the number of elements in this Composite */ - getCount?(): number; - /** [Method] Find the index of the passed element within the composite collection - * @param el any The id of an element, or an Ext.dom.Element, or an HtmlElement to find within the composite collection. - */ - indexOf?( el?:any ): any; - indexOf?( el?:string ): number; - indexOf?( el?:HTMLElement ): number; - indexOf?( el?:Ext.IElement ): number; - indexOf?( el?:number ): number; - /** [Method] Returns a flyweight Element of the dom element object at the specified index - * @param index Number - */ - item?( index?:number ): Ext.dom.IElement; - /** [Method] Returns the last Element */ - last?(): Ext.dom.IElement; - /** [Method] Removes the specified element s - * @param el any The id of an element, the Element itself, the index of the element in this composite or an array of any of those. - * @param removeDom any True to also remove the element from the document. - */ - removeElement?( el?:any, removeDom?:any ): any; - removeElement?( el?:string, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:HTMLElement, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:Ext.IElement, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:number, removeDom?:boolean ): Ext.dom.ICompositeElement; - /** [Method] Replaces the specified element with the passed element - * @param el any The id of an element, the Element itself, the index of the element in this composite to replace. - * @param replacement any The id of an element or the Element itself. - * @param domReplace any True to remove and replace the element in the document too. - */ - replaceElement?( el?:any, replacement?:any, domReplace?:any ): any; - replaceElement?( el?:string, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:HTMLElement, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:Ext.IElement, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:number, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:string, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:HTMLElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:Ext.IElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:number, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - /** [Method] Gets a range nodes - * @param start Number The index of the first node in the range - * @param end Number The index of the last node in the range - */ - slice?( start?:number, end?:number ): HTMLElement[]; - } -} -declare module Ext { - export interface ICompositeElementLite extends Ext.IBase { - /** [Property] (HTMLElement[]) The Array of DOM elements which this CompositeElement encapsulates. ... */ - elements?: HTMLElement[]; - /** [Property] (Boolean) true in this class to identify an object as an instantiated CompositeElement, or subclass thereof. ... */ - isComposite?: boolean; - /** [Method] Adds elements to this Composite object - * @param els any Either an Array of DOM elements to add, or another Composite object who's elements should be added. - */ - add?( els?:any ): any; - add?( els?:HTMLElement[] ): Ext.dom.ICompositeElement; - add?( els?:Ext.dom.ICompositeElement ): Ext.dom.ICompositeElement; - /** [Method] Removes all elements from this Composite - * @param removeDom Boolean True to also remove the elements from the document. - */ - clear?( removeDom?:boolean ): void; - /** [Method] Returns true if this composite contains the passed element - * @param el any The id of an element, or an Ext.Element, or an HtmlElement to find within the composite collection. - */ - contains?( el?:any ): any; - contains?( el?:string ): boolean; - contains?( el?:HTMLElement ): boolean; - contains?( el?:Ext.IElement ): boolean; - contains?( el?:number ): boolean; - /** [Method] Calls the passed function for each element in this composite - * @param fn Function The function to call. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Element. - */ - each?( fn?:any, scope?:any ): Ext.dom.ICompositeElement; - /** [Method] Clears this Composite and adds the elements passed - * @param els any Either an array of DOM elements, or another Composite from which to fill this Composite. - */ - fill?( els?:any ): any; - fill?( els?:HTMLElement[] ): Ext.dom.ICompositeElement; - fill?( els?:Ext.dom.ICompositeElement ): Ext.dom.ICompositeElement; - /** [Method] Filters this composite to only elements that match the passed selector - * @param selector any A string CSS selector or a comparison function. The comparison function will be called with the following arguments: - */ - filter?( selector?:any ): any; - filter?( selector?:string ): Ext.dom.ICompositeElement; - /** [Method] Returns the first Element */ - first?(): Ext.dom.IElement; - /** [Method] Returns the number of elements in this Composite */ - getCount?(): number; - /** [Method] Find the index of the passed element within the composite collection - * @param el any The id of an element, or an Ext.dom.Element, or an HtmlElement to find within the composite collection. - */ - indexOf?( el?:any ): any; - indexOf?( el?:string ): number; - indexOf?( el?:HTMLElement ): number; - indexOf?( el?:Ext.IElement ): number; - indexOf?( el?:number ): number; - /** [Method] Returns a flyweight Element of the dom element object at the specified index - * @param index Number - */ - item?( index?:number ): Ext.dom.IElement; - /** [Method] Returns the last Element */ - last?(): Ext.dom.IElement; - /** [Method] Removes the specified element s - * @param el any The id of an element, the Element itself, the index of the element in this composite or an array of any of those. - * @param removeDom any True to also remove the element from the document. - */ - removeElement?( el?:any, removeDom?:any ): any; - removeElement?( el?:string, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:HTMLElement, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:Ext.IElement, removeDom?:boolean ): Ext.dom.ICompositeElement; - removeElement?( el?:number, removeDom?:boolean ): Ext.dom.ICompositeElement; - /** [Method] Replaces the specified element with the passed element - * @param el any The id of an element, the Element itself, the index of the element in this composite to replace. - * @param replacement any The id of an element or the Element itself. - * @param domReplace any True to remove and replace the element in the document too. - */ - replaceElement?( el?:any, replacement?:any, domReplace?:any ): any; - replaceElement?( el?:string, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:HTMLElement, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:Ext.IElement, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:number, replacement?:string, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:string, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:HTMLElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:Ext.IElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - replaceElement?( el?:number, replacement?:Ext.IElement, domReplace?:boolean ): Ext.dom.ICompositeElement; - /** [Method] Gets a range nodes - * @param start Number The index of the first node in the range - * @param end Number The index of the last node in the range - */ - slice?( start?:number, end?:number ): HTMLElement[]; - } -} -declare module Ext.dom.element { - export interface IFly extends Ext.dom.IElement { - /** [Property] (Boolean) This is true to identify Element flyweights ... */ - isFly?: boolean; - } -} -declare module Ext.dom.abstractelement { - export interface IFly extends Ext.dom.IElement { - /** [Property] (Boolean) This is true to identify Element flyweights ... */ - isFly?: boolean; - } -} -declare module Ext.dom { - export interface IElement extends Ext.dom.IAbstractElement { - /** [Property] (Boolean) True to automatically adjust width and height settings for box-model issues. ... */ - autoBoxAdjust?: boolean; - /** [Property] (String) The element's default display mode. ... */ - originalDisplay?: string; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is down and then up on this element a click effe - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnClick?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when this element has the focus Defined in override Ext dom Ele - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnFocus?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is over this element Defined in override Ext dom - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnOver?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Convenience method for constructing a KeyMap - * @param key any Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options: - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the specified function is executed. Defaults to this Element. - */ - addKeyListener?( key?:any, fn?:any, scope?:any ): Ext.util.IKeyMap; - /** [Method] Creates a KeyMap for this element - * @param config Object The KeyMap config. See Ext.util.KeyMap for more details - */ - addKeyMap?( config?:any ): Ext.util.IKeyMap; - /** [Method] Shorthand for on - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - addListener?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Performs custom animation on this Element - * @param config Object Configuration for Ext.fx.Anim. Note that the to config is required. - */ - animate?( config?:any ): Ext.dom.IElement; - /** [Method] Tries to blur the element */ - blur?(): Ext.dom.IElement; - /** [Method] Wraps the specified element with a special 9 element markup CSS block that renders by default as a gray container wit - * @param class String A base CSS class to apply to the containing wrapper element. Note that there are a number of CSS rules that are dependent on this name to make the overall effect work, so if you supply an alternate base class, make sure you also supply all of the necessary rules. - */ - boxWrap?( clazz?:string ): Ext.dom.IElement; - /** [Method] When an element is moved around in the DOM or is hidden using display none it loses layout and therefore all scrol */ - cacheScrollValues?(): any; - /** [Method] Centers the Element in either the viewport or another Element - * @param centerIn String element in which to center the element. - */ - center?( centerIn?:string ): void; - center?( centerIn?:HTMLElement ): void; - center?( centerIn?:Ext.dom.IElement ): void; - /** [Method] Removes Empty or whitespace filled text nodes - * @param forceReclean Boolean By default the element keeps track if it has been cleaned already so you can call this over and over. However, if you update the element and need to force a reclean, you can pass true. - */ - clean?( forceReclean?:boolean ): void; - /** [Method] Alias for removeAllListeners */ - clearListeners?(): Ext.dom.IElement; - /** [Method] Clears any opacity settings from this element */ - clearOpacity?(): Ext.dom.IElement; - /** [Method] Clears positioning back to the default when the document was loaded - * @param value String The value to use for the left, right, top, bottom. You could use 'auto'. - */ - clearPositioning?( value?:string ): Ext.dom.IElement; - /** [Method] Store the current overflow setting and clip overflow on the element use unclip to remove Defined in override Ext d */ - clip?(): Ext.dom.IElement; - /** [Method] Creates a proxy element of this element - * @param config any The class name of the proxy element or a DomHelper config object - * @param renderTo any The element or element id to render the proxy to. Defaults to: document.body. - * @param matchBox any True to align and size the proxy to this element now. - */ - createProxy?( config?:any, renderTo?:any, matchBox?:any ): any; - createProxy?( config?:any, renderTo?:string, matchBox?:boolean ): Ext.dom.IElement; - createProxy?( config?:any, renderTo?:HTMLElement, matchBox?:boolean ): Ext.dom.IElement; - /** [Method] Creates an iframe shim for this element to keep selects and other windowed objects from showing through */ - createShim?(): Ext.dom.IElement; - /** [Method] Convenience method for setVisibilityMode Element DISPLAY - * @param display String What to set display to when visible - */ - enableDisplayMode?( display?:string ): Ext.dom.IElement; - /** [Method] Fade an element in from transparent to opaque - * @param options Object Object literal with any of the Fx config options - */ - fadeIn?( options?:any ): Ext.IElement; - /** [Method] Fade an element out from opaque to transparent - * @param options Object Object literal with any of the Fx config options - */ - fadeOut?( options?:any ): Ext.IElement; - /** [Method] Tries to focus the element - * @param defer Number Milliseconds to defer the focus - */ - focus?( defer?:number ): Ext.dom.IElement; - /** [Method] Alias for isFocusable - * @param asFocusEl Object - */ - focusable?( asFocusEl?:any ): boolean; - /** [Method] Shows a ripple of exploding attenuating borders to draw attention to an Element - * @param color String The hex color value for the border. - * @param count Number The number of ripples to display. - * @param options Object Object literal with any of the Fx config options - */ - frame?( color?:string, count?:number, options?:any ): Ext.dom.IElement; - /** [Method] Returns the value of a namespaced attribute from the element s underlying DOM node - * @param namespace String The namespace in which to look for the attribute - * @param name String The attribute name - */ - getAttributeNS?( namespace?:string, name?:string ): string; - /** [Method] Return the CSS color for the specified CSS attribute - * @param attr String The css attribute - * @param defaultValue String The default value to use when a valid color isn't found - * @param prefix String defaults to #. Use an empty string when working with color anims. - */ - getColor?( attr?:string, defaultValue?:string, prefix?:string ): void; - /** [Method] Returns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders when */ - getComputedHeight?(): number; - /** [Method] Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders when ne */ - getComputedWidth?(): number; - /** [Method] Returns the sum width of the padding and borders for the passed sides - * @param sides String - */ - getFrameWidth?( sides?:string ): number; - /** [Method] Gets this element s ElementLoader */ - getLoader?(): Ext.IElementLoader; - /** [Method] Gets the local CSS X position for the element Defined in override Ext dom Element_position */ - getLocalX?(): number; - /** [Method] Gets the local CSS X and Y position for the element Defined in override Ext dom Element_position */ - getLocalXY?(): any[]; - /** [Method] Gets the local CSS Y position for the element Defined in override Ext dom Element_position */ - getLocalY?(): number; - /** [Method] Gets an object with all CSS positioning properties - * @param autoPx Boolean true to return pixel values for "auto" styles. - */ - getPositioning?( autoPx?:boolean ): any; - /** [Method] Returns the current scroll position of the element */ - getScroll?(): any; - /** [Method] Gets the left scroll position Defined in override Ext dom Element_scroll */ - getScrollLeft?(): number; - /** [Method] Gets the top scroll position Defined in override Ext dom Element_scroll */ - getScrollTop?(): number; - /** [Method] Returns the dimensions of the element available to lay content out in */ - getStyleSize?(): any; - /** [Method] Returns the width in pixels of the passed text or the width of the text in this Element - * @param text String The text to measure. Defaults to the innerHTML of the element. - * @param min Number The minumum value to return. - * @param max Number The maximum value to return. - */ - getTextWidth?( text?:string, min?:number, max?:number ): number; - /** [Method] Gets element X position in page coordinates Defined in override Ext dom Element_position */ - getX?(): number; - /** [Method] Gets element X and Y positions in page coordinates Defined in override Ext dom Element_position */ - getXY?(): any[]; - /** [Method] Gets element Y position in page coordinates Defined in override Ext dom Element_position */ - getY?(): number; - /** [Method] Slides the element while fading it out of view - * @param anchor String One of the valid Fx anchor positions (defaults to bottom: 'b') - * @param options Object Object literal with any of the Fx config options - */ - ghost?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Hide this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - hide?( animate?:any ): Ext.dom.IElement; - /** [Method] Highlights the Element by setting a color applies to the background color by default but can be changed using the - * @param color String The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c') - * @param options Object Object literal with any of the Fx config options - */ - highlight?( color?:string, options?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element - * @param overFn Function The function to call when the mouse enters the Element. - * @param outFn Function The function to call when the mouse leaves the Element. - * @param scope Object The scope (this reference) in which the functions are executed. Defaults to the Element's DOM element. - * @param options Object Options for the listener. See the options parameter. - */ - hover?( overFn?:any, outFn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes a Ext dd DD drag drop object for this element - * @param group String The group the DD object is member of - * @param config Object The DD config object - * @param overrides Object An object containing methods to override/implement on the DD object - */ - initDD?( group?:string, config?:any, overrides?:any ): Ext.dd.IDD; - /** [Method] Initializes a Ext dd DDProxy object for this element - * @param group String The group the DDProxy object is member of - * @param config Object The DDProxy config object - * @param overrides Object An object containing methods to override/implement on the DDProxy object - */ - initDDProxy?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDProxy; - /** [Method] Initializes a Ext dd DDTarget object for this element - * @param group String The group the DDTarget object is member of - * @param config Object The DDTarget config object - * @param overrides Object An object containing methods to override/implement on the DDTarget object - */ - initDDTarget?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDTarget; - /** [Method] Tests various css rules browsers to determine if this element uses a border box */ - isBorderBox?(): boolean; - /** [Method] Returns true if display is not none */ - isDisplayed?(): boolean; - /** [Method] Checks whether this element can be focused - * @param asFocusEl Object - */ - isFocusable?( asFocusEl?:any ): boolean; - /** [Method] Returns true if this element is masked */ - isMasked?(): boolean; - /** [Method] Returns true if this element is scrollable */ - isScrollable?(): boolean; - /** [Method] Checks whether the element is currently visible using both visibility and display properties - * @param deep Boolean True to walk the dom and see if parent elements are hidden. If false, the function only checks the visibility of the element itself and it may return true even though a parent is not visible. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Direct access to the Ext ElementLoader Ext ElementLoader load method - * @param options Object - */ - load?( options?:any ): Ext.dom.IElement; - /** [Method] Puts a mask over this element to disable user interaction - * @param msg String A message to display in the mask - * @param msgCls String A css class to apply to the msg element - */ - mask?( msg?:string, msgCls?:string ): Ext.dom.IElement; - /** [Method] Monitors this Element for the mouse leaving - * @param delay Number The delay in milliseconds to wait for possible mouse re-entry before calling the handler function. - * @param handler Function The function to call if the mouse remains outside of this Element for the specified time. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to this Element. - */ - monitorMouseLeave?( delay?:number, handler?:any, scope?:any ): any; - /** [Method] Returns true if this element needs an explicit tabIndex to make it focusable */ - needsTabIndex?(): void; - /** [Method] Appends an event handler to this element - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - on?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes positioning on this element - * @param pos String Positioning to use "relative", "absolute" or "fixed" - * @param zIndex Number The zIndex to apply - * @param x Number Set the page X position - * @param y Number Set the page Y position - */ - position?( pos?:string, zIndex?:number, x?:number, y?:number ): void; - /** [Method] Fades the element out while slowly expanding it in all directions - * @param options Object Object literal with any of the Fx config options - */ - puff?( options?:any ): Ext.dom.IElement; - /** [Method] Recursively removes all previous added listeners from this element and its children */ - purgeAllListeners?(): Ext.dom.IElement; - /** [Method] Create an event handler on this element such that when the event fires and is handled by this element it will be rel - * @param eventName String The type of event to relay - * @param observable Object Any object that extends Ext.util.Observable that will provide the context for firing the relayed event - */ - relayEvent?( eventName?:string, observable?:any ): void; - /** [Method] Removes all previous added listeners from this element */ - removeAllListeners?(): Ext.dom.IElement; - /** [Method] Shorthand for un - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified direction - * @param direction String Possible values are: "l" (or "left") "r" (or "right") "t" (or "top", or "up") "b" (or "bottom", or "down") - * @param distance Number How far to scroll the element in pixels - * @param animate any true for the default animation or a standard Element animation config object - */ - scroll?( direction?:string, distance?:number, animate?:any ): boolean; - /** [Method] Scrolls this element by the passed delta values optionally animating - * @param deltaX any Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties. - * @param deltaY any Either the y delta, or an animate flag or config object. - * @param animate any Animate flag/config object if the delta values were passed separately. - */ - scrollBy?( deltaX?:any, deltaY?:any, animate?:any ): Ext.IElement; - /** [Method] Scrolls this element into view within the passed container - * @param container any The container element to scroll. Should be a string (id), dom node, or Ext.Element. - * @param hscroll any False to disable horizontal scroll. - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollIntoView?( container?:any, hscroll?:any, animate?:any ): any; - scrollIntoView?( container?:string, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:HTMLElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:Ext.IElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified scroll point - * @param side String Either "left" for scrollLeft values or "top" for scrollTop values. - * @param value Number The new scroll value - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollTo?( side?:string, value?:number, animate?:any ): Ext.IElement; - /** [Method] Enable text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - selectable?(): Ext.IElement; - /** [Method] Sets the CSS display property - * @param value any Boolean value to display the element using its default display, or a string to set the display directly. - */ - setDisplayed?( value?:any ): any; - setDisplayed?( value?:boolean ): Ext.dom.IElement; - setDisplayed?( value?:string ): Ext.dom.IElement; - /** [Method] Set the opacity of the element Defined in override Ext dom Element_style - * @param opacity Number The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc - * @param animate any a standard Element animation config object or true for the default animation ({duration: 350, easing: 'easeIn'}) - */ - setOpacity?( opacity?:number, animate?:any ): Ext.dom.IElement; - /** [Method] Set positioning with an object returned by getPositioning - * @param posCfg Object - */ - setPositioning?( posCfg?:any ): Ext.dom.IElement; - /** [Method] Sets the left scroll position Defined in override Ext dom Element_scroll - * @param left Number The left scroll position - */ - setScrollLeft?( left?:number ): Ext.dom.IElement; - /** [Method] Sets the top scroll position Defined in override Ext dom Element_scroll - * @param top Number The top scroll position - */ - setScrollTop?( top?:number ): Ext.dom.IElement; - /** [Method] Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Show this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - show?( animate?:any ): Ext.dom.IElement; - /** [Method] Slides the element into view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideIn?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Slides the element out of view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideOut?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Stops the specified event s from bubbling and optionally prevents the default action - * @param eventName any an event / array of events to stop from bubbling - * @param preventDefault any true to prevent the default action too - */ - swallowEvent?( eventName?:any, preventDefault?:any ): any; - swallowEvent?( eventName?:string, preventDefault?:boolean ): Ext.dom.IElement; - swallowEvent?( eventName?:string[], preventDefault?:boolean ): Ext.dom.IElement; - /** [Method] Blinks the element as if it was clicked and then collapses on its center similar to switching off a television - * @param options Object Object literal with any of the Fx config options - */ - switchOff?( options?:any ): Ext.dom.IElement; - /** [Method] Toggles the element s visibility or display depending on visibility mode - * @param animate any True for the default animation, or a standard Element animation config object - */ - toggle?( animate?:any ): Ext.dom.IElement; - /** [Method] Removes an event handler from this element - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - un?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Return clipping overflow to original clipping before clip was called Defined in override Ext dom Element_style */ - unclip?(): Ext.dom.IElement; - /** [Method] Hides a previously applied mask */ - unmask?(): void; - /** [Method] Disables text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - unselectable?(): Ext.dom.IElement; - /** [Method] Updates the innerHTML of this element optionally searching for and processing scripts - * @param html String The new HTML - * @param loadScripts Boolean True to look for and process scripts (defaults to false) - * @param callback Function For async script loading you can be notified when the update completes - */ - update?( html?:string, loadScripts?:boolean, callback?:any ): Ext.dom.IElement; - } -} -declare module Ext { - export interface IElement extends Ext.dom.IAbstractElement { - /** [Property] (Boolean) True to automatically adjust width and height settings for box-model issues. ... */ - autoBoxAdjust?: boolean; - /** [Property] (String) The element's default display mode. ... */ - originalDisplay?: string; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is down and then up on this element a click effe - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnClick?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when this element has the focus Defined in override Ext dom Ele - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnFocus?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is over this element Defined in override Ext dom - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnOver?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Convenience method for constructing a KeyMap - * @param key any Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options: - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the specified function is executed. Defaults to this Element. - */ - addKeyListener?( key?:any, fn?:any, scope?:any ): Ext.util.IKeyMap; - /** [Method] Creates a KeyMap for this element - * @param config Object The KeyMap config. See Ext.util.KeyMap for more details - */ - addKeyMap?( config?:any ): Ext.util.IKeyMap; - /** [Method] Shorthand for on - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - addListener?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Performs custom animation on this Element - * @param config Object Configuration for Ext.fx.Anim. Note that the to config is required. - */ - animate?( config?:any ): Ext.dom.IElement; - /** [Method] Tries to blur the element */ - blur?(): Ext.dom.IElement; - /** [Method] Wraps the specified element with a special 9 element markup CSS block that renders by default as a gray container wit - * @param class String A base CSS class to apply to the containing wrapper element. Note that there are a number of CSS rules that are dependent on this name to make the overall effect work, so if you supply an alternate base class, make sure you also supply all of the necessary rules. - */ - boxWrap?( clazz?:string ): Ext.dom.IElement; - /** [Method] When an element is moved around in the DOM or is hidden using display none it loses layout and therefore all scrol */ - cacheScrollValues?(): any; - /** [Method] Centers the Element in either the viewport or another Element - * @param centerIn String element in which to center the element. - */ - center?( centerIn?:string ): void; - center?( centerIn?:HTMLElement ): void; - center?( centerIn?:Ext.dom.IElement ): void; - /** [Method] Removes Empty or whitespace filled text nodes - * @param forceReclean Boolean By default the element keeps track if it has been cleaned already so you can call this over and over. However, if you update the element and need to force a reclean, you can pass true. - */ - clean?( forceReclean?:boolean ): void; - /** [Method] Alias for removeAllListeners */ - clearListeners?(): Ext.dom.IElement; - /** [Method] Clears any opacity settings from this element */ - clearOpacity?(): Ext.dom.IElement; - /** [Method] Clears positioning back to the default when the document was loaded - * @param value String The value to use for the left, right, top, bottom. You could use 'auto'. - */ - clearPositioning?( value?:string ): Ext.dom.IElement; - /** [Method] Store the current overflow setting and clip overflow on the element use unclip to remove Defined in override Ext d */ - clip?(): Ext.dom.IElement; - /** [Method] Creates a proxy element of this element - * @param config any The class name of the proxy element or a DomHelper config object - * @param renderTo any The element or element id to render the proxy to. Defaults to: document.body. - * @param matchBox any True to align and size the proxy to this element now. - */ - createProxy?( config?:any, renderTo?:any, matchBox?:any ): any; - createProxy?( config?:any, renderTo?:string, matchBox?:boolean ): Ext.dom.IElement; - createProxy?( config?:any, renderTo?:HTMLElement, matchBox?:boolean ): Ext.dom.IElement; - /** [Method] Creates an iframe shim for this element to keep selects and other windowed objects from showing through */ - createShim?(): Ext.dom.IElement; - /** [Method] Convenience method for setVisibilityMode Element DISPLAY - * @param display String What to set display to when visible - */ - enableDisplayMode?( display?:string ): Ext.dom.IElement; - /** [Method] Fade an element in from transparent to opaque - * @param options Object Object literal with any of the Fx config options - */ - fadeIn?( options?:any ): Ext.IElement; - /** [Method] Fade an element out from opaque to transparent - * @param options Object Object literal with any of the Fx config options - */ - fadeOut?( options?:any ): Ext.IElement; - /** [Method] Tries to focus the element - * @param defer Number Milliseconds to defer the focus - */ - focus?( defer?:number ): Ext.dom.IElement; - /** [Method] Alias for isFocusable - * @param asFocusEl Object - */ - focusable?( asFocusEl?:any ): boolean; - /** [Method] Shows a ripple of exploding attenuating borders to draw attention to an Element - * @param color String The hex color value for the border. - * @param count Number The number of ripples to display. - * @param options Object Object literal with any of the Fx config options - */ - frame?( color?:string, count?:number, options?:any ): Ext.dom.IElement; - /** [Method] Returns the value of a namespaced attribute from the element s underlying DOM node - * @param namespace String The namespace in which to look for the attribute - * @param name String The attribute name - */ - getAttributeNS?( namespace?:string, name?:string ): string; - /** [Method] Return the CSS color for the specified CSS attribute - * @param attr String The css attribute - * @param defaultValue String The default value to use when a valid color isn't found - * @param prefix String defaults to #. Use an empty string when working with color anims. - */ - getColor?( attr?:string, defaultValue?:string, prefix?:string ): void; - /** [Method] Returns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders when */ - getComputedHeight?(): number; - /** [Method] Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders when ne */ - getComputedWidth?(): number; - /** [Method] Returns the sum width of the padding and borders for the passed sides - * @param sides String - */ - getFrameWidth?( sides?:string ): number; - /** [Method] Gets this element s ElementLoader */ - getLoader?(): Ext.IElementLoader; - /** [Method] Gets the local CSS X position for the element Defined in override Ext dom Element_position */ - getLocalX?(): number; - /** [Method] Gets the local CSS X and Y position for the element Defined in override Ext dom Element_position */ - getLocalXY?(): any[]; - /** [Method] Gets the local CSS Y position for the element Defined in override Ext dom Element_position */ - getLocalY?(): number; - /** [Method] Gets an object with all CSS positioning properties - * @param autoPx Boolean true to return pixel values for "auto" styles. - */ - getPositioning?( autoPx?:boolean ): any; - /** [Method] Returns the current scroll position of the element */ - getScroll?(): any; - /** [Method] Gets the left scroll position Defined in override Ext dom Element_scroll */ - getScrollLeft?(): number; - /** [Method] Gets the top scroll position Defined in override Ext dom Element_scroll */ - getScrollTop?(): number; - /** [Method] Returns the dimensions of the element available to lay content out in */ - getStyleSize?(): any; - /** [Method] Returns the width in pixels of the passed text or the width of the text in this Element - * @param text String The text to measure. Defaults to the innerHTML of the element. - * @param min Number The minumum value to return. - * @param max Number The maximum value to return. - */ - getTextWidth?( text?:string, min?:number, max?:number ): number; - /** [Method] Gets element X position in page coordinates Defined in override Ext dom Element_position */ - getX?(): number; - /** [Method] Gets element X and Y positions in page coordinates Defined in override Ext dom Element_position */ - getXY?(): any[]; - /** [Method] Gets element Y position in page coordinates Defined in override Ext dom Element_position */ - getY?(): number; - /** [Method] Slides the element while fading it out of view - * @param anchor String One of the valid Fx anchor positions (defaults to bottom: 'b') - * @param options Object Object literal with any of the Fx config options - */ - ghost?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Hide this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - hide?( animate?:any ): Ext.dom.IElement; - /** [Method] Highlights the Element by setting a color applies to the background color by default but can be changed using the - * @param color String The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c') - * @param options Object Object literal with any of the Fx config options - */ - highlight?( color?:string, options?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element - * @param overFn Function The function to call when the mouse enters the Element. - * @param outFn Function The function to call when the mouse leaves the Element. - * @param scope Object The scope (this reference) in which the functions are executed. Defaults to the Element's DOM element. - * @param options Object Options for the listener. See the options parameter. - */ - hover?( overFn?:any, outFn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes a Ext dd DD drag drop object for this element - * @param group String The group the DD object is member of - * @param config Object The DD config object - * @param overrides Object An object containing methods to override/implement on the DD object - */ - initDD?( group?:string, config?:any, overrides?:any ): Ext.dd.IDD; - /** [Method] Initializes a Ext dd DDProxy object for this element - * @param group String The group the DDProxy object is member of - * @param config Object The DDProxy config object - * @param overrides Object An object containing methods to override/implement on the DDProxy object - */ - initDDProxy?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDProxy; - /** [Method] Initializes a Ext dd DDTarget object for this element - * @param group String The group the DDTarget object is member of - * @param config Object The DDTarget config object - * @param overrides Object An object containing methods to override/implement on the DDTarget object - */ - initDDTarget?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDTarget; - /** [Method] Tests various css rules browsers to determine if this element uses a border box */ - isBorderBox?(): boolean; - /** [Method] Returns true if display is not none */ - isDisplayed?(): boolean; - /** [Method] Checks whether this element can be focused - * @param asFocusEl Object - */ - isFocusable?( asFocusEl?:any ): boolean; - /** [Method] Returns true if this element is masked */ - isMasked?(): boolean; - /** [Method] Returns true if this element is scrollable */ - isScrollable?(): boolean; - /** [Method] Checks whether the element is currently visible using both visibility and display properties - * @param deep Boolean True to walk the dom and see if parent elements are hidden. If false, the function only checks the visibility of the element itself and it may return true even though a parent is not visible. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Direct access to the Ext ElementLoader Ext ElementLoader load method - * @param options Object - */ - load?( options?:any ): Ext.dom.IElement; - /** [Method] Puts a mask over this element to disable user interaction - * @param msg String A message to display in the mask - * @param msgCls String A css class to apply to the msg element - */ - mask?( msg?:string, msgCls?:string ): Ext.dom.IElement; - /** [Method] Monitors this Element for the mouse leaving - * @param delay Number The delay in milliseconds to wait for possible mouse re-entry before calling the handler function. - * @param handler Function The function to call if the mouse remains outside of this Element for the specified time. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to this Element. - */ - monitorMouseLeave?( delay?:number, handler?:any, scope?:any ): any; - /** [Method] Returns true if this element needs an explicit tabIndex to make it focusable */ - needsTabIndex?(): void; - /** [Method] Appends an event handler to this element - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - on?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes positioning on this element - * @param pos String Positioning to use "relative", "absolute" or "fixed" - * @param zIndex Number The zIndex to apply - * @param x Number Set the page X position - * @param y Number Set the page Y position - */ - position?( pos?:string, zIndex?:number, x?:number, y?:number ): void; - /** [Method] Fades the element out while slowly expanding it in all directions - * @param options Object Object literal with any of the Fx config options - */ - puff?( options?:any ): Ext.dom.IElement; - /** [Method] Recursively removes all previous added listeners from this element and its children */ - purgeAllListeners?(): Ext.dom.IElement; - /** [Method] Create an event handler on this element such that when the event fires and is handled by this element it will be rel - * @param eventName String The type of event to relay - * @param observable Object Any object that extends Ext.util.Observable that will provide the context for firing the relayed event - */ - relayEvent?( eventName?:string, observable?:any ): void; - /** [Method] Removes all previous added listeners from this element */ - removeAllListeners?(): Ext.dom.IElement; - /** [Method] Shorthand for un - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified direction - * @param direction String Possible values are: "l" (or "left") "r" (or "right") "t" (or "top", or "up") "b" (or "bottom", or "down") - * @param distance Number How far to scroll the element in pixels - * @param animate any true for the default animation or a standard Element animation config object - */ - scroll?( direction?:string, distance?:number, animate?:any ): boolean; - /** [Method] Scrolls this element by the passed delta values optionally animating - * @param deltaX any Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties. - * @param deltaY any Either the y delta, or an animate flag or config object. - * @param animate any Animate flag/config object if the delta values were passed separately. - */ - scrollBy?( deltaX?:any, deltaY?:any, animate?:any ): Ext.IElement; - /** [Method] Scrolls this element into view within the passed container - * @param container any The container element to scroll. Should be a string (id), dom node, or Ext.Element. - * @param hscroll any False to disable horizontal scroll. - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollIntoView?( container?:any, hscroll?:any, animate?:any ): any; - scrollIntoView?( container?:string, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:HTMLElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:Ext.IElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified scroll point - * @param side String Either "left" for scrollLeft values or "top" for scrollTop values. - * @param value Number The new scroll value - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollTo?( side?:string, value?:number, animate?:any ): Ext.IElement; - /** [Method] Enable text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - selectable?(): Ext.IElement; - /** [Method] Sets the CSS display property - * @param value any Boolean value to display the element using its default display, or a string to set the display directly. - */ - setDisplayed?( value?:any ): any; - setDisplayed?( value?:boolean ): Ext.dom.IElement; - setDisplayed?( value?:string ): Ext.dom.IElement; - /** [Method] Set the opacity of the element Defined in override Ext dom Element_style - * @param opacity Number The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc - * @param animate any a standard Element animation config object or true for the default animation ({duration: 350, easing: 'easeIn'}) - */ - setOpacity?( opacity?:number, animate?:any ): Ext.dom.IElement; - /** [Method] Set positioning with an object returned by getPositioning - * @param posCfg Object - */ - setPositioning?( posCfg?:any ): Ext.dom.IElement; - /** [Method] Sets the left scroll position Defined in override Ext dom Element_scroll - * @param left Number The left scroll position - */ - setScrollLeft?( left?:number ): Ext.dom.IElement; - /** [Method] Sets the top scroll position Defined in override Ext dom Element_scroll - * @param top Number The top scroll position - */ - setScrollTop?( top?:number ): Ext.dom.IElement; - /** [Method] Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Show this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - show?( animate?:any ): Ext.dom.IElement; - /** [Method] Slides the element into view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideIn?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Slides the element out of view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideOut?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Stops the specified event s from bubbling and optionally prevents the default action - * @param eventName any an event / array of events to stop from bubbling - * @param preventDefault any true to prevent the default action too - */ - swallowEvent?( eventName?:any, preventDefault?:any ): any; - swallowEvent?( eventName?:string, preventDefault?:boolean ): Ext.dom.IElement; - swallowEvent?( eventName?:string[], preventDefault?:boolean ): Ext.dom.IElement; - /** [Method] Blinks the element as if it was clicked and then collapses on its center similar to switching off a television - * @param options Object Object literal with any of the Fx config options - */ - switchOff?( options?:any ): Ext.dom.IElement; - /** [Method] Toggles the element s visibility or display depending on visibility mode - * @param animate any True for the default animation, or a standard Element animation config object - */ - toggle?( animate?:any ): Ext.dom.IElement; - /** [Method] Removes an event handler from this element - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - un?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Return clipping overflow to original clipping before clip was called Defined in override Ext dom Element_style */ - unclip?(): Ext.dom.IElement; - /** [Method] Hides a previously applied mask */ - unmask?(): void; - /** [Method] Disables text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - unselectable?(): Ext.dom.IElement; - /** [Method] Updates the innerHTML of this element optionally searching for and processing scripts - * @param html String The new HTML - * @param loadScripts Boolean True to look for and process scripts (defaults to false) - * @param callback Function For async script loading you can be notified when the update completes - */ - update?( html?:string, loadScripts?:boolean, callback?:any ): Ext.dom.IElement; - } -} -declare module Ext.core { - export interface IElement extends Ext.dom.IAbstractElement { - /** [Property] (Boolean) True to automatically adjust width and height settings for box-model issues. ... */ - autoBoxAdjust?: boolean; - /** [Property] (String) The element's default display mode. ... */ - originalDisplay?: string; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is down and then up on this element a click effe - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnClick?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when this element has the focus Defined in override Ext dom Ele - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnFocus?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to add and remove a css class when the mouse is over this element Defined in override Ext dom - * @param className String The class to add - * @param testFn Function A test function to execute before adding the class. The passed parameter will be the Element instance. If this functions returns false, the class will not be added. - * @param scope Object The scope to execute the testFn in. - */ - addClsOnOver?( className?:string, testFn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Convenience method for constructing a KeyMap - * @param key any Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options: - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the specified function is executed. Defaults to this Element. - */ - addKeyListener?( key?:any, fn?:any, scope?:any ): Ext.util.IKeyMap; - /** [Method] Creates a KeyMap for this element - * @param config Object The KeyMap config. See Ext.util.KeyMap for more details - */ - addKeyMap?( config?:any ): Ext.util.IKeyMap; - /** [Method] Shorthand for on - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - addListener?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Performs custom animation on this Element - * @param config Object Configuration for Ext.fx.Anim. Note that the to config is required. - */ - animate?( config?:any ): Ext.dom.IElement; - /** [Method] Tries to blur the element */ - blur?(): Ext.dom.IElement; - /** [Method] Wraps the specified element with a special 9 element markup CSS block that renders by default as a gray container wit - * @param class String A base CSS class to apply to the containing wrapper element. Note that there are a number of CSS rules that are dependent on this name to make the overall effect work, so if you supply an alternate base class, make sure you also supply all of the necessary rules. - */ - boxWrap?( clazz?:string ): Ext.dom.IElement; - /** [Method] When an element is moved around in the DOM or is hidden using display none it loses layout and therefore all scrol */ - cacheScrollValues?(): any; - /** [Method] Centers the Element in either the viewport or another Element - * @param centerIn String element in which to center the element. - */ - center?( centerIn?:string ): void; - center?( centerIn?:HTMLElement ): void; - center?( centerIn?:Ext.dom.IElement ): void; - /** [Method] Removes Empty or whitespace filled text nodes - * @param forceReclean Boolean By default the element keeps track if it has been cleaned already so you can call this over and over. However, if you update the element and need to force a reclean, you can pass true. - */ - clean?( forceReclean?:boolean ): void; - /** [Method] Alias for removeAllListeners */ - clearListeners?(): Ext.dom.IElement; - /** [Method] Clears any opacity settings from this element */ - clearOpacity?(): Ext.dom.IElement; - /** [Method] Clears positioning back to the default when the document was loaded - * @param value String The value to use for the left, right, top, bottom. You could use 'auto'. - */ - clearPositioning?( value?:string ): Ext.dom.IElement; - /** [Method] Store the current overflow setting and clip overflow on the element use unclip to remove Defined in override Ext d */ - clip?(): Ext.dom.IElement; - /** [Method] Creates a proxy element of this element - * @param config any The class name of the proxy element or a DomHelper config object - * @param renderTo any The element or element id to render the proxy to. Defaults to: document.body. - * @param matchBox any True to align and size the proxy to this element now. - */ - createProxy?( config?:any, renderTo?:any, matchBox?:any ): any; - createProxy?( config?:any, renderTo?:string, matchBox?:boolean ): Ext.dom.IElement; - createProxy?( config?:any, renderTo?:HTMLElement, matchBox?:boolean ): Ext.dom.IElement; - /** [Method] Creates an iframe shim for this element to keep selects and other windowed objects from showing through */ - createShim?(): Ext.dom.IElement; - /** [Method] Convenience method for setVisibilityMode Element DISPLAY - * @param display String What to set display to when visible - */ - enableDisplayMode?( display?:string ): Ext.dom.IElement; - /** [Method] Fade an element in from transparent to opaque - * @param options Object Object literal with any of the Fx config options - */ - fadeIn?( options?:any ): Ext.IElement; - /** [Method] Fade an element out from opaque to transparent - * @param options Object Object literal with any of the Fx config options - */ - fadeOut?( options?:any ): Ext.IElement; - /** [Method] Tries to focus the element - * @param defer Number Milliseconds to defer the focus - */ - focus?( defer?:number ): Ext.dom.IElement; - /** [Method] Alias for isFocusable - * @param asFocusEl Object - */ - focusable?( asFocusEl?:any ): boolean; - /** [Method] Shows a ripple of exploding attenuating borders to draw attention to an Element - * @param color String The hex color value for the border. - * @param count Number The number of ripples to display. - * @param options Object Object literal with any of the Fx config options - */ - frame?( color?:string, count?:number, options?:any ): Ext.dom.IElement; - /** [Method] Returns the value of a namespaced attribute from the element s underlying DOM node - * @param namespace String The namespace in which to look for the attribute - * @param name String The attribute name - */ - getAttributeNS?( namespace?:string, name?:string ): string; - /** [Method] Return the CSS color for the specified CSS attribute - * @param attr String The css attribute - * @param defaultValue String The default value to use when a valid color isn't found - * @param prefix String defaults to #. Use an empty string when working with color anims. - */ - getColor?( attr?:string, defaultValue?:string, prefix?:string ): void; - /** [Method] Returns either the offsetHeight or the height of this element based on CSS height adjusted by padding or borders when */ - getComputedHeight?(): number; - /** [Method] Returns either the offsetWidth or the width of this element based on CSS width adjusted by padding or borders when ne */ - getComputedWidth?(): number; - /** [Method] Returns the sum width of the padding and borders for the passed sides - * @param sides String - */ - getFrameWidth?( sides?:string ): number; - /** [Method] Gets this element s ElementLoader */ - getLoader?(): Ext.IElementLoader; - /** [Method] Gets the local CSS X position for the element Defined in override Ext dom Element_position */ - getLocalX?(): number; - /** [Method] Gets the local CSS X and Y position for the element Defined in override Ext dom Element_position */ - getLocalXY?(): any[]; - /** [Method] Gets the local CSS Y position for the element Defined in override Ext dom Element_position */ - getLocalY?(): number; - /** [Method] Gets an object with all CSS positioning properties - * @param autoPx Boolean true to return pixel values for "auto" styles. - */ - getPositioning?( autoPx?:boolean ): any; - /** [Method] Returns the current scroll position of the element */ - getScroll?(): any; - /** [Method] Gets the left scroll position Defined in override Ext dom Element_scroll */ - getScrollLeft?(): number; - /** [Method] Gets the top scroll position Defined in override Ext dom Element_scroll */ - getScrollTop?(): number; - /** [Method] Returns the dimensions of the element available to lay content out in */ - getStyleSize?(): any; - /** [Method] Returns the width in pixels of the passed text or the width of the text in this Element - * @param text String The text to measure. Defaults to the innerHTML of the element. - * @param min Number The minumum value to return. - * @param max Number The maximum value to return. - */ - getTextWidth?( text?:string, min?:number, max?:number ): number; - /** [Method] Gets element X position in page coordinates Defined in override Ext dom Element_position */ - getX?(): number; - /** [Method] Gets element X and Y positions in page coordinates Defined in override Ext dom Element_position */ - getXY?(): any[]; - /** [Method] Gets element Y position in page coordinates Defined in override Ext dom Element_position */ - getY?(): number; - /** [Method] Slides the element while fading it out of view - * @param anchor String One of the valid Fx anchor positions (defaults to bottom: 'b') - * @param options Object Object literal with any of the Fx config options - */ - ghost?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Hide this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - hide?( animate?:any ): Ext.dom.IElement; - /** [Method] Highlights the Element by setting a color applies to the background color by default but can be changed using the - * @param color String The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c') - * @param options Object Object literal with any of the Fx config options - */ - highlight?( color?:string, options?:any ): Ext.dom.IElement; - /** [Method] Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element - * @param overFn Function The function to call when the mouse enters the Element. - * @param outFn Function The function to call when the mouse leaves the Element. - * @param scope Object The scope (this reference) in which the functions are executed. Defaults to the Element's DOM element. - * @param options Object Options for the listener. See the options parameter. - */ - hover?( overFn?:any, outFn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes a Ext dd DD drag drop object for this element - * @param group String The group the DD object is member of - * @param config Object The DD config object - * @param overrides Object An object containing methods to override/implement on the DD object - */ - initDD?( group?:string, config?:any, overrides?:any ): Ext.dd.IDD; - /** [Method] Initializes a Ext dd DDProxy object for this element - * @param group String The group the DDProxy object is member of - * @param config Object The DDProxy config object - * @param overrides Object An object containing methods to override/implement on the DDProxy object - */ - initDDProxy?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDProxy; - /** [Method] Initializes a Ext dd DDTarget object for this element - * @param group String The group the DDTarget object is member of - * @param config Object The DDTarget config object - * @param overrides Object An object containing methods to override/implement on the DDTarget object - */ - initDDTarget?( group?:string, config?:any, overrides?:any ): Ext.dd.IDDTarget; - /** [Method] Tests various css rules browsers to determine if this element uses a border box */ - isBorderBox?(): boolean; - /** [Method] Returns true if display is not none */ - isDisplayed?(): boolean; - /** [Method] Checks whether this element can be focused - * @param asFocusEl Object - */ - isFocusable?( asFocusEl?:any ): boolean; - /** [Method] Returns true if this element is masked */ - isMasked?(): boolean; - /** [Method] Returns true if this element is scrollable */ - isScrollable?(): boolean; - /** [Method] Checks whether the element is currently visible using both visibility and display properties - * @param deep Boolean True to walk the dom and see if parent elements are hidden. If false, the function only checks the visibility of the element itself and it may return true even though a parent is not visible. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Direct access to the Ext ElementLoader Ext ElementLoader load method - * @param options Object - */ - load?( options?:any ): Ext.dom.IElement; - /** [Method] Puts a mask over this element to disable user interaction - * @param msg String A message to display in the mask - * @param msgCls String A css class to apply to the msg element - */ - mask?( msg?:string, msgCls?:string ): Ext.dom.IElement; - /** [Method] Monitors this Element for the mouse leaving - * @param delay Number The delay in milliseconds to wait for possible mouse re-entry before calling the handler function. - * @param handler Function The function to call if the mouse remains outside of this Element for the specified time. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to this Element. - */ - monitorMouseLeave?( delay?:number, handler?:any, scope?:any ): any; - /** [Method] Returns true if this element needs an explicit tabIndex to make it focusable */ - needsTabIndex?(): void; - /** [Method] Appends an event handler to this element - * @param eventName String The name of event to handle. - * @param fn Function The handler function the event invokes. This function is passed the following parameters: evt : EventObject The EventObject describing the event. el : HtmlElement The DOM element which was the target of the event. Note that this may be filtered by using the delegate option. o : Object The options object from the call that setup the listener. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties: scope Object : The scope (this reference) in which the handler function is executed. If omitted, defaults to this Element. delegate String: A simple selector to filter the target or look for a descendant of the target. See below for additional details. stopEvent Boolean: True to stop the event. That is stop propagation, and prevent the default action. preventDefault Boolean: True to prevent the default action stopPropagation Boolean: True to prevent event propagation normalized Boolean: False to pass a browser event to the handler function instead of an Ext.EventObject target Ext.dom.Element: Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node. delay Number: The number of milliseconds to delay the invocation of the handler after the event fires. single Boolean: True to add a handler to handle just the next firing of the event, and then remove itself. buffer Number: Causes the handler to be scheduled to run in an Ext.util.DelayedTask delayed by the specified number of milliseconds. If the event fires again within that time, the original handler is not invoked, but the new handler is scheduled in its place. Combining Options Using the options argument, it is possible to combine different types of listeners: A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the options object. The options object is available as the third parameter in the handler function. Code: el.on('click', this.onClick, this, { single: true, delay: 100, stopEvent : true, forumId: 4 }); Attaching multiple handlers in 1 call The method also allows for a single argument to be passed which is a config object containing properties which specify multiple handlers. Code: el.on({ 'click' : { fn: this.onClick, scope: this, delay: 100 }, 'mouseover' : { fn: this.onMouseOver, scope: this }, 'mouseout' : { fn: this.onMouseOut, scope: this } }); Or a shorthand syntax: Code: el.on({ 'click' : this.onClick, 'mouseover' : this.onMouseOver, 'mouseout' : this.onMouseOut, scope: this }); delegate This is a configuration option that you can pass along when registering a handler for an event to assist with event delegation. Event delegation is a technique that is used to reduce memory consumption and prevent exposure to memory-leaks. By registering an event for a container element as opposed to each element within a container. By setting this configuration option to a simple selector, the target element will be filtered to look for a descendant of the target. For example: // using this markup: <div id='elId'> <p id='p1'>paragraph one</p> <p id='p2' class='clickable'>paragraph two</p> <p id='p3'>paragraph three</p> </div> // utilize event delegation to registering just one handler on the container element: el = Ext.get('elId'); el.on( 'click', function(e,t) { // handle click console.info(t.id); // 'p2' }, this, { // filter the target element to be a descendant with the class 'clickable' delegate: '.clickable' } ); - */ - on?( eventName?:string, fn?:any, scope?:any, options?:any ): Ext.dom.IElement; - /** [Method] Initializes positioning on this element - * @param pos String Positioning to use "relative", "absolute" or "fixed" - * @param zIndex Number The zIndex to apply - * @param x Number Set the page X position - * @param y Number Set the page Y position - */ - position?( pos?:string, zIndex?:number, x?:number, y?:number ): void; - /** [Method] Fades the element out while slowly expanding it in all directions - * @param options Object Object literal with any of the Fx config options - */ - puff?( options?:any ): Ext.dom.IElement; - /** [Method] Recursively removes all previous added listeners from this element and its children */ - purgeAllListeners?(): Ext.dom.IElement; - /** [Method] Create an event handler on this element such that when the event fires and is handled by this element it will be rel - * @param eventName String The type of event to relay - * @param observable Object Any object that extends Ext.util.Observable that will provide the context for firing the relayed event - */ - relayEvent?( eventName?:string, observable?:any ): void; - /** [Method] Removes all previous added listeners from this element */ - removeAllListeners?(): Ext.dom.IElement; - /** [Method] Shorthand for un - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified direction - * @param direction String Possible values are: "l" (or "left") "r" (or "right") "t" (or "top", or "up") "b" (or "bottom", or "down") - * @param distance Number How far to scroll the element in pixels - * @param animate any true for the default animation or a standard Element animation config object - */ - scroll?( direction?:string, distance?:number, animate?:any ): boolean; - /** [Method] Scrolls this element by the passed delta values optionally animating - * @param deltaX any Either the x delta, an Array specifying x and y deltas or an object with "x" and "y" properties. - * @param deltaY any Either the y delta, or an animate flag or config object. - * @param animate any Animate flag/config object if the delta values were passed separately. - */ - scrollBy?( deltaX?:any, deltaY?:any, animate?:any ): Ext.IElement; - /** [Method] Scrolls this element into view within the passed container - * @param container any The container element to scroll. Should be a string (id), dom node, or Ext.Element. - * @param hscroll any False to disable horizontal scroll. - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollIntoView?( container?:any, hscroll?:any, animate?:any ): any; - scrollIntoView?( container?:string, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:HTMLElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - scrollIntoView?( container?:Ext.IElement, hscroll?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Scrolls this element the specified scroll point - * @param side String Either "left" for scrollLeft values or "top" for scrollTop values. - * @param value Number The new scroll value - * @param animate any true for the default animation or a standard Element animation config object - */ - scrollTo?( side?:string, value?:number, animate?:any ): Ext.IElement; - /** [Method] Enable text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - selectable?(): Ext.IElement; - /** [Method] Sets the CSS display property - * @param value any Boolean value to display the element using its default display, or a string to set the display directly. - */ - setDisplayed?( value?:any ): any; - setDisplayed?( value?:boolean ): Ext.dom.IElement; - setDisplayed?( value?:string ): Ext.dom.IElement; - /** [Method] Set the opacity of the element Defined in override Ext dom Element_style - * @param opacity Number The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc - * @param animate any a standard Element animation config object or true for the default animation ({duration: 350, easing: 'easeIn'}) - */ - setOpacity?( opacity?:number, animate?:any ): Ext.dom.IElement; - /** [Method] Set positioning with an object returned by getPositioning - * @param posCfg Object - */ - setPositioning?( posCfg?:any ): Ext.dom.IElement; - /** [Method] Sets the left scroll position Defined in override Ext dom Element_scroll - * @param left Number The left scroll position - */ - setScrollLeft?( left?:number ): Ext.dom.IElement; - /** [Method] Sets the top scroll position Defined in override Ext dom Element_scroll - * @param top Number The top scroll position - */ - setScrollTop?( top?:number ): Ext.dom.IElement; - /** [Method] Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] Show this element Uses display mode to determine whether to use display or visibility - * @param animate any true for the default animation or a standard Element animation config object - */ - show?( animate?:any ): Ext.dom.IElement; - /** [Method] Slides the element into view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideIn?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Slides the element out of view - * @param anchor String One of the valid Fx anchor positions (defaults to top: 't') - * @param options Object Object literal with any of the Fx config options - */ - slideOut?( anchor?:string, options?:any ): Ext.dom.IElement; - /** [Method] Stops the specified event s from bubbling and optionally prevents the default action - * @param eventName any an event / array of events to stop from bubbling - * @param preventDefault any true to prevent the default action too - */ - swallowEvent?( eventName?:any, preventDefault?:any ): any; - swallowEvent?( eventName?:string, preventDefault?:boolean ): Ext.dom.IElement; - swallowEvent?( eventName?:string[], preventDefault?:boolean ): Ext.dom.IElement; - /** [Method] Blinks the element as if it was clicked and then collapses on its center similar to switching off a television - * @param options Object Object literal with any of the Fx config options - */ - switchOff?( options?:any ): Ext.dom.IElement; - /** [Method] Toggles the element s visibility or display depending on visibility mode - * @param animate any True for the default animation, or a standard Element animation config object - */ - toggle?( animate?:any ): Ext.dom.IElement; - /** [Method] Removes an event handler from this element - * @param eventName String The name of the event from which to remove the handler. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the on call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - un?( eventName?:string, fn?:any, scope?:any ): Ext.dom.IElement; - /** [Method] Return clipping overflow to original clipping before clip was called Defined in override Ext dom Element_style */ - unclip?(): Ext.dom.IElement; - /** [Method] Hides a previously applied mask */ - unmask?(): void; - /** [Method] Disables text selection for this element normalized across browsers Defined in override Ext dom Element_style */ - unselectable?(): Ext.dom.IElement; - /** [Method] Updates the innerHTML of this element optionally searching for and processing scripts - * @param html String The new HTML - * @param loadScripts Boolean True to look for and process scripts (defaults to false) - * @param callback Function For async script loading you can be notified when the update completes - */ - update?( html?:string, loadScripts?:boolean, callback?:any ): Ext.dom.IElement; - } -} -declare module Ext.dom { - export interface IHelper extends Ext.dom.IAbstractHelper { - /** [Property] (Boolean) True to force the use of DOM instead of html fragments. ... */ - useDom?: boolean; - /** [Method] Creates new DOM element s without inserting them to the document - * @param o any The DOM object spec (and children) or raw HTML blob - */ - createDom?( o?:any ): HTMLElement; - /** [Method] Alias for markup - * @param spec Object The DOM object spec (and children) - */ - createHtml?( spec?:any ): string; - /** [Method] Creates a new Ext Template from the DOM object spec - * @param o Object The DOM object spec (and children) - */ - createTemplate?( o?:any ): Ext.ITemplate; - /** [Method] Creates new DOM element s and overwrites the contents of el with them - * @param el any The context element - * @param o any The DOM object spec (and children) or raw HTML blob - * @param returnElement any true to return an Ext.Element - */ - overwrite?( el?:any, o?:any, returnElement?:any ): any; - overwrite?( el?:string, o?:any, returnElement?:boolean ): any; - overwrite?( el?:HTMLElement, o?:any, returnElement?:boolean ): any; - overwrite?( el?:Ext.IElement, o?:any, returnElement?:boolean ): any; - } -} -declare module Ext.dom { - export interface ILayer extends Ext.dom.IElement { - /** [Config Option] (String) */ - cls?: string; - /** [Config Option] (Boolean) False to disable constrain to viewport. ... */ - constrain?: boolean; - /** [Config Option] (Object) DomHelper object config to create element with. ... */ - dh?: any; - /** [Config Option] (String) A String which specifies how this Layer will be hidden. ... */ - hideMode?: string; - /** [Config Option] (String/Boolean) True to automatically create an Ext.Shadow, or a string indicating the shadow's display Ext.Shadow.mode. ... */ - shadow?: any; - /** [Config Option] (Number) Number of pixels to offset the shadow ... */ - shadowOffset?: number; - /** [Config Option] (Boolean) False to disable the iframe shim in browsers which need one. ... */ - shim?: boolean; - /** [Config Option] (Boolean) Defaults to use css offsets to hide the Layer. ... */ - useDisplay?: boolean; - /** [Config Option] (String) */ - visibilityCls?: string; - /** [Config Option] (Number) Starting z-index. ... */ - zindex?: number; - /** [Method] Removes this element s dom reference */ - remove?(): void; - /** [Method] overridden Element method Set the height of this Element - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels.) A String used to set the CSS height style. Animation may not be used. - */ - setHeight?( height?:any ): any; - setHeight?( height?:number ): Ext.dom.IElement; - setHeight?( height?:string ): Ext.dom.IElement; - /** [Method] overridden Element method Set the size of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. A size object in the format {width: widthValue, height: heightValue}. - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:number, height?:number ): Ext.dom.IElement; - setSize?( width?:string, height?:number ): Ext.dom.IElement; - setSize?( width?:number, height?:string ): Ext.dom.IElement; - setSize?( width?:string, height?:string ): Ext.dom.IElement; - /** [Method] overridden Element method Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] overridden Element method Set the width of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. - */ - setWidth?( width?:any ): any; - setWidth?( width?:number ): Ext.dom.IElement; - setWidth?( width?:string ): Ext.dom.IElement; - /** [Method] Sets the z index of this layer and adjusts any shadow and shim z indexes - * @param zindex Number The new z-index to set - */ - setZIndex?( zindex?:number ): Ext.ILayer; - } -} -declare module Ext { - export interface ILayer extends Ext.dom.IElement { - /** [Config Option] (String) */ - cls?: string; - /** [Config Option] (Boolean) False to disable constrain to viewport. ... */ - constrain?: boolean; - /** [Config Option] (Object) DomHelper object config to create element with. ... */ - dh?: any; - /** [Config Option] (String) A String which specifies how this Layer will be hidden. ... */ - hideMode?: string; - /** [Config Option] (String/Boolean) True to automatically create an Ext.Shadow, or a string indicating the shadow's display Ext.Shadow.mode. ... */ - shadow?: any; - /** [Config Option] (Number) Number of pixels to offset the shadow ... */ - shadowOffset?: number; - /** [Config Option] (Boolean) False to disable the iframe shim in browsers which need one. ... */ - shim?: boolean; - /** [Config Option] (Boolean) Defaults to use css offsets to hide the Layer. ... */ - useDisplay?: boolean; - /** [Config Option] (String) */ - visibilityCls?: string; - /** [Config Option] (Number) Starting z-index. ... */ - zindex?: number; - /** [Method] Removes this element s dom reference */ - remove?(): void; - /** [Method] overridden Element method Set the height of this Element - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels.) A String used to set the CSS height style. Animation may not be used. - */ - setHeight?( height?:any ): any; - setHeight?( height?:number ): Ext.dom.IElement; - setHeight?( height?:string ): Ext.dom.IElement; - /** [Method] overridden Element method Set the size of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. A size object in the format {width: widthValue, height: heightValue}. - * @param height any The new height. This may be one of: A Number specifying the new height in this Element's defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:number, height?:number ): Ext.dom.IElement; - setSize?( width?:string, height?:number ): Ext.dom.IElement; - setSize?( width?:number, height?:string ): Ext.dom.IElement; - setSize?( width?:string, height?:string ): Ext.dom.IElement; - /** [Method] overridden Element method Sets the visibility of the element see details - * @param visible Boolean Whether the element is visible - * @param animate any True for the default animation, or a standard Element animation config object - */ - setVisible?( visible?:boolean, animate?:any ): Ext.dom.IElement; - /** [Method] overridden Element method Set the width of this Element - * @param width any The new width. This may be one of: A Number specifying the new width in this Element's defaultUnits (by default, pixels). A String used to set the CSS width style. Animation may not be used. - */ - setWidth?( width?:any ): any; - setWidth?( width?:number ): Ext.dom.IElement; - setWidth?( width?:string ): Ext.dom.IElement; - /** [Method] Sets the z index of this layer and adjusts any shadow and shim z indexes - * @param zindex Number The new z-index to set - */ - setZIndex?( zindex?:number ): Ext.ILayer; - } -} -declare module Ext.dom { - export interface IQuery { - } - export class Query { - /** [Method] Compiles a selector xpath query into a reusable function - * @param selector String The selector/xpath query - * @param type String Either "select" or "simple" for a simple selector match - */ - static compile( selector?:string, type?:string ): any; - /** [Method] Filters an array of elements to only include matches of a simple selector e g - * @param el HTMLElement[] An array of elements to filter - * @param selector String The simple selector to test - * @param nonMatches Boolean If true, it returns the elements that DON'T match the selector instead of the ones that match - */ - static filter( el?:HTMLElement[], selector?:string, nonMatches?:boolean ): HTMLElement[]; - /** [Method] Returns true if the passed element s match the passed simple selector e g - * @param el any An element id, element or array of elements - * @param selector any The simple selector to test - */ - static is( el?:any, selector?:any ): any; - static is( el?:string, selector?:string ): boolean; - static is( el?:HTMLElement, selector?:string ): boolean; - static is( el?:HTMLElement[], selector?:string ): boolean; - /** [Method] Selects an array of DOM nodes using JavaScript only implementation - * @param selector any The selector/xpath query (can be a comma separated list of selectors) - * @param root any The start of the query. - */ - static jsSelect( selector?:any, root?:any ): any; - static jsSelect( selector?:string, root?:HTMLElement ): HTMLElement[]; - static jsSelect( selector?:string, root?:string ): HTMLElement[]; - /** [Method] Selects an array of DOM nodes by CSS XPath selector - * @param path String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param type String Either "select" or "simple" for a simple selector match (only valid when used when the call is deferred to the jsSelect method) - * @param single Boolean Pass true to select only the first matching node using document.querySelector (where available) - */ - static select( path?:string, root?:HTMLElement, type?:string, single?:boolean ): HTMLElement[]; - /** [Method] Selects a single element - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - */ - static selectNode( selector?:string, root?:HTMLElement ): HTMLElement; - /** [Method] Selects the value of a node parsing integers and floats - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue Number When specified, this is return as empty value. - */ - static selectNumber( selector?:string, root?:HTMLElement, defaultValue?:number ): number; - /** [Method] Selects the value of a node optionally replacing null with the defaultValue - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue String When specified, this is return as empty value. - */ - static selectValue( selector?:string, root?:HTMLElement, defaultValue?:string ): string; - } -} -declare module Ext { - export interface IDomQuery { - } - export class DomQuery { - /** [Method] Compiles a selector xpath query into a reusable function - * @param selector String The selector/xpath query - * @param type String Either "select" or "simple" for a simple selector match - */ - static compile( selector?:string, type?:string ): any; - /** [Method] Filters an array of elements to only include matches of a simple selector e g - * @param el HTMLElement[] An array of elements to filter - * @param selector String The simple selector to test - * @param nonMatches Boolean If true, it returns the elements that DON'T match the selector instead of the ones that match - */ - static filter( el?:HTMLElement[], selector?:string, nonMatches?:boolean ): HTMLElement[]; - /** [Method] Returns true if the passed element s match the passed simple selector e g - * @param el any An element id, element or array of elements - * @param selector any The simple selector to test - */ - static is( el?:any, selector?:any ): any; - static is( el?:string, selector?:string ): boolean; - static is( el?:HTMLElement, selector?:string ): boolean; - static is( el?:HTMLElement[], selector?:string ): boolean; - /** [Method] Selects an array of DOM nodes using JavaScript only implementation - * @param selector any The selector/xpath query (can be a comma separated list of selectors) - * @param root any The start of the query. - */ - static jsSelect( selector?:any, root?:any ): any; - static jsSelect( selector?:string, root?:HTMLElement ): HTMLElement[]; - static jsSelect( selector?:string, root?:string ): HTMLElement[]; - /** [Method] Selects an array of DOM nodes by CSS XPath selector - * @param path String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param type String Either "select" or "simple" for a simple selector match (only valid when used when the call is deferred to the jsSelect method) - * @param single Boolean Pass true to select only the first matching node using document.querySelector (where available) - */ - static select( path?:string, root?:HTMLElement, type?:string, single?:boolean ): HTMLElement[]; - /** [Method] Selects a single element - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - */ - static selectNode( selector?:string, root?:HTMLElement ): HTMLElement; - /** [Method] Selects the value of a node parsing integers and floats - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue Number When specified, this is return as empty value. - */ - static selectNumber( selector?:string, root?:HTMLElement, defaultValue?:number ): number; - /** [Method] Selects the value of a node optionally replacing null with the defaultValue - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue String When specified, this is return as empty value. - */ - static selectValue( selector?:string, root?:HTMLElement, defaultValue?:string ): string; - } -} -declare module Ext.core { - export interface IDomQuery { - } - export class DomQuery { - /** [Method] Compiles a selector xpath query into a reusable function - * @param selector String The selector/xpath query - * @param type String Either "select" or "simple" for a simple selector match - */ - static compile( selector?:string, type?:string ): any; - /** [Method] Filters an array of elements to only include matches of a simple selector e g - * @param el HTMLElement[] An array of elements to filter - * @param selector String The simple selector to test - * @param nonMatches Boolean If true, it returns the elements that DON'T match the selector instead of the ones that match - */ - static filter( el?:HTMLElement[], selector?:string, nonMatches?:boolean ): HTMLElement[]; - /** [Method] Returns true if the passed element s match the passed simple selector e g - * @param el any An element id, element or array of elements - * @param selector any The simple selector to test - */ - static is( el?:any, selector?:any ): any; - static is( el?:string, selector?:string ): boolean; - static is( el?:HTMLElement, selector?:string ): boolean; - static is( el?:HTMLElement[], selector?:string ): boolean; - /** [Method] Selects an array of DOM nodes using JavaScript only implementation - * @param selector any The selector/xpath query (can be a comma separated list of selectors) - * @param root any The start of the query. - */ - static jsSelect( selector?:any, root?:any ): any; - static jsSelect( selector?:string, root?:HTMLElement ): HTMLElement[]; - static jsSelect( selector?:string, root?:string ): HTMLElement[]; - /** [Method] Selects an array of DOM nodes by CSS XPath selector - * @param path String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param type String Either "select" or "simple" for a simple selector match (only valid when used when the call is deferred to the jsSelect method) - * @param single Boolean Pass true to select only the first matching node using document.querySelector (where available) - */ - static select( path?:string, root?:HTMLElement, type?:string, single?:boolean ): HTMLElement[]; - /** [Method] Selects a single element - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - */ - static selectNode( selector?:string, root?:HTMLElement ): HTMLElement; - /** [Method] Selects the value of a node parsing integers and floats - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue Number When specified, this is return as empty value. - */ - static selectNumber( selector?:string, root?:HTMLElement, defaultValue?:number ): number; - /** [Method] Selects the value of a node optionally replacing null with the defaultValue - * @param selector String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param defaultValue String When specified, this is return as empty value. - */ - static selectValue( selector?:string, root?:HTMLElement, defaultValue?:string ): string; - } -} -declare module Ext { - export interface IDomHelper extends Ext.dom.IHelper { - } - export class DomHelper { - } -} -declare module Ext.core { - export interface IDomHelper extends Ext.dom.IHelper { - } - export class DomHelper { - } -} -declare module Ext.draw { - export interface IColor extends Ext.IBase { - /** [Config Option] (Number) The default factor to compute the lighter or darker color. ... */ - lightnessFactor?: number; - /** [Method] Get the blue component of the color in the range 0 255 */ - getBlue?(): number; - /** [Method] Return a new color that is darker than this color - * @param factor Number Darker factor (0..1), default to 0.2 - */ - getDarker?( factor?:number ): any; - /** [Method] Returns the gray value 0 to 255 of the color */ - getGrayscale?(): number; - /** [Method] Get the green component of the color in the range 0 255 */ - getGreen?(): number; - /** [Method] Get the equivalent HSL components of the color */ - getHSL?(): number[]; - /** [Method] Return a new color that is lighter than this color - * @param factor Number Lighter factor (0..1), default to 0.2 - */ - getLighter?( factor?:number ): any; - /** [Method] Get the RGB values */ - getRGB?(): number[]; - /** [Method] Get the red component of the color in the range 0 255 */ - getRed?(): number; - /** [Method] Return the color in the hex format i e */ - toString?(): string; - } -} -declare module Ext.draw { - export interface IComponent extends Ext.IComponent { - /** [Config Option] (Boolean) Turn on autoSize support which will set the bounding div's size to the natural size of the contents. ... */ - autoSize?: boolean; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String[]) Defines the priority order for which Surface implementation to use. ... */ - enginePriority?: string[]; - /** [Config Option] (Object[]) (optional) Define a set of gradients that can be used as fill property in sprites. ... */ - gradients?: Object[]; - /** [Config Option] (Ext.draw.Sprite[]) */ - items?: Ext.draw.ISprite[]; - /** [Config Option] (Boolean/Number) If this property is a number, it is interpreted as follows: 0: Neither width nor height depend on content. ... */ - shrinkWrap?: any; - /** [Config Option] (Boolean) Turn on view box support which will scale and position items in the draw component to fit to the component while main... */ - viewBox?: boolean; - /** [Property] (Ext.draw.Surface) */ - surface?: Ext.draw.ISurface; - } -} -declare module Ext.draw { - export interface ICompositeSprite extends Ext.util.IMixedCollection,Ext.util.IAnimate { - /** [Method] Inherit docs from MixedCollection Adds an item to the collection - * @param key any The key to associate with the item, or the new item. If a getKey implementation was specified for this MixedCollection, or if the key of the stored items is in a property called id, the MixedCollection will be able to derive the key for the new item. In this case just pass the new item in this parameter. - * @param obj Object The item to add. - */ - add?( key?:any, obj?:any ): any; - /** [Method] Adds class to all sprites - * @param cls String CSS class name - */ - addCls?( cls?:string ): void; - /** [Method] Performs custom animation on this object - * @param config Object Configuration for Ext.fx.Anim. Note that the to config is required. - */ - animate?( config?:any ): any; - /** [Method] Destroys this CompositeSprite */ - destroy?(): void; - /** [Method] Returns the current animation if this object has any effects actively running or queued else returns false */ - getActiveAnimation?(): any; - /** [Method] Returns the group bounding box */ - getBBox?(): any; - /** [Method] Hides all sprites - * @param redraw Boolean Flag to immediately draw the change. - */ - hide?( redraw?:boolean ): Ext.draw.ICompositeSprite; - /** [Method] Inserts an item at the specified index in the collection - * @param index Number The index to insert the item at. - * @param key any The key to associate with the new item, or the item itself. May also be an array of either to insert multiple items at once. - * @param o any If the second parameter was a key, the new item. May also be an array to insert multiple items at once. - */ - insert?( index?:number, key?:any, o?:any ): any; - /** [Method] Force redraw of all sprites */ - redraw?(): void; - /** [Method] Inherit docs from MixedCollection Remove an item from the collection - * @param o Object The item to remove. - */ - remove?( o?:any ): any; - /** [Method] Removes class from all sprites - * @param cls String CSS class name - */ - removeCls?( cls?:string ): void; - /** [Method] Ensures that all effects queued after sequenceFx is called on this object are run in sequence */ - sequenceFx?(): any; - /** [Method] Iterates through all sprites calling setAttributes on each one - * @param attrs Object Attributes to be changed on the sprite. - * @param redraw Boolean Flag to immediately draw the change. - */ - setAttributes?( attrs?:any, redraw?:boolean ): Ext.draw.ICompositeSprite; - /** [Method] Sets style for all sprites - * @param style String CSS Style definition. - */ - setStyle?( style?:string ): void; - /** [Method] Shows all sprites - * @param redraw Boolean Flag to immediately draw the change. - */ - show?( redraw?:boolean ): Ext.draw.ICompositeSprite; - /** [Method] Stops any running effects and clears this object s internal effects queue if it contains any additional effects that */ - stopAnimation?(): Ext.IElement; - /** [Method] Ensures that all effects queued after syncFx is called on this object are run concurrently */ - syncFx?(): any; - } -} -declare module Ext.draw { - export interface IDraw extends Ext.IBase { - } - export class Draw { - /** [Method] snapEndsByDate is a utility method to deduce an appropriate tick configuration for the data set of given feature - * @param from Date The minimum value in the data - * @param to Date The maximum value in the data - * @param stepsMax Number The maximum number of ticks - * @param lockEnds Boolean If true, the 'from' and 'to' parameters will be used as fixed end values and will not be adjusted - */ - static snapEndsByDate( from?:any, to?:any, stepsMax?:number, lockEnds?:boolean ): any; - /** [Method] snapEndsByDateAndStep is a utility method to deduce an appropriate tick configuration for the data set of given featu - * @param from Date The minimum value in the data - * @param to Date The maximum value in the data - * @param step Array An array with two components: The first is the unit of the step (day, month, year, etc). The second is the number of units for the step (1, 2, etc.). If the number is an integer, it represents the number of units for the step ([Ext.Date.DAY, 2] means "Every other day"). If the number is a fraction, it represents the number of steps per unit ([Ext.Date.DAY, 1/2] means "Twice a day"). If the unit is the month, the steps may be adjusted depending on the month. For instance [Ext.Date.MONTH, 1/3], which means "Three times a month", generates steps on the 1st, the 10th and the 20th of every month regardless of whether a month has 28 days or 31 days. The steps are generated as follows: - [Ext.Date.MONTH, n]: on the current date every 'n' months, maxed to the number of days in the month. - [Ext.Date.MONTH, 1/2]: on the 1st and 15th of every month. - [Ext.Date.MONTH, 1/3]: on the 1st, 10th and 20th of every month. - [Ext.Date.MONTH, 1/4]: on the 1st, 8th, 15th and 22nd of every month. - * @param lockEnds Boolean If true, the 'from' and 'to' parameters will be used as fixed end values and will not be adjusted - */ - static snapEndsByDateAndStep( from?:any, to?:any, step?:any[], lockEnds?:boolean ): any; - } -} -declare module Ext.draw.engine { - export interface IImageExporter extends Ext.IBase { - } - export class ImageExporter { - /** [Method] Exports the surface to an image - * @param surface Ext.draw.ISurface The surface to export - * @param config Object The following config options are supported: - */ - static generate( surface?:Ext.draw.ISurface, config?:any ): boolean; - } -} -declare module Ext.draw.engine { - export interface ISvg extends Ext.draw.ISurface { - /** [Method] Adds one or more CSS classes to the element - * @param sprite Object The sprite to add the class to. - * @param className String The CSS class to add, or an array of classes - */ - addCls?( sprite?:any, className?:string ): void; - addCls?( sprite?:any, className?:string[] ): void; - /** [Method] Adds a gradient definition to the Surface - * @param gradient Object A gradient config. - */ - addGradient?( gradient?:any ): void; - /** [Method] Insert or move a given sprite s element to the correct place in the DOM list for its zIndex - * @param sprite Ext.draw.ISprite - */ - applyZIndex?( sprite?:Ext.draw.ISprite ): void; - /** [Method] Destroys the surface */ - destroy?(): void; - /** [Method] Get the region for the surface s canvas area */ - getRegion?(): Ext.util.IRegion; - /** [Method] Checks if the specified CSS class exists on this element s DOM node - * @param sprite Ext.draw.ISprite The sprite to look into. - * @param className String The CSS class to check for - */ - hasCls?( sprite?:Ext.draw.ISprite, className?:string ): boolean; - /** [Method] Removes one or more CSS classes from the element - * @param sprite Object The sprite to remove the class from. - * @param className String The CSS class to remove, or an array of classes - */ - removeCls?( sprite?:any, className?:string ): void; - removeCls?( sprite?:any, className?:string[] ): void; - /** [Method] Sets the size of the surface - * @param w Number The new width of the canvas. - * @param h Number The new height of the canvas. - */ - setSize?( w?:number, h?:number ): void; - /** [Method] Changes the text in the sprite element - * @param sprite Object The Sprite to change the text. - * @param text String The new text to be set. - */ - setText?( sprite?:any, text?:string ): void; - } -} -declare module Ext.draw.engine { - export interface ISvgExporter extends Ext.IBase { - } - export class SvgExporter { - /** [Method] Exports the passed surface to a SVG string representation - * @param surface Ext.draw.ISurface The surface to export - * @param config Object Any configuration for the export. Currently this is unused but may provide more options in the future - */ - static generate( surface?:Ext.draw.ISurface, config?:any ): string; - } -} -declare module Ext.draw.engine { - export interface IVml extends Ext.draw.ISurface { - /** [Method] Adds one or more CSS classes to the element - * @param sprite Object The sprite to add the class to. - * @param className String The CSS class to add, or an array of classes - */ - addCls?( sprite?:any, className?:string ): void; - addCls?( sprite?:any, className?:string[] ): void; - /** [Method] Adds a definition to this Surface for a linear gradient - * @param gradient Object - */ - addGradient?( gradient?:any ): void; - /** [Method] Destroys the surface */ - destroy?(): void; - /** [Method] Removes one or more CSS classes from the element - * @param sprite Object The sprite to remove the class from. - * @param className String The CSS class to remove, or an array of classes - */ - removeCls?( sprite?:any, className?:string ): void; - removeCls?( sprite?:any, className?:string[] ): void; - /** [Method] Sets the size of the surface - * @param w Number The new width of the canvas. - * @param h Number The new height of the canvas. - */ - setSize?( w?:number, h?:number ): void; - /** [Method] Changes the text in the sprite element - * @param sprite Object The Sprite to change the text. - * @param text String The new text to be set. - */ - setText?( sprite?:any, text?:string ): void; - } -} -declare module Ext.draw { - export interface IMatrix extends Ext.IBase { - } -} -declare module Ext.draw { - export interface ISprite extends Ext.IBase,Ext.util.IAnimate,Ext.util.IObservable { - /** [Config Option] (Boolean) */ - draggable?: boolean; - /** [Config Option] (String) */ - fill?: string; - /** [Config Option] (String) Used with text type sprites. ... */ - font?: string; - /** [Config Option] (String/String[]) The group that this sprite belongs to, or an array of groups. ... */ - group?: any; - /** [Config Option] (Number) */ - height?: number; - /** [Config Option] (Number) The opacity of the sprite. ... */ - opacity?: number; - /** [Config Option] (String) */ - path?: string; - /** [Config Option] (Number) The radius of the circle sprite. ... */ - radius?: number; - /** [Config Option] (Number) */ - radiusX?: number; - /** [Config Option] (Number) */ - radiusY?: number; - /** [Config Option] (String) */ - src?: string; - /** [Config Option] (String) */ - stroke?: string; - /** [Config Option] (Number) The width of the stroke. ... */ - strokewidth?: number; - /** [Config Option] (String) */ - text?: string; - /** [Config Option] (String) The type of the sprite. ... */ - type?: string; - /** [Config Option] (Number) */ - width?: number; - /** [Config Option] (Number) */ - x?: number; - /** [Config Option] (Number) */ - y?: number; - /** [Property] (Ext.dd.DragSource) If this Sprite is configured draggable, this property will contain an instance of Ext.dd.DragSource which handles dra... */ - dd?: Ext.dd.IDragSource; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Sprite, or subclass thereof. ... */ - isSprite?: boolean; - /** [Method] Adds one or more CSS classes to the element - * @param className any The CSS class to add, or an array of classes - */ - addCls?( className?:any ): any; - addCls?( className?:string ): Ext.draw.ISprite; - addCls?( className?:string[] ): Ext.draw.ISprite; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Performs custom animation on this object - * @param config Object Configuration for Ext.fx.Anim. Note that the to config is required. - */ - animate?( config?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Removes the sprite and clears all listeners */ - destroy?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the current animation if this object has any effects actively running or queued else returns false */ - getActiveAnimation?(): any; - /** [Method] Retrieves the bounding box of the sprite */ - getBBox?(): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Hides the sprite - * @param redraw Boolean Flag to immediately draw the change. - */ - hide?( redraw?:boolean ): Ext.draw.ISprite; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Redraws the sprite */ - redraw?(): Ext.draw.ISprite; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes the sprite */ - remove?(): boolean; - /** [Method] Removes one or more CSS classes from the element - * @param className any The CSS class to remove, or an array of classes. Note this method is severly limited in VML. - */ - removeCls?( className?:any ): any; - removeCls?( className?:string ): Ext.draw.ISprite; - removeCls?( className?:string[] ): Ext.draw.ISprite; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Ensures that all effects queued after sequenceFx is called on this object are run in sequence */ - sequenceFx?(): any; - /** [Method] Change the attributes of the sprite - * @param attrs Object attributes to be changed on the sprite. - * @param redraw Boolean Flag to immediately draw the change. - */ - setAttributes?( attrs?:any, redraw?:boolean ): Ext.draw.ISprite; - /** [Method] Wrapper for setting style properties also takes single object parameter of multiple styles - * @param property any The style property to be set, or an object of multiple styles. - * @param value String The value to apply to the given property, or null if an object was passed. - */ - setStyle?( property?:any, value?:string ): Ext.draw.ISprite; - /** [Method] Shows the sprite - * @param redraw Boolean Flag to immediately draw the change. - */ - show?( redraw?:boolean ): Ext.draw.ISprite; - /** [Method] Stops any running effects and clears this object s internal effects queue if it contains any additional effects that */ - stopAnimation?(): Ext.IElement; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Ensures that all effects queued after syncFx is called on this object are run concurrently */ - syncFx?(): any; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.draw { - export interface ISpriteDD extends Ext.dd.IDragSource { - /** [Method] Creates the proxy element if it does not yet exist */ - createFrame?(): void; - /** [Method] Returns a reference to the actual element to drag */ - getDragEl?(): HTMLElement; - /** [Method] Abstract method called during the onMouseMove event while dragging an object - * @param e Event the mousemove event - */ - onDrag?( e?:Event ): void; - /** [Method] Sets the drag element to the location of the mousedown or click event maintaining the cursor location relative to th - * @param iPageX Number the X coordinate of the mousedown or drag event - * @param iPageY Number the Y coordinate of the mousedown or drag event - */ - setDragElPos?( iPageX?:number, iPageY?:number ): void; - /** [Method] TODO nico Cumulative translations in VML are handled differently than in SVG - * @param x Number X click location - * @param y Number Y click location - */ - startDrag?( x?:number, y?:number ): void; - } -} -declare module Ext.draw { - export interface ISurface extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Number) */ - height?: number; - /** [Config Option] (Ext.draw.Sprite[]) */ - items?: Ext.draw.ISprite[]; - /** [Config Option] (Number) */ - width?: number; - /** [Method] Adds a Sprite to the surface - * @param args any One or more Sprite objects or configs. - */ - add?( args?:any ): any; - add?( args?:Ext.draw.ISprite[] ): any; - add?( args:Ext.draw.ISprite ): any; - /** [Method] Adds one or more CSS classes to the element - * @param sprite Object The sprite to add the class to. - * @param className String The CSS class to add, or an array of classes - */ - addCls?( sprite?:any, className?:string ): void; - addCls?( sprite?:any, className?:string[] ): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Adds a gradient definition to the Surface - * @param gradient Object A gradient config. - */ - addGradient?( gradient?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Destroys the surface */ - destroy?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns a new group or an existent group associated with the current surface - * @param id String The unique identifier of the group. - */ - getGroup?( id?:string ): any; - /** [Method] Retrieves the id of this component */ - getId?(): void; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes a given sprite from the surface optionally destroying the sprite in the process - * @param sprite Ext.draw.ISprite - * @param destroySprite Boolean - */ - remove?( sprite?:Ext.draw.ISprite, destroySprite?:boolean ): void; - /** [Method] Removes all sprites from the surface optionally destroying the sprites in the process - * @param destroySprites Boolean Whether to destroy all sprites when removing them. - */ - removeAll?( destroySprites?:boolean ): void; - /** [Method] Removes one or more CSS classes from the element - * @param sprite Object The sprite to remove the class from. - * @param className String The CSS class to remove, or an array of classes - */ - removeCls?( sprite?:any, className?:string ): void; - removeCls?( sprite?:any, className?:string[] ): void; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the size of the surface - * @param w Number The new width of the canvas. - * @param h Number The new height of the canvas. - */ - setSize?( w?:number, h?:number ): void; - /** [Method] Sets CSS style attributes to an element - * @param sprite Object The sprite to add, or an array of classes to - * @param styles Object An Object with CSS styles. - */ - setStyle?( sprite?:any, styles?:any ): void; - /** [Method] Changes the text in the sprite element - * @param sprite Object The Sprite to change the text. - * @param text String The new text to be set. - */ - setText?( sprite?:any, text?:string ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.draw { - export interface IText extends Ext.draw.IComponent { - /** [Config Option] (Boolean) Turn on autoSize support which will set the bounding div's size to the natural size of the contents. ... */ - autoSize?: boolean; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number) The angle by which to initially rotate the text clockwise. ... */ - degrees?: number; - /** [Config Option] (String) A CSS selector string which matches a style rule in the document stylesheet from which the text's font properties are... */ - styleSelector?: string; - /** [Config Option] (String) The text to display (html tags are not accepted) ... */ - text?: string; - /** [Config Option] (Boolean) Turn on view box support which will scale and position items in the draw component to fit to the component while main... */ - viewBox?: boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Sets the clockwise rotation angle relative to the horizontal axis - * @param degrees Number The clockwise angle (in degrees) from the horizontal axis by which the text should be rotated. - */ - setAngle?( degrees?:number ): void; - /** [Method] Updates this item s text - * @param t String The text to display (html not accepted). - */ - setText?( t?:string ): void; - } -} -declare module Ext { - export interface IEditor extends Ext.container.IContainer { - /** [Config Option] (String) The position to align to (see Ext.util.Positionable.alignTo for more details). ... */ - alignment?: string; - /** [Config Option] (Boolean) True to complete the editing process if in edit mode when the field is blurred. ... */ - allowBlur?: boolean; - /** [Config Option] (Boolean/Object) True for the editor to automatically adopt the size of the underlying field. ... */ - autoSize?: any; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to cancel the edit when the escape key is pressed. ... */ - cancelOnEsc?: boolean; - /** [Config Option] (Boolean) True to complete the edit when the enter key is pressed. ... */ - completeOnEnter?: boolean; - /** [Config Option] (Boolean) True to constrain the editor to the viewport ... */ - constrain?: boolean; - /** [Config Option] (Ext.form.field.Field) */ - field?: Ext.form.field.IField; - /** [Config Option] (Boolean) Do not participate in the ZIndexManager's focus switching operations. ... */ - focusOnToFront?: boolean; - /** [Config Option] (Boolean) private overrides true to hide the component. ... */ - hidden?: boolean; - /** [Config Option] (Boolean) False to keep the bound element visible while the editor is displayed ... */ - hideEl?: boolean; - /** [Config Option] (Boolean) True to skip the edit completion process (no save, no events fired) if the user completes an edit and the value has n... */ - ignoreNoChange?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) End Definitions Important: In order for child items to be correctly sized and positioned, typically a layout manager... */ - layout?: any; - /** [Config Option] (Number[]) The offsets to use when aligning (see Ext.util.Positionable.alignTo for more details. ... */ - offsets?: number[]; - /** [Config Option] (String/HTMLElement/Ext.Element) An element to render to. ... */ - parentEl?: any; - /** [Config Option] (Boolean) True to automatically revert the field value and cancel the edit when the user completes an edit and the field valida... */ - revertInvalid?: boolean; - /** [Config Option] (Boolean/String) "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop" for bottom-right shadow. ... */ - shadow?: any; - /** [Config Option] (Boolean) Handle the keydown/keypress events so they don't propagate ... */ - swallowKeys?: boolean; - /** [Config Option] (Boolean) True to update the innerHTML of the bound element when the update completes ... */ - updateEl?: boolean; - /** [Config Option] (Object) The data value of the underlying field ... */ - value?: any; - /** [Method] private Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Cancels the editing process and hides the editor without persisting any changes - * @param remainVisible Boolean Override the default behavior and keep the editor visible after cancel - */ - cancelEdit?( remainVisible?:boolean ): void; - /** [Method] Ends the editing process persists the changed value to the underlying field and hides the editor - * @param remainVisible Boolean Override the default behavior and keep the editor visible after edit - */ - completeEdit?( remainVisible?:boolean ): void; - /** [Method] Gets the data value of the editor */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] private Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Realigns the editor to the bound field based on the current alignment config value - * @param autoSize Boolean True to size the field to the dimensions of the bound element. - */ - realign?( autoSize?:boolean ): void; - /** [Method] Sets the data value of the editor - * @param value Object Any valid value supported by the underlying field - */ - setValue?( value?:any ): void; - /** [Method] Starts the editing process and shows the editor - * @param el String The element to edit - * @param value String A value to initialize the editor with. If a value is not provided, it defaults to the innerHTML of el. - */ - startEdit?( el?:string, value?:string ): void; - startEdit?( el?:HTMLElement, value?:string ): void; - startEdit?( el?:Ext.IElement, value?:string ): void; - } -} -declare module Ext { - export interface IElementLoader extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Object) */ - ajaxOptions?: any; - /** [Config Option] (Boolean/Object) True to have the loader make a request as soon as it is created. ... */ - autoLoad?: any; - /** [Config Option] (Object) Params that will be attached to every request. ... */ - baseParams?: any; - /** [Config Option] (Function) A function to be called when a load request finishes. ... */ - callback?: any; - /** [Config Option] (Function) A function to be called when a load request fails. ... */ - failure?: any; - /** [Config Option] (Boolean/String) True or a string to show when the element is loading. ... */ - loadMask?: any; - /** [Config Option] (Object) Any params to be attached to the Ajax request. ... */ - params?: any; - /** [Config Option] (Function) A custom function to render the content to the element. ... */ - renderer?: any; - /** [Config Option] (Object) */ - scope?: any; - /** [Config Option] (Boolean) True to parse any inline script tags in the response. ... */ - scripts?: boolean; - /** [Config Option] (Function) A function to be called when a load request is successful. ... */ - success?: any; - /** [Config Option] (HTMLElement/Ext.Element/String) The target element for the loader. ... */ - target?: any; - /** [Config Option] (String) */ - url?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated ElementLoader, or subclass thereof. ... */ - isLoader?: boolean; - /** [Method] Aborts the active load request */ - abort?(): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Destroys the loader */ - destroy?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the target of this loader */ - getTarget?(): Ext.IComponent; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Checks whether the loader is automatically refreshing */ - isAutoRefreshing?(): boolean; - /** [Method] Loads new data from the server - * @param options Object The options for the request. They can be any configuration option that can be specified for the class, with the exception of the target option. Note that any options passed to the method will override any class defaults. - */ - load?( options?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets an Ext Element as the target of this loader - * @param target String The element or its ID. - */ - setTarget?( target?:string ): void; - setTarget?( target?:HTMLElement ): void; - setTarget?( target?:Ext.IElement ): void; - /** [Method] Automatically refreshes the content over a specified period - * @param interval Number The interval to refresh in ms. - * @param options Object The options to pass to the load method. See load - */ - startAutoRefresh?( interval?:number, options?:any ): void; - /** [Method] Clears any auto refresh */ - stopAutoRefresh?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.enums { - export interface IFeature { - /** [Property] (String) Alias for Ext.grid.feature.AbstractSummary. ... */ - abstractsummary?: string; - /** [Property] (String) Alias for Ext.grid.feature.Feature. ... */ - feature?: string; - /** [Property] (String) Alias for Ext.grid.feature.Grouping. ... */ - grouping?: string; - /** [Property] (String) Alias for Ext.grid.feature.GroupingSummary. ... */ - groupingsummary?: string; - /** [Property] (String) Alias for Ext.grid.feature.RowBody. ... */ - rowbody?: string; - /** [Property] (String) Alias for Ext.grid.feature.Summary. ... */ - summary?: string; - } -} -declare module Ext.enums { - export interface ILayout { - /** [Property] (String) Alias for Ext.layout.container.Absolute. ... */ - absolute?: string; - /** [Property] (String) Alias for Ext.layout.container.Accordion. ... */ - accordion?: string; - /** [Property] (String) Alias for Ext.layout.container.Anchor. ... */ - anchor?: string; - /** [Property] (String) Alias for Ext.layout.container.Auto. ... */ - auto?: string; - /** [Property] (String) Alias for Ext.layout.component.Auto. ... */ - autocomponent?: string; - /** [Property] (String) Alias for Ext.layout.container.Auto. ... */ - autocontainer?: string; - /** [Property] (String) Alias for Ext.layout.container.Border. ... */ - border?: string; - /** [Property] (String) Alias for Ext.layout.container.Box. ... */ - box?: string; - /** [Property] (String) Alias for Ext.layout.container.Card. ... */ - card?: string; - /** [Property] (String) Alias for Ext.layout.container.CheckboxGroup. ... */ - checkboxgroup?: string; - /** [Property] (String) Alias for Ext.layout.container.Column. ... */ - column?: string; - /** [Property] (String) Alias for Ext.layout.container.Container. ... */ - container?: string; - /** [Property] (String) Alias for Ext.layout.container.Fit. ... */ - fit?: string; - /** [Property] (String) Alias for Ext.layout.container.Form. ... */ - form?: string; - /** [Property] (String) Alias for Ext.layout.container.HBox. ... */ - hbox?: string; - /** [Property] (String) Alias for Ext.layout.container.Table. ... */ - table?: string; - /** [Property] (String) Alias for Ext.layout.container.VBox. ... */ - vbox?: string; - } -} -declare module Ext.enums { - export interface IPlugin { - /** [Property] (String) Alias for Ext.grid.plugin.BufferedRenderer. ... */ - bufferedrenderer?: string; - /** [Property] (String) Alias for Ext.grid.plugin.CellEditing. ... */ - cellediting?: string; - /** [Property] (String) Alias for Ext.grid.plugin.HeaderResizer. ... */ - gridheaderresizer?: string; - /** [Property] (String) Alias for Ext.grid.plugin.DragDrop. ... */ - gridviewdragdrop?: string; - /** [Property] (String) Alias for Ext.grid.plugin.RowEditing. ... */ - rowediting?: string; - /** [Property] (String) Alias for Ext.grid.plugin.RowExpander. ... */ - rowexpander?: string; - /** [Property] (String) Alias for Ext.tree.plugin.TreeViewDragDrop. ... */ - treeviewdragdrop?: string; - } -} -declare module Ext.enums { - export interface IWidget { - /** [Property] (String) Alias for Ext.grid.column.Action. ... */ - actioncolumn?: string; - /** [Property] (String) Alias for Ext.grid.column.Boolean. ... */ - booleancolumn?: string; - /** [Property] (String) Alias for Ext.view.BoundList. ... */ - boundlist?: string; - /** [Property] (String) Alias for Ext.Component. ... */ - box?: string; - /** [Property] (String) Alias for Ext.button.Button. ... */ - button?: string; - /** [Property] (String) Alias for Ext.container.ButtonGroup. ... */ - buttongroup?: string; - /** [Property] (String) Alias for Ext.chart.Chart. ... */ - chart?: string; - /** [Property] (String) Alias for Ext.form.field.Checkbox. ... */ - checkbox?: string; - /** [Property] (String) Alias for Ext.form.field.Checkbox. ... */ - checkboxfield?: string; - /** [Property] (String) Alias for Ext.form.CheckboxGroup. ... */ - checkboxgroup?: string; - /** [Property] (String) Alias for Ext.grid.column.CheckColumn. ... */ - checkcolumn?: string; - /** [Property] (String) Alias for Ext.menu.ColorPicker. ... */ - colormenu?: string; - /** [Property] (String) Alias for Ext.picker.Color. ... */ - colorpicker?: string; - /** [Property] (String) Alias for Ext.form.field.ComboBox. ... */ - combo?: string; - /** [Property] (String) Alias for Ext.form.field.ComboBox. ... */ - combobox?: string; - /** [Property] (String) Alias for Ext.Component. ... */ - component?: string; - /** [Property] (String) Alias for Ext.container.Container. ... */ - container?: string; - /** [Property] (String) Alias for Ext.button.Cycle. ... */ - cycle?: string; - /** [Property] (String) Alias for Ext.view.View. ... */ - dataview?: string; - /** [Property] (String) Alias for Ext.grid.column.Date. ... */ - datecolumn?: string; - /** [Property] (String) Alias for Ext.form.field.Date. ... */ - datefield?: string; - /** [Property] (String) Alias for Ext.menu.DatePicker. ... */ - datemenu?: string; - /** [Property] (String) Alias for Ext.picker.Date. ... */ - datepicker?: string; - /** [Property] (String) Alias for Ext.form.field.Display. ... */ - displayfield?: string; - /** [Property] (String) Alias for Ext.draw.Component. ... */ - draw?: string; - /** [Property] (String) Alias for Ext.Editor. ... */ - editor?: string; - /** [Property] (String) Alias for Ext.form.field.Base. ... */ - field?: string; - /** [Property] (String) Alias for Ext.form.FieldContainer. ... */ - fieldcontainer?: string; - /** [Property] (String) Alias for Ext.form.FieldSet. ... */ - fieldset?: string; - /** [Property] (String) Alias for Ext.form.field.FileButton. ... */ - filebutton?: string; - /** [Property] (String) Alias for Ext.form.field.File. ... */ - filefield?: string; - /** [Property] (String) Alias for Ext.form.field.File. ... */ - fileuploadfield?: string; - /** [Property] (String) Alias for Ext.flash.Component. ... */ - flash?: string; - /** [Property] (String) Alias for Ext.form.Panel. ... */ - form?: string; - /** [Property] (String) Alias for Ext.grid.Panel. ... */ - grid?: string; - /** [Property] (String) Alias for Ext.grid.column.Column. ... */ - gridcolumn?: string; - /** [Property] (String) Alias for Ext.grid.Panel. ... */ - gridpanel?: string; - /** [Property] (String) Alias for Ext.grid.View. ... */ - gridview?: string; - /** [Property] (String) Alias for Ext.panel.Header. ... */ - header?: string; - /** [Property] (String) Alias for Ext.grid.header.Container. ... */ - headercontainer?: string; - /** [Property] (String) Alias for Ext.form.field.Hidden. ... */ - hidden?: string; - /** [Property] (String) Alias for Ext.form.field.Hidden. ... */ - hiddenfield?: string; - /** [Property] (String) Alias for Ext.form.field.HtmlEditor. ... */ - htmleditor?: string; - /** [Property] (String) Alias for Ext.Img. ... */ - image?: string; - /** [Property] (String) Alias for Ext.Img. ... */ - imagecomponent?: string; - /** [Property] (String) Alias for Ext.data.JsonPStore. ... */ - jsonpstore?: string; - /** [Property] (String) Alias for Ext.form.Label. ... */ - label?: string; - /** [Property] (String) Alias for Ext.LoadMask. ... */ - loadmask?: string; - /** [Property] (String) Alias for Ext.menu.Menu. ... */ - menu?: string; - /** [Property] (String) Alias for Ext.menu.CheckItem. ... */ - menucheckitem?: string; - /** [Property] (String) Alias for Ext.menu.Item. ... */ - menuitem?: string; - /** [Property] (String) Alias for Ext.menu.Separator. ... */ - menuseparator?: string; - /** [Property] (String) Alias for Ext.window.MessageBox. ... */ - messagebox?: string; - /** [Property] (String) Alias for Ext.slider.Multi. ... */ - multislider?: string; - /** [Property] (String) Alias for Ext.grid.column.Number. ... */ - numbercolumn?: string; - /** [Property] (String) Alias for Ext.form.field.Number. ... */ - numberfield?: string; - /** [Property] (String) Alias for Ext.toolbar.Paging. ... */ - pagingtoolbar?: string; - /** [Property] (String) Alias for Ext.panel.Panel. ... */ - panel?: string; - /** [Property] (String) Alias for Ext.form.field.Picker. ... */ - pickerfield?: string; - /** [Property] (String) Alias for Ext.ProgressBar. ... */ - progressbar?: string; - /** [Property] (String) Alias for Ext.grid.property.Grid. ... */ - propertygrid?: string; - /** [Property] (String) Alias for Ext.tip.QuickTip. ... */ - quicktip?: string; - /** [Property] (String) Alias for Ext.form.field.Radio. ... */ - radio?: string; - /** [Property] (String) Alias for Ext.form.field.Radio. ... */ - radiofield?: string; - /** [Property] (String) Alias for Ext.form.RadioGroup. ... */ - radiogroup?: string; - /** [Property] (String) Alias for Ext.grid.RowNumberer. ... */ - rownumberer?: string; - /** [Property] (String) Alias for Ext.slider.Single. ... */ - slider?: string; - /** [Property] (String) Alias for Ext.slider.Single. ... */ - sliderfield?: string; - /** [Property] (String) Alias for Ext.slider.Tip. ... */ - slidertip?: string; - /** [Property] (String) Alias for Ext.form.field.Spinner. ... */ - spinnerfield?: string; - /** [Property] (String) Alias for Ext.button.Split. ... */ - splitbutton?: string; - /** [Property] (String) Alias for Ext.resizer.Splitter. ... */ - splitter?: string; - /** [Property] (String) Alias for Ext.tab.Tab. ... */ - tab?: string; - /** [Property] (String) Alias for Ext.tab.Bar. ... */ - tabbar?: string; - /** [Property] (String) Alias for Ext.panel.Table. ... */ - tablepanel?: string; - /** [Property] (String) Alias for Ext.view.Table. ... */ - tableview?: string; - /** [Property] (String) Alias for Ext.tab.Panel. ... */ - tabpanel?: string; - /** [Property] (String) Alias for Ext.toolbar.Fill. ... */ - tbfill?: string; - /** [Property] (String) Alias for Ext.toolbar.Item. ... */ - tbitem?: string; - /** [Property] (String) Alias for Ext.toolbar.Separator. ... */ - tbseparator?: string; - /** [Property] (String) Alias for Ext.toolbar.Spacer. ... */ - tbspacer?: string; - /** [Property] (String) Alias for Ext.toolbar.TextItem. ... */ - tbtext?: string; - /** [Property] (String) Alias for Ext.grid.column.Template. ... */ - templatecolumn?: string; - /** [Property] (String) Alias for Ext.draw.Text. ... */ - text?: string; - /** [Property] (String) Alias for Ext.form.field.TextArea. ... */ - textarea?: string; - /** [Property] (String) Alias for Ext.form.field.TextArea. ... */ - textareafield?: string; - /** [Property] (String) Alias for Ext.form.field.Text. ... */ - textfield?: string; - /** [Property] (String) Alias for Ext.form.field.Time. ... */ - timefield?: string; - /** [Property] (String) Alias for Ext.picker.Time. ... */ - timepicker?: string; - /** [Property] (String) Alias for Ext.tip.Tip. ... */ - tip?: string; - /** [Property] (String) Alias for Ext.panel.Tool. ... */ - tool?: string; - /** [Property] (String) Alias for Ext.toolbar.Toolbar. ... */ - toolbar?: string; - /** [Property] (String) Alias for Ext.tip.ToolTip. ... */ - tooltip?: string; - /** [Property] (String) Alias for Ext.tree.Panel. ... */ - treepanel?: string; - /** [Property] (String) Alias for Ext.tree.View. ... */ - treeview?: string; - /** [Property] (String) Alias for Ext.form.field.Trigger. ... */ - trigger?: string; - /** [Property] (String) Alias for Ext.form.field.Trigger. ... */ - triggerfield?: string; - /** [Property] (String) Alias for Ext.container.Viewport. ... */ - viewport?: string; - /** [Property] (String) Alias for Ext.window.Window. ... */ - window?: string; - } -} -declare module Ext { - export interface IError { - /** [Method] Provides a custom string representation of the error object */ - toString?(): string; - } -} -declare module Ext { - export interface IEventManager { - } - export class EventManager { - /** [Method] Appends an event handler to an element - * @param el String The html element or id to assign the event handler to. - * @param eventName String The name of the event to listen for. - * @param handler Function The handler function the event invokes. - * @param scope Object The scope (this reference) in which the handler function is executed. Defaults to the Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties (See Ext.Element.addListener for examples of how to use these options.): - */ - static addListener( el?:string, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static addListener( el?:Ext.IElement, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static addListener( el?:HTMLElement, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static addListener( el?:Window, eventName?:string, handler?:any, scope?:any, options?:any ): void; - /** [Method] Get the id of the element - * @param element any The element to get the id for. - */ - static getId( element?:any ): any; - static getId( element?:HTMLElement ): string; - static getId( element?:Ext.IElement ): string; - /** [Method] Indicates which event to use for getting key presses */ - static getKeyEvent(): string; - /** [Method] Gets the x coordinate from the event - * @param event Object The event - */ - static getPageX( event?:any ): number; - /** [Method] Gets the x amp y coordinate from the event - * @param event Object The event - */ - static getPageXY( event?:any ): number[]; - /** [Method] Gets the y coordinate from the event - * @param event Object The event - */ - static getPageY( event?:any ): number; - /** [Method] Gets the related target from the event - * @param event Object The event - */ - static getRelatedTarget( event?:any ): HTMLElement; - /** [Method] Gets the target of the event - * @param event Object The event - */ - static getTarget( event?:any ): HTMLElement; - /** [Method] Appends an event handler to an element - * @param el String The html element or id to assign the event handler to. - * @param eventName String The name of the event to listen for. - * @param handler Function The handler function the event invokes. - * @param scope Object The scope (this reference) in which the handler function is executed. Defaults to the Element. - * @param options Object An object containing handler configuration properties. This may contain any of the following properties (See Ext.Element.addListener for examples of how to use these options.): - */ - static on( el?:string, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static on( el?:Ext.IElement, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static on( el?:HTMLElement, eventName?:string, handler?:any, scope?:any, options?:any ): void; - static on( el?:Window, eventName?:string, handler?:any, scope?:any, options?:any ): void; - /** [Method] Adds a listener to be notified when the document is ready before onload and before images are loaded - * @param fn Function The method the event invokes. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to the browser window. - * @param options Object Options object as passed to Ext.Element.addListener. - */ - static onDocumentReady( fn?:any, scope?:any, options?:any ): void; - /** [Method] Adds a listener to be notified when the browser window is resized and provides resize event buffering 100 millisecon - * @param fn Function The handler function the window resize event invokes. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to the browser window. - * @param options Boolean Options object as passed to Ext.Element.addListener - */ - static onWindowResize( fn?:any, scope?:any, options?:boolean ): void; - /** [Method] Adds a listener to be notified when the browser window is unloaded - * @param fn Function The handler function the window unload event invokes. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to the browser window. - * @param options Boolean Options object as passed to Ext.Element.addListener - */ - static onWindowUnload( fn?:any, scope?:any, options?:boolean ): void; - /** [Method] This strategy has minimal benefits for Sencha solutions that build themselves ie */ - static pollScroll(): void; - /** [Method] Prevents the browsers default handling of the event - * @param event Event The event to prevent the default - */ - static preventDefault( event?:Event ): void; - /** [Method] Recursively removes all previous added listeners from an element and its children - * @param el String The id or html element from which to remove all event handlers. - * @param eventName String The name of the event. - */ - static purgeElement( el?:string, eventName?:string ): void; - static purgeElement( el?:Ext.IElement, eventName?:string ): void; - static purgeElement( el?:HTMLElement, eventName?:string ): void; - static purgeElement( el?:Window, eventName?:string ): void; - /** [Method] Removes all event handers from an element - * @param el String The id or html element from which to remove all event handlers. - */ - static removeAll( el?:string ): void; - static removeAll( el?:Ext.IElement ): void; - static removeAll( el?:HTMLElement ): void; - static removeAll( el?:Window ): void; - /** [Method] Removes an event handler from an element - * @param el String The id or html element from which to remove the listener. - * @param eventName String The name of the event. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the addListener call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - static removeListener( el?:string, eventName?:string, fn?:any, scope?:any ): void; - static removeListener( el?:Ext.IElement, eventName?:string, fn?:any, scope?:any ): void; - static removeListener( el?:HTMLElement, eventName?:string, fn?:any, scope?:any ): void; - static removeListener( el?:Window, eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes the passed window resize listener - * @param fn Function The method the event invokes - * @param scope Object The scope of handler - */ - static removeResizeListener( fn?:any, scope?:any ): void; - /** [Method] Removes the passed window unload listener - * @param fn Function The method the event invokes - * @param scope Object The scope of handler - */ - static removeUnloadListener( fn?:any, scope?:any ): void; - /** [Method] Stop the event preventDefault and stopPropagation - * @param event Event The event to stop - */ - static stopEvent( event?:Event ): void; - /** [Method] Cancels bubbling of the event - * @param event Event The event to stop bubbling. - */ - static stopPropagation( event?:Event ): void; - /** [Method] Removes an event handler from an element - * @param el String The id or html element from which to remove the listener. - * @param eventName String The name of the event. - * @param fn Function The handler function to remove. This must be a reference to the function passed into the addListener call. - * @param scope Object If a scope (this reference) was specified when the listener was added, then this must refer to the same object. - */ - static un( el?:string, eventName?:string, fn?:any, scope?:any ): void; - static un( el?:Ext.IElement, eventName?:string, fn?:any, scope?:any ): void; - static un( el?:HTMLElement, eventName?:string, fn?:any, scope?:any ): void; - static un( el?:Window, eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IEventObject extends Ext.IBase { - } - export class EventObject { - /** [Method] Correctly scales a given wheel delta - * @param delta Number The delta value. - */ - static correctWheelDelta( delta?:number ): void; - /** [Method] Gets the character code for the event */ - static getCharCode(): number; - /** [Method] Returns a normalized keyCode for the event */ - static getKey(): number; - /** [Method] Returns a point object that consists of the object coordinates */ - static getPoint(): Ext.util.IPoint; - /** [Method] Gets the related target - * @param selector any A simple selector to filter the target or look for an ancestor of the target - * @param maxDepth any The max depth to search as a number or element (defaults to 10 || document.body) - * @param returnEl any True to return a Ext.Element object instead of DOM node - */ - static getRelatedTarget( selector?:any, maxDepth?:any, returnEl?:any ): any; - static getRelatedTarget( selector?:string, maxDepth?:number, returnEl?:boolean ): HTMLElement; - static getRelatedTarget( selector?:string, maxDepth?:HTMLElement, returnEl?:boolean ): HTMLElement; - /** [Method] Gets the target for the event - * @param selector any A simple selector to filter the target or look for an ancestor of the target - * @param maxDepth any The max depth to search as a number or element (defaults to 10 || document.body) - * @param returnEl any True to return a Ext.Element object instead of DOM node - */ - static getTarget( selector?:any, maxDepth?:any, returnEl?:any ): any; - static getTarget( selector?:string, maxDepth?:number, returnEl?:boolean ): HTMLElement; - static getTarget( selector?:string, maxDepth?:HTMLElement, returnEl?:boolean ): HTMLElement; - /** [Method] Normalizes mouse wheel y delta across browsers */ - static getWheelDelta(): number; - /** [Method] Returns the mouse wheel deltas for this event */ - static getWheelDeltas(): any; - /** [Method] Gets the x coordinate of the event */ - static getX(): number; - /** [Method] Gets the page coordinates of the event */ - static getXY(): number[]; - /** [Method] Gets the y coordinate of the event */ - static getY(): number; - /** [Method] Returns true if the control meta shift or alt key was pressed during this event */ - static hasModifier(): boolean; - /** [Method] Injects a DOM event using the data in this object and optionally a new target - * @param target Ext.IElement If specified, the target for the event. This is likely to be used when relaying a DOM event. If not specified, getTarget is used to determine the target. - */ - static injectEvent( target?:Ext.IElement ): void; - static injectEvent( target?:HTMLElement ): void; - /** [Method] Checks if the key pressed was a navigation key */ - static isNavKeyPress(): boolean; - /** [Method] Checks if the key pressed was a special key */ - static isSpecialKey(): boolean; - /** [Method] Prevents the browsers default handling of the event */ - static preventDefault(): void; - /** [Method] Stop the event preventDefault and stopPropagation */ - static stopEvent(): void; - /** [Method] Cancels bubbling of the event */ - static stopPropagation(): void; - /** [Method] Returns true if the target of this event is a child of el - * @param el any The id, DOM element or Ext.Element to check - * @param related any true to test if the related target is within el instead of the target - * @param allowEl any true to also check if the passed element is the target or related target - */ - static within( el?:any, related?:any, allowEl?:any ): any; - static within( el?:string, related?:boolean, allowEl?:boolean ): boolean; - static within( el?:HTMLElement, related?:boolean, allowEl?:boolean ): boolean; - static within( el?:Ext.IElement, related?:boolean, allowEl?:boolean ): boolean; - } -} -declare module Ext.flash { - export interface IComponent extends Ext.IComponent { - /** [Config Option] (String) The background color of the SWF movie. ... */ - backgroundColor?: string; - /** [Config Option] (Boolean) True to prompt the user to install flash if not installed. ... */ - expressInstall?: boolean; - /** [Config Option] (Object) */ - flashAttributes?: any; - /** [Config Option] (Object) A set of key value pairs to be passed to the flash object as parameters. ... */ - flashParams?: any; - /** [Config Option] (Object) */ - flashVars?: any; - /** [Config Option] (String) Indicates the version the flash content was published for. ... */ - flashVersion?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) Have to create a placeholder div with the swfId, which SWFObject will replace with the object/embed element. ... */ - renderTpl?: any; - /** [Config Option] (String/Number) The height of the embedded SWF movie inside the component. ... */ - swfHeight?: any; - /** [Config Option] (String/Number) The width of the embedded SWF movie inside the component. ... */ - swfWidth?: any; - /** [Config Option] (String) */ - url?: string; - /** [Config Option] (String) The wmode of the flash object. ... */ - wmode?: string; - /** [Property] (Ext.Element) A reference to the object or embed element into which the SWF file is loaded. ... */ - swf?: Ext.IElement; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Retrieves the id of the SWF object embed element */ - getSwfId?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext { - export interface IFlashComponent extends Ext.IComponent { - /** [Config Option] (String) The background color of the SWF movie. ... */ - backgroundColor?: string; - /** [Config Option] (Boolean) True to prompt the user to install flash if not installed. ... */ - expressInstall?: boolean; - /** [Config Option] (Object) */ - flashAttributes?: any; - /** [Config Option] (Object) A set of key value pairs to be passed to the flash object as parameters. ... */ - flashParams?: any; - /** [Config Option] (Object) */ - flashVars?: any; - /** [Config Option] (String) Indicates the version the flash content was published for. ... */ - flashVersion?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) Have to create a placeholder div with the swfId, which SWFObject will replace with the object/embed element. ... */ - renderTpl?: any; - /** [Config Option] (String/Number) The height of the embedded SWF movie inside the component. ... */ - swfHeight?: any; - /** [Config Option] (String/Number) The width of the embedded SWF movie inside the component. ... */ - swfWidth?: any; - /** [Config Option] (String) */ - url?: string; - /** [Config Option] (String) The wmode of the flash object. ... */ - wmode?: string; - /** [Property] (Ext.Element) A reference to the object or embed element into which the SWF file is loaded. ... */ - swf?: Ext.IElement; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Retrieves the id of the SWF object embed element */ - getSwfId?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext { - export interface IFocusManager extends Ext.IBase,Ext.util.IObservable { - } - export class FocusManager { - /** [Method] - * @param config Object - */ - constructor( config?:any ); - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds the specified xtype to the whitelist - * @param xtype String Adds the xtype(s) to the whitelist. - */ - static addXTypeToWhitelist( xtype?:string ): void; - static addXTypeToWhitelist( xtype?:string[] ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Disables the FocusManager by turning of all automatic focus management and keyboard navigation */ - static disable(): void; - /** [Method] Enables the FocusManager by turning on all automatic focus management and keyboard navigation - * @param options any Either true/false to turn on the focus frame, or an object with the following options: - */ - static enable( options?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Removes the specified xtype from the whitelist - * @param xtype String Removes the xtype(s) from the whitelist. - */ - static removeXTypeFromWhitelist( xtype?:string ): void; - static removeXTypeFromWhitelist( xtype?:string[] ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IFocusMgr extends Ext.IBase,Ext.util.IObservable { - } - export class FocusMgr { - /** [Method] - * @param config Object - */ - constructor( config?:any ); - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds the specified xtype to the whitelist - * @param xtype String Adds the xtype(s) to the whitelist. - */ - static addXTypeToWhitelist( xtype?:string ): void; - static addXTypeToWhitelist( xtype?:string[] ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Disables the FocusManager by turning of all automatic focus management and keyboard navigation */ - static disable(): void; - /** [Method] Enables the FocusManager by turning on all automatic focus management and keyboard navigation - * @param options any Either true/false to turn on the focus frame, or an object with the following options: - */ - static enable( options?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Removes the specified xtype from the whitelist - * @param xtype String Removes the xtype(s) from the whitelist. - */ - static removeXTypeFromWhitelist( xtype?:string ): void; - static removeXTypeFromWhitelist( xtype?:string[] ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.form.action { - export interface IAction extends Ext.IBase { - /** [Config Option] (Function) The function to call when a failure packet was received, or when an error ocurred in the Ajax communication. ... */ - failure?: any; - /** [Config Option] (Ext.form.Basic) The BasicForm instance that is invoking this Action. ... */ - form?: Ext.form.IBasic; - /** [Config Option] (Object) Extra headers to be sent in the AJAX request for submit and load actions. ... */ - headers?: any; - /** [Config Option] (String) The HTTP method to use to access the requested URL. ... */ - method?: string; - /** [Config Option] (Object/String) Extra parameter values to pass. ... */ - params?: any; - /** [Config Option] (Boolean) When set to true, causes the Form to be reset on Action success. ... */ - reset?: boolean; - /** [Config Option] (Object) The scope in which to call the configured success and failure callback functions (the this reference for the callback... */ - scope?: any; - /** [Config Option] (Boolean) If set to true, the emptyText value will be sent with the form when it is submitted. ... */ - submitEmptyText?: boolean; - /** [Config Option] (Function) The function to call when a valid success return packet is received. ... */ - success?: any; - /** [Config Option] (Number) The number of seconds to wait for a server response before failing with the failureType as CONNECT_FAILURE. ... */ - timeout?: number; - /** [Config Option] (String) The URL that the Action is to invoke. ... */ - url?: string; - /** [Config Option] (String) */ - waitMsg?: string; - /** [Config Option] (String) */ - waitTitle?: string; - /** [Property] (String) The type of failure detected will be one of these: CLIENT_INVALID, SERVER_INVALID, CONNECT_FAILURE, or LOAD_FAILURE. ... */ - failureType?: string; - /** [Property] (Object) */ - response?: any; - /** [Property] (Object) */ - result?: any; - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - /** [Method] Invokes this action using the current configuration */ - run?(): void; - } -} -declare module Ext.form { - export interface IAction extends Ext.IBase { - /** [Config Option] (Function) The function to call when a failure packet was received, or when an error ocurred in the Ajax communication. ... */ - failure?: any; - /** [Config Option] (Ext.form.Basic) The BasicForm instance that is invoking this Action. ... */ - form?: Ext.form.IBasic; - /** [Config Option] (Object) Extra headers to be sent in the AJAX request for submit and load actions. ... */ - headers?: any; - /** [Config Option] (String) The HTTP method to use to access the requested URL. ... */ - method?: string; - /** [Config Option] (Object/String) Extra parameter values to pass. ... */ - params?: any; - /** [Config Option] (Boolean) When set to true, causes the Form to be reset on Action success. ... */ - reset?: boolean; - /** [Config Option] (Object) The scope in which to call the configured success and failure callback functions (the this reference for the callback... */ - scope?: any; - /** [Config Option] (Boolean) If set to true, the emptyText value will be sent with the form when it is submitted. ... */ - submitEmptyText?: boolean; - /** [Config Option] (Function) The function to call when a valid success return packet is received. ... */ - success?: any; - /** [Config Option] (Number) The number of seconds to wait for a server response before failing with the failureType as CONNECT_FAILURE. ... */ - timeout?: number; - /** [Config Option] (String) The URL that the Action is to invoke. ... */ - url?: string; - /** [Config Option] (String) */ - waitMsg?: string; - /** [Config Option] (String) */ - waitTitle?: string; - /** [Property] (String) The type of failure detected will be one of these: CLIENT_INVALID, SERVER_INVALID, CONNECT_FAILURE, or LOAD_FAILURE. ... */ - failureType?: string; - /** [Property] (Object) */ - response?: any; - /** [Property] (Object) */ - result?: any; - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - /** [Method] Invokes this action using the current configuration */ - run?(): void; - } -} -declare module Ext.form.action { - export interface IDirectLoad extends Ext.form.action.ILoad { - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - } -} -declare module Ext.form.action { - export interface IDirectSubmit extends Ext.form.action.ISubmit { - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - } -} -declare module Ext.form.action { - export interface ILoad extends Ext.form.action.IAction { - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - } -} -declare module Ext.form.action { - export interface IStandardSubmit extends Ext.form.action.ISubmit { - /** [Config Option] (String) Optional target attribute to be used for the form when submitting. ... */ - target?: string; - } -} -declare module Ext.form.action { - export interface ISubmit extends Ext.form.action.IAction { - /** [Config Option] (Boolean) Determines whether a Form's fields are validated in a final call to isValid prior to submission. ... */ - clientValidation?: boolean; - /** [Property] (String) The type of action this Action instance performs. ... */ - type?: string; - /** [Method] inherit docs Invokes this action using the current configuration */ - run?(): void; - } -} -declare module Ext.form { - export interface IBasic extends Ext.util.IObservable { - /** [Config Option] (Object) If specified, load and submit actions will be handled with DirectLoad and DirectSubmit. ... */ - api?: any; - /** [Config Option] (Object) Parameters to pass with all requests. ... */ - baseParams?: any; - /** [Config Option] (Object/Ext.data.reader.Reader) An Ext.data.reader.Reader (e.g. ... */ - errorReader?: any; - /** [Config Option] (Boolean) If set to true, the field values are sent as JSON in the request body. ... */ - jsonSubmit?: boolean; - /** [Config Option] (String) */ - method?: string; - /** [Config Option] (String/String[]) A list of params to be executed server side. ... */ - paramOrder?: any; - /** [Config Option] (Boolean) Only used for the api load configuration. ... */ - paramsAsHash?: boolean; - /** [Config Option] (Object/Ext.data.reader.Reader) An Ext.data.reader.Reader (e.g. ... */ - reader?: any; - /** [Config Option] (Boolean) If set to true, a standard HTML form submit is used instead of a XHR (Ajax) style form submission. ... */ - standardSubmit?: boolean; - /** [Config Option] (Number) Timeout for form actions in seconds. ... */ - timeout?: number; - /** [Config Option] (Boolean) If set to true, reset() resets to the last loaded or setValues() data instead of when the form was first created. ... */ - trackResetOnLoad?: boolean; - /** [Config Option] (String) */ - url?: string; - /** [Config Option] (String/HTMLElement/Ext.Element) By default wait messages are displayed with Ext.MessageBox.wait. ... */ - waitMsgTarget?: any; - /** [Config Option] (String) The default title to show for the waiting message box ... */ - waitTitle?: string; - /** [Property] (Ext.container.Container) */ - owner?: Ext.container.IContainer; - /** [Method] Calls Ext applyIf for all field in this form with the passed object - * @param obj Object The object to be applied - */ - applyIfToFields?( obj?:any ): Ext.form.IBasic; - /** [Method] Calls Ext apply for all fields in this form with the passed object - * @param obj Object The object to be applied - */ - applyToFields?( obj?:any ): Ext.form.IBasic; - /** [Method] Check whether the dirty state of the entire form has changed since it was last checked and if so fire the dirtychang */ - checkDirty?(): void; - /** [Method] Check whether the validity of the entire form has changed since it was last checked and if so fire the validitychang */ - checkValidity?(): void; - /** [Method] Clears all invalid field messages in this form */ - clearInvalid?(): Ext.form.IBasic; - /** [Method] Destroys this object */ - destroy?(): void; - /** [Method] Performs a predefined action an implementation of Ext form action Action to perform application specific processing - * @param action any The name of the predefined action type, or instance of Ext.form.action.Action to perform. - * @param options any The options to pass to the Ext.form.action.Action that will get created, if the action argument is a String. All of the config options listed below are supported by both the submit and load actions unless otherwise noted (custom actions could also accept other config options): - */ - doAction?( action?:any, options?:any ): any; - doAction?( action?:string, options?:any ): Ext.form.IBasic; - doAction?( action?:Ext.form.action.IAction, options?:any ): Ext.form.IBasic; - /** [Method] Find a specific Ext form field Field in this form by id or name - * @param id String The value to search for (specify either a id or name or hiddenName). - */ - findField?( id?:string ): any; - /** [Method] Retrieves the fields in the form as a set of key value pairs using their getModelData method to collect the values - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - */ - getFieldValues?( dirtyOnly?:boolean ): any; - /** [Method] Return all the Ext form field Field components in the owner container */ - getFields?(): Ext.util.IMixedCollection; - /** [Method] Returns the last Ext data Model instance that was loaded via loadRecord */ - getRecord?(): Ext.data.IModel; - /** [Method] Retrieves the fields in the form as a set of key value pairs using their getSubmitData method to collect the values - * @param asString Boolean If true, will return the key/value collection as a single URL-encoded param string. - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - * @param includeEmptyText Boolean If true, the configured emptyText of empty fields will be used. - * @param useDataValues Boolean If true, the getModelData method is used to retrieve values from fields, otherwise the getSubmitData method is used. - */ - getValues?( asString?:boolean, dirtyOnly?:boolean, includeEmptyText?:boolean, useDataValues?:boolean ): any; - /** [Method] Returns true if the form contains any invalid fields */ - hasInvalidField?(): void; - /** [Method] Returns true if the form contains a file upload field */ - hasUpload?(): boolean; - /** [Method] Returns true if any fields in this form have changed from their original values */ - isDirty?(): boolean; - /** [Method] Returns true if client side validation on the form is successful */ - isValid?(): boolean; - /** [Method] Shortcut to do a load action - * @param options Object The options to pass to the action (see doAction for details) - */ - load?( options?:any ): Ext.form.IBasic; - /** [Method] Loads an Ext data Model into this form by calling setValues with the record data - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Mark fields in this form invalid in bulk - * @param errors any Either an array in the form [{id:'fieldId', msg:'The message'}, ...], an object hash of {id: msg, id2: msg2}, or a Ext.data.Errors object. - */ - markInvalid?( errors?:any ): Ext.form.IBasic; - /** [Method] Resets all fields in this form - * @param resetRecord Boolean True to unbind any record set by loadRecord - */ - reset?( resetRecord?:boolean ): Ext.form.IBasic; - /** [Method] Set values for fields in this form in bulk - * @param values any Either an array in the form: [{id:'clientName', value:'Fred. Olsen Lines'}, {id:'portOfLoading', value:'FXT'}, {id:'portOfDischarge', value:'OSL'} ] or an object hash of the form: { clientName: 'Fred. Olsen Lines', portOfLoading: 'FXT', portOfDischarge: 'OSL' } - */ - setValues?( values?:any ): Ext.form.IBasic; - /** [Method] Shortcut to do a submit action - * @param options Object The options to pass to the action (see doAction for details). - */ - submit?( options?:any ): Ext.form.IBasic; - /** [Method] Persists the values in this form into the passed Ext data Model object in a beginEdit endEdit block - * @param record Ext.data.IModel The record to edit - */ - updateRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - } -} -declare module Ext.form { - export interface IBasicForm extends Ext.util.IObservable { - /** [Config Option] (Object) If specified, load and submit actions will be handled with DirectLoad and DirectSubmit. ... */ - api?: any; - /** [Config Option] (Object) Parameters to pass with all requests. ... */ - baseParams?: any; - /** [Config Option] (Object/Ext.data.reader.Reader) An Ext.data.reader.Reader (e.g. ... */ - errorReader?: any; - /** [Config Option] (Boolean) If set to true, the field values are sent as JSON in the request body. ... */ - jsonSubmit?: boolean; - /** [Config Option] (String) */ - method?: string; - /** [Config Option] (String/String[]) A list of params to be executed server side. ... */ - paramOrder?: any; - /** [Config Option] (Boolean) Only used for the api load configuration. ... */ - paramsAsHash?: boolean; - /** [Config Option] (Object/Ext.data.reader.Reader) An Ext.data.reader.Reader (e.g. ... */ - reader?: any; - /** [Config Option] (Boolean) If set to true, a standard HTML form submit is used instead of a XHR (Ajax) style form submission. ... */ - standardSubmit?: boolean; - /** [Config Option] (Number) Timeout for form actions in seconds. ... */ - timeout?: number; - /** [Config Option] (Boolean) If set to true, reset() resets to the last loaded or setValues() data instead of when the form was first created. ... */ - trackResetOnLoad?: boolean; - /** [Config Option] (String) */ - url?: string; - /** [Config Option] (String/HTMLElement/Ext.Element) By default wait messages are displayed with Ext.MessageBox.wait. ... */ - waitMsgTarget?: any; - /** [Config Option] (String) The default title to show for the waiting message box ... */ - waitTitle?: string; - /** [Property] (Ext.container.Container) */ - owner?: Ext.container.IContainer; - /** [Method] Calls Ext applyIf for all field in this form with the passed object - * @param obj Object The object to be applied - */ - applyIfToFields?( obj?:any ): Ext.form.IBasic; - /** [Method] Calls Ext apply for all fields in this form with the passed object - * @param obj Object The object to be applied - */ - applyToFields?( obj?:any ): Ext.form.IBasic; - /** [Method] Check whether the dirty state of the entire form has changed since it was last checked and if so fire the dirtychang */ - checkDirty?(): void; - /** [Method] Check whether the validity of the entire form has changed since it was last checked and if so fire the validitychang */ - checkValidity?(): void; - /** [Method] Clears all invalid field messages in this form */ - clearInvalid?(): Ext.form.IBasic; - /** [Method] Destroys this object */ - destroy?(): void; - /** [Method] Performs a predefined action an implementation of Ext form action Action to perform application specific processing - * @param action any The name of the predefined action type, or instance of Ext.form.action.Action to perform. - * @param options any The options to pass to the Ext.form.action.Action that will get created, if the action argument is a String. All of the config options listed below are supported by both the submit and load actions unless otherwise noted (custom actions could also accept other config options): - */ - doAction?( action?:any, options?:any ): any; - doAction?( action?:string, options?:any ): Ext.form.IBasic; - doAction?( action?:Ext.form.action.IAction, options?:any ): Ext.form.IBasic; - /** [Method] Find a specific Ext form field Field in this form by id or name - * @param id String The value to search for (specify either a id or name or hiddenName). - */ - findField?( id?:string ): any; - /** [Method] Retrieves the fields in the form as a set of key value pairs using their getModelData method to collect the values - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - */ - getFieldValues?( dirtyOnly?:boolean ): any; - /** [Method] Return all the Ext form field Field components in the owner container */ - getFields?(): Ext.util.IMixedCollection; - /** [Method] Returns the last Ext data Model instance that was loaded via loadRecord */ - getRecord?(): Ext.data.IModel; - /** [Method] Retrieves the fields in the form as a set of key value pairs using their getSubmitData method to collect the values - * @param asString Boolean If true, will return the key/value collection as a single URL-encoded param string. - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - * @param includeEmptyText Boolean If true, the configured emptyText of empty fields will be used. - * @param useDataValues Boolean If true, the getModelData method is used to retrieve values from fields, otherwise the getSubmitData method is used. - */ - getValues?( asString?:boolean, dirtyOnly?:boolean, includeEmptyText?:boolean, useDataValues?:boolean ): any; - /** [Method] Returns true if the form contains any invalid fields */ - hasInvalidField?(): void; - /** [Method] Returns true if the form contains a file upload field */ - hasUpload?(): boolean; - /** [Method] Returns true if any fields in this form have changed from their original values */ - isDirty?(): boolean; - /** [Method] Returns true if client side validation on the form is successful */ - isValid?(): boolean; - /** [Method] Shortcut to do a load action - * @param options Object The options to pass to the action (see doAction for details) - */ - load?( options?:any ): Ext.form.IBasic; - /** [Method] Loads an Ext data Model into this form by calling setValues with the record data - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Mark fields in this form invalid in bulk - * @param errors any Either an array in the form [{id:'fieldId', msg:'The message'}, ...], an object hash of {id: msg, id2: msg2}, or a Ext.data.Errors object. - */ - markInvalid?( errors?:any ): Ext.form.IBasic; - /** [Method] Resets all fields in this form - * @param resetRecord Boolean True to unbind any record set by loadRecord - */ - reset?( resetRecord?:boolean ): Ext.form.IBasic; - /** [Method] Set values for fields in this form in bulk - * @param values any Either an array in the form: [{id:'clientName', value:'Fred. Olsen Lines'}, {id:'portOfLoading', value:'FXT'}, {id:'portOfDischarge', value:'OSL'} ] or an object hash of the form: { clientName: 'Fred. Olsen Lines', portOfLoading: 'FXT', portOfDischarge: 'OSL' } - */ - setValues?( values?:any ): Ext.form.IBasic; - /** [Method] Shortcut to do a submit action - * @param options Object The options to pass to the action (see doAction for details). - */ - submit?( options?:any ): Ext.form.IBasic; - /** [Method] Persists the values in this form into the passed Ext data Model object in a beginEdit endEdit block - * @param record Ext.data.IModel The record to edit - */ - updateRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - } -} -declare module Ext.form { - export interface ICheckboxGroup extends Ext.form.IFieldContainer,Ext.form.field.IField { - /** [Config Option] (Boolean) False to validate that at least one item in the group is checked. ... */ - allowBlank?: boolean; - /** [Config Option] (String) Error text to display if the allowBlank validation fails ... */ - blankText?: string; - /** [Config Option] (String/Number/Number[]) Specifies the number of columns to use when displaying grouped checkbox/radio controls using automatic layout. ... */ - columns?: any; - /** [Config Option] (String) CSS Class to be added to a components root level element to give distinction to it via styling. ... */ - componentCls?: string; - /** [Config Option] (String) private The default xtype of child Components to create in this Container when a child item is specified as a raw co... */ - defaultType?: string; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (Ext.form.field.Checkbox[]/Object[]) */ - items?: any; - /** [Config Option] (Ext.enums.Layout/Object) private Important: In order for child items to be correctly sized and positioned, typically a layout manager must be... */ - layout?: any; - /** [Config Option] (Boolean) True to distribute contained controls across columns, completely filling each column top to bottom before starting on... */ - vertical?: boolean; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Returns an Array of all checkboxes in the container which are currently checked */ - getChecked?(): Ext.form.field.ICheckbox[]; - /** [Method] Runs CheckboxGroup s validations and returns an array of any errors */ - getErrors?(): string[]; - /** [Method] Don t return any data for the model the form will get the info from the individual checkboxes themselves */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Don t return any data for submit the form will get the info from the individual checkboxes themselves */ - getSubmitData?(): any; - /** [Method] Returns an object containing the values of all checked checkboxes within the group */ - getValue?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] private override Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] private override the group value is a complex object compare using object serialization Returns whether two field - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value */ - isValid?(): boolean; - /** [Method] Associate one or more error messages with this field - * @param errors String The error message(s) for the field. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] When a checkbox is added to the group monitor it for changes - * @param field Object - */ - onAdd?( field?:any ): void; - /** [Method] Called when a Ext form Labelable instance is removed from the container s subtree - * @param labelable Ext.form.ILabelable The instance that was removed - */ - onRemove?( labelable?:Ext.form.ILabelable ): void; - /** [Method] Resets the checked state of all checkboxes in the group to their originally loaded values and clears any validation m */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the value s of all checkboxes in the group - * @param value Object The mapping of checkbox names to values. - */ - setValue?( value?:any ): Ext.form.ICheckboxGroup; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - } -} -declare module Ext.form { - export interface ICheckboxManager extends Ext.util.IMixedCollection { - } - export class CheckboxManager { - } -} -declare module Ext.form.field { - export interface IBase extends Ext.IComponent,Ext.form.ILabelable,Ext.form.field.IField { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number) Defines a timeout in milliseconds for buffering checkChangeEvents that fire in rapid succession. ... */ - checkChangeBuffer?: number; - /** [Config Option] (String[]) A list of event names that will be listened for on the field's input element, which will cause the field's value to b... */ - checkChangeEvents?: string[]; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The CSS class to use when the field value is dirty. ... */ - dirtyCls?: string; - /** [Config Option] (String) The default CSS class for the field input ... */ - fieldCls?: string; - /** [Config Option] (String) Optional CSS style(s) to be applied to the field input element. ... */ - fieldStyle?: string; - /** [Config Option] (String) The CSS class to use when the field receives focus ... */ - focusCls?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the input element (as attributes). ... */ - inputAttrTpl?: any; - /** [Config Option] (String) The id that will be given to the generated input DOM element. ... */ - inputId?: string; - /** [Config Option] (String) The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Config Option] (String) The error text to use when marking a field invalid and no message is provided ... */ - invalidText?: string; - /** [Config Option] (String) The name of the field. ... */ - name?: string; - /** [Config Option] (Boolean) true to mark the field as readOnly in HTML. ... */ - readOnly?: boolean; - /** [Config Option] (String) The CSS class applied to the component's main element when it is readOnly. ... */ - readOnlyCls?: string; - /** [Config Option] (Number) The tabIndex for this field. ... */ - tabIndex?: number; - /** [Config Option] (Boolean) Whether the field should validate when it loses focus. ... */ - validateOnBlur?: boolean; - /** [Property] (Ext.Element) The input Element for this Field. ... */ - inputEl?: Ext.IElement; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] This method needs to be called whenever you change something on this component that requires the Component s layout t */ - doComponentLayout?(): Ext.container.IContainer; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the active error message for this component if any */ - getActiveError?(): string; - /** [Method] Gets an Array of any active error messages currently applied to the field */ - getActiveErrors?(): string[]; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the label for the field */ - getFieldLabel?(): string; - /** [Method] Returns the input id for this field */ - getInputId?(): any; - /** [Method] Gets the width of the label if visible */ - getLabelWidth?(): number; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): any; - /** [Method] private override to use getSubmitValue as a convenience Returns the parameter s that would be included in a stand */ - getSubmitData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Tells whether the field currently has an active error message */ - hasActiveError?(): boolean; - /** [Method] Checks if the field has a visible label */ - hasVisibleLabel?(): boolean; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Performs initialization of this mixin */ - initLabelable?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Display one or more error messages associated with this field using msgTarget to determine how to display the messag - * @param errors String The validation message(s) to display. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Performs any necessary manipulation of a raw field value to prepare it for conversion and or validation for instance - * @param value Object The unprocessed string value - */ - processRawValue?( value?:any ): any; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the active error message to the given string - * @param msg String The error message - */ - setActiveError?( msg?:string ): void; - /** [Method] Set the active error message to an Array of error messages - * @param errors String[] The error messages - */ - setActiveErrors?( errors?:string[] ): void; - /** [Method] Applies a set of default configuration values to this Labelable instance - * @param defaults Object The defaults to apply to the object. - */ - setFieldDefaults?( defaults?:any ): void; - /** [Method] Set the label of this field - * @param label String The new label. The labelSeparator will be automatically appended to the label string. - */ - setFieldLabel?( label?:string ): void; - /** [Method] Set the CSS style of the field input element - * @param style any The style(s) to apply. Should be a valid argument to Ext.Element.applyStyles. - */ - setFieldStyle?( style?:any ): void; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Transform the raw value before it is set - * @param value Object The value - */ - transformRawValue?( value?:any ): any; - /** [Method] Returns the trimmed label by slicing off the label separator character */ - trimLabelSeparator?(): string; - /** [Method] Clears the active error message s */ - unsetActiveError?(): void; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - /** [Method] Uses getErrors to build an array of validation errors - * @param value Object The value to validate - */ - validateValue?( value?:any ): boolean; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface IBaseField extends Ext.IComponent,Ext.form.ILabelable,Ext.form.field.IField { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number) Defines a timeout in milliseconds for buffering checkChangeEvents that fire in rapid succession. ... */ - checkChangeBuffer?: number; - /** [Config Option] (String[]) A list of event names that will be listened for on the field's input element, which will cause the field's value to b... */ - checkChangeEvents?: string[]; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The CSS class to use when the field value is dirty. ... */ - dirtyCls?: string; - /** [Config Option] (String) The default CSS class for the field input ... */ - fieldCls?: string; - /** [Config Option] (String) Optional CSS style(s) to be applied to the field input element. ... */ - fieldStyle?: string; - /** [Config Option] (String) The CSS class to use when the field receives focus ... */ - focusCls?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the input element (as attributes). ... */ - inputAttrTpl?: any; - /** [Config Option] (String) The id that will be given to the generated input DOM element. ... */ - inputId?: string; - /** [Config Option] (String) The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Config Option] (String) The error text to use when marking a field invalid and no message is provided ... */ - invalidText?: string; - /** [Config Option] (String) The name of the field. ... */ - name?: string; - /** [Config Option] (Boolean) true to mark the field as readOnly in HTML. ... */ - readOnly?: boolean; - /** [Config Option] (String) The CSS class applied to the component's main element when it is readOnly. ... */ - readOnlyCls?: string; - /** [Config Option] (Number) The tabIndex for this field. ... */ - tabIndex?: number; - /** [Config Option] (Boolean) Whether the field should validate when it loses focus. ... */ - validateOnBlur?: boolean; - /** [Property] (Ext.Element) The input Element for this Field. ... */ - inputEl?: Ext.IElement; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] This method needs to be called whenever you change something on this component that requires the Component s layout t */ - doComponentLayout?(): Ext.container.IContainer; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the active error message for this component if any */ - getActiveError?(): string; - /** [Method] Gets an Array of any active error messages currently applied to the field */ - getActiveErrors?(): string[]; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the label for the field */ - getFieldLabel?(): string; - /** [Method] Returns the input id for this field */ - getInputId?(): void; - /** [Method] Gets the width of the label if visible */ - getLabelWidth?(): number; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] private override to use getSubmitValue as a convenience Returns the parameter s that would be included in a stand */ - getSubmitData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Tells whether the field currently has an active error message */ - hasActiveError?(): boolean; - /** [Method] Checks if the field has a visible label */ - hasVisibleLabel?(): boolean; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Performs initialization of this mixin */ - initLabelable?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Display one or more error messages associated with this field using msgTarget to determine how to display the messag - * @param errors String The validation message(s) to display. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Performs any necessary manipulation of a raw field value to prepare it for conversion and or validation for instance - * @param value Object The unprocessed string value - */ - processRawValue?( value?:any ): any; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the active error message to the given string - * @param msg String The error message - */ - setActiveError?( msg?:string ): void; - /** [Method] Set the active error message to an Array of error messages - * @param errors String[] The error messages - */ - setActiveErrors?( errors?:string[] ): void; - /** [Method] Applies a set of default configuration values to this Labelable instance - * @param defaults Object The defaults to apply to the object. - */ - setFieldDefaults?( defaults?:any ): void; - /** [Method] Set the label of this field - * @param label String The new label. The labelSeparator will be automatically appended to the label string. - */ - setFieldLabel?( label?:string ): void; - /** [Method] Set the CSS style of the field input element - * @param style any The style(s) to apply. Should be a valid argument to Ext.Element.applyStyles. - */ - setFieldStyle?( style?:any ): void; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Transform the raw value before it is set - * @param value Object The value - */ - transformRawValue?( value?:any ): any; - /** [Method] Returns the trimmed label by slicing off the label separator character */ - trimLabelSeparator?(): string; - /** [Method] Clears the active error message s */ - unsetActiveError?(): void; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - /** [Method] Uses getErrors to build an array of validation errors - * @param value Object The value to validate - */ - validateValue?( value?:any ): boolean; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface IField extends Ext.IComponent,Ext.form.ILabelable,Ext.form.field.IField { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number) Defines a timeout in milliseconds for buffering checkChangeEvents that fire in rapid succession. ... */ - checkChangeBuffer?: number; - /** [Config Option] (String[]) A list of event names that will be listened for on the field's input element, which will cause the field's value to b... */ - checkChangeEvents?: string[]; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The CSS class to use when the field value is dirty. ... */ - dirtyCls?: string; - /** [Config Option] (String) The default CSS class for the field input ... */ - fieldCls?: string; - /** [Config Option] (String) Optional CSS style(s) to be applied to the field input element. ... */ - fieldStyle?: string; - /** [Config Option] (String) The CSS class to use when the field receives focus ... */ - focusCls?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the input element (as attributes). ... */ - inputAttrTpl?: any; - /** [Config Option] (String) The id that will be given to the generated input DOM element. ... */ - inputId?: string; - /** [Config Option] (String) The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Config Option] (String) The error text to use when marking a field invalid and no message is provided ... */ - invalidText?: string; - /** [Config Option] (String) The name of the field. ... */ - name?: string; - /** [Config Option] (Boolean) true to mark the field as readOnly in HTML. ... */ - readOnly?: boolean; - /** [Config Option] (String) The CSS class applied to the component's main element when it is readOnly. ... */ - readOnlyCls?: string; - /** [Config Option] (Number) The tabIndex for this field. ... */ - tabIndex?: number; - /** [Config Option] (Boolean) Whether the field should validate when it loses focus. ... */ - validateOnBlur?: boolean; - /** [Property] (Ext.Element) The input Element for this Field. ... */ - inputEl?: Ext.IElement; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] This method needs to be called whenever you change something on this component that requires the Component s layout t */ - doComponentLayout?(): Ext.container.IContainer; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the active error message for this component if any */ - getActiveError?(): string; - /** [Method] Gets an Array of any active error messages currently applied to the field */ - getActiveErrors?(): string[]; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the label for the field */ - getFieldLabel?(): string; - /** [Method] Returns the input id for this field */ - getInputId?(): void; - /** [Method] Gets the width of the label if visible */ - getLabelWidth?(): number; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] private override to use getSubmitValue as a convenience Returns the parameter s that would be included in a stand */ - getSubmitData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Tells whether the field currently has an active error message */ - hasActiveError?(): boolean; - /** [Method] Checks if the field has a visible label */ - hasVisibleLabel?(): boolean; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Performs initialization of this mixin */ - initLabelable?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Display one or more error messages associated with this field using msgTarget to determine how to display the messag - * @param errors String The validation message(s) to display. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Performs any necessary manipulation of a raw field value to prepare it for conversion and or validation for instance - * @param value Object The unprocessed string value - */ - processRawValue?( value?:any ): any; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the active error message to the given string - * @param msg String The error message - */ - setActiveError?( msg?:string ): void; - /** [Method] Set the active error message to an Array of error messages - * @param errors String[] The error messages - */ - setActiveErrors?( errors?:string[] ): void; - /** [Method] Applies a set of default configuration values to this Labelable instance - * @param defaults Object The defaults to apply to the object. - */ - setFieldDefaults?( defaults?:any ): void; - /** [Method] Set the label of this field - * @param label String The new label. The labelSeparator will be automatically appended to the label string. - */ - setFieldLabel?( label?:string ): void; - /** [Method] Set the CSS style of the field input element - * @param style any The style(s) to apply. Should be a valid argument to Ext.Element.applyStyles. - */ - setFieldStyle?( style?:any ): void; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Transform the raw value before it is set - * @param value Object The value - */ - transformRawValue?( value?:any ): any; - /** [Method] Returns the trimmed label by slicing off the label separator character */ - trimLabelSeparator?(): string; - /** [Method] Clears the active error message s */ - unsetActiveError?(): void; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - /** [Method] Uses getErrors to build an array of validation errors - * @param value Object The value to validate - */ - validateValue?( value?:any ): boolean; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface ICheckbox extends Ext.form.field.IBase { - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the box label text. ... */ - afterBoxLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the box label element. ... */ - afterBoxLabelTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the box label text. ... */ - beforeBoxLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the box label element. ... */ - beforeBoxLabelTpl?: any; - /** [Config Option] (String) An optional text label that will appear next to the checkbox. ... */ - boxLabel?: string; - /** [Config Option] (String) The position relative to the checkbox where the boxLabel should appear. ... */ - boxLabelAlign?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the box label element (as attribut... */ - boxLabelAttrTpl?: any; - /** [Config Option] (String) The CSS class to be applied to the boxLabel element ... */ - boxLabelCls?: string; - /** [Config Option] (String[]) private overrides A list of event names that will be listened for on the field's input element, which will cause the... */ - checkChangeEvents?: string[]; - /** [Config Option] (Boolean) true if the checkbox should render initially checked ... */ - checked?: boolean; - /** [Config Option] (String) The CSS class(es) added to the component's main element when it is in the checked state. ... */ - checkedCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to fieldBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (String) The default CSS class for the checkbox ... */ - fieldCls?: string; - /** [Config Option] (String) The CSS class to use when the checkbox receives focus ... */ - focusCls?: string; - /** [Config Option] (Function) A function called when the checked value changes (can be used instead of handling the change event). ... */ - handler?: any; - /** [Config Option] (String) The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Config Option] (String) The value that should go into the generated input element's value attribute and should be used as the parameter value... */ - inputValue?: string; - /** [Config Option] (Object) An object to use as the scope ('this' reference) of the handler function. ... */ - scope?: any; - /** [Config Option] (String) If configured, this will be submitted as the checkbox's value during form submit if the checkbox is unchecked. ... */ - uncheckedValue?: string; - /** [Property] (Ext.Element) A reference to the label element created for the boxLabel. ... */ - boxLabelEl?: Ext.IElement; - /** [Property] (Object) The original value of the field as configured in the checked configuration, or as loaded by the last form load operat... */ - originalValue?: any; - /** [Method] inherit docs Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Returns the checked state of the checkbox */ - getRawValue?(): boolean; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the submit value for the checkbox which can be used when submitting forms */ - getSubmitValue?(): string; - /** [Method] Returns the checked state of the checkbox */ - getValue?(): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the boxLabel for this checkbox - * @param boxLabel String The new label - */ - setBoxLabel?( boxLabel?:string ): void; - /** [Method] Sets the checked state of the checkbox - * @param value any The following values will check the checkbox: true, 'true', '1', 1, or 'on', as well as a String that matches the inputValue. Any other value will uncheck the checkbox. - */ - setRawValue?( value?:any ): any; - setRawValue?( value?:boolean ): boolean; - setRawValue?( value?:string ): boolean; - setRawValue?( value?:number ): boolean; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets the checked state of the checkbox and invokes change detection - * @param checked any The following values will check the checkbox: true, 'true', '1', or 'on', as well as a String that matches the inputValue. Any other value will uncheck the checkbox. - */ - setValue?( checked?:any ): any; - setValue?( checked?:boolean ): Ext.form.field.ICheckbox; - setValue?( checked?:string ): Ext.form.field.ICheckbox; - /** [Method] private Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface ICheckbox extends Ext.form.field.IBase { - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the box label text. ... */ - afterBoxLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the box label element. ... */ - afterBoxLabelTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the box label text. ... */ - beforeBoxLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the box label element. ... */ - beforeBoxLabelTpl?: any; - /** [Config Option] (String) An optional text label that will appear next to the checkbox. ... */ - boxLabel?: string; - /** [Config Option] (String) The position relative to the checkbox where the boxLabel should appear. ... */ - boxLabelAlign?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the box label element (as attribut... */ - boxLabelAttrTpl?: any; - /** [Config Option] (String) The CSS class to be applied to the boxLabel element ... */ - boxLabelCls?: string; - /** [Config Option] (String[]) private overrides A list of event names that will be listened for on the field's input element, which will cause the... */ - checkChangeEvents?: string[]; - /** [Config Option] (Boolean) true if the checkbox should render initially checked ... */ - checked?: boolean; - /** [Config Option] (String) The CSS class(es) added to the component's main element when it is in the checked state. ... */ - checkedCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to fieldBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (String) The default CSS class for the checkbox ... */ - fieldCls?: string; - /** [Config Option] (String) The CSS class to use when the checkbox receives focus ... */ - focusCls?: string; - /** [Config Option] (Function) A function called when the checked value changes (can be used instead of handling the change event). ... */ - handler?: any; - /** [Config Option] (String) The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Config Option] (String) The value that should go into the generated input element's value attribute and should be used as the parameter value... */ - inputValue?: string; - /** [Config Option] (Object) An object to use as the scope ('this' reference) of the handler function. ... */ - scope?: any; - /** [Config Option] (String) If configured, this will be submitted as the checkbox's value during form submit if the checkbox is unchecked. ... */ - uncheckedValue?: string; - /** [Property] (Ext.Element) A reference to the label element created for the boxLabel. ... */ - boxLabelEl?: Ext.IElement; - /** [Property] (Object) The original value of the field as configured in the checked configuration, or as loaded by the last form load operat... */ - originalValue?: any; - /** [Method] inherit docs Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Returns the checked state of the checkbox */ - getRawValue?(): boolean; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the submit value for the checkbox which can be used when submitting forms */ - getSubmitValue?(): string; - /** [Method] Returns the checked state of the checkbox */ - getValue?(): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the boxLabel for this checkbox - * @param boxLabel String The new label - */ - setBoxLabel?( boxLabel?:string ): void; - /** [Method] Sets the checked state of the checkbox - * @param value any The following values will check the checkbox: true, 'true', '1', 1, or 'on', as well as a String that matches the inputValue. Any other value will uncheck the checkbox. - */ - setRawValue?( value?:any ): any; - setRawValue?( value?:boolean ): boolean; - setRawValue?( value?:string ): boolean; - setRawValue?( value?:number ): boolean; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets the checked state of the checkbox and invokes change detection - * @param checked any The following values will check the checkbox: true, 'true', '1', or 'on', as well as a String that matches the inputValue. Any other value will uncheck the checkbox. - */ - setValue?( checked?:any ): any; - setValue?( checked?:boolean ): Ext.form.field.ICheckbox; - setValue?( checked?:string ): Ext.form.field.ICheckbox; - /** [Method] private Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface IComboBox extends Ext.form.field.IPicker,Ext.util.IBindable { - /** [Config Option] (String) The text query to send to the server to return all records for the list with no filtering ... */ - allQuery?: string; - /** [Config Option] (Boolean) true to automatically highlight the first result gathered by the data store in the dropdown list when it is opened. ... */ - autoSelect?: boolean; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Object) Set of options that will be used as defaults for the user-configured listConfig object. ... */ - defaultListConfig?: any; - /** [Config Option] (String) The character(s) used to separate the display values of multiple selected items when multiSelect = true. ... */ - delimiter?: string; - /** [Config Option] (String) The underlying data field name to bind to this ComboBox. ... */ - displayField?: string; - /** [Config Option] (Boolean) When queryMode is 'local' only Set to true to have the ComboBox use the typed value as a RegExp source to filter the... */ - enableRegEx?: boolean; - /** [Config Option] (Ext.XTemplate) The content of the field body is defined by this config option. ... */ - fieldSubTpl?: Ext.IXTemplate; - /** [Config Option] (Boolean) true to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text i... */ - forceSelection?: boolean; - /** [Config Option] (Boolean) false to not allow the component to resize itself when its data changes (and its grow property is true) ... */ - growToLongestValue?: boolean; - /** [Config Option] (String) The name of an underlying hidden field which will be synchronized with the underlying value of the combo. ... */ - hiddenName?: string; - /** [Config Option] (Object) An optional set of configuration properties that will be passed to the Ext.view.BoundList's constructor. ... */ - listConfig?: any; - /** [Config Option] (Number) The minimum number of characters the user must type before autocomplete and typeAhead activate. ... */ - minChars?: number; - /** [Config Option] (Boolean) If set to true, allows the combo field to hold more than one value at a time, and allows selecting multiple items fro... */ - multiSelect?: boolean; - /** [Config Option] (Number) If greater than 0, a Ext.toolbar.Paging is displayed in the footer of the dropdown list and the filter queries will e... */ - pageSize?: number; - /** [Config Option] (Boolean) When true, this prevents the combo from re-querying (either locally or remotely) when the current query is the same a... */ - queryCaching?: boolean; - /** [Config Option] (Number) The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown ... */ - queryDelay?: number; - /** [Config Option] (String) The mode in which the ComboBox uses the configured Store. ... */ - queryMode?: string; - /** [Config Option] (String) Name of the parameter used by the Store to pass the typed string when the ComboBox is configured with queryMode: 'rem... */ - queryParam?: string; - /** [Config Option] (Boolean) Whether the Tab key should select the currently highlighted item. ... */ - selectOnTab?: boolean; - /** [Config Option] (Ext.data.Store/String/Array) The data source to which this combo is bound. ... */ - store?: any; - /** [Config Option] (String/HTMLElement/Ext.Element) The id, DOM node or Ext.Element of an existing HTML <select> element to convert into a ComboBox. ... */ - transform?: any; - /** [Config Option] (String) The action to execute when the trigger is clicked. ... */ - triggerAction?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (Boolean) true to populate and autoselect the remainder of the text being typed after a configurable delay (typeAheadDelay) if ... */ - typeAhead?: boolean; - /** [Config Option] (Number) The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true ... */ - typeAheadDelay?: number; - /** [Config Option] (String) The underlying data value name to bind to this ComboBox. ... */ - valueField?: string; - /** [Config Option] (String) When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be d... */ - valueNotFoundText?: string; - /** [Property] (String) The value of the match string used to filter the store. ... */ - lastQuery?: string; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Aligns the picker to the input element */ - alignPicker?(): void; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Clears any value currently set in the ComboBox */ - clearValue?(): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Executes a query to filter the dropdown list - * @param queryString String The SQL query to execute - * @param forceAll Boolean true to force the query to execute even if there are currently fewer characters in the field than the minimum specified by the minChars config option. It also clears any filter previously saved in the current store. - * @param rawQuery Boolean Pass as true if the raw typed value is being used as the query string. This causes the resulting store load to leave the raw value undisturbed. - */ - doQuery?( queryString?:string, forceAll?:boolean, rawQuery?:boolean ): boolean; - /** [Method] Finds the record by searching for a specific field value combination - * @param field String The name of the field to test. - * @param value Object The value to match the field against. - */ - findRecord?( field?:string, value?:any ): Ext.data.IModel; - /** [Method] Finds the record by searching values in the displayField - * @param value Object The value to match the field against. - */ - findRecordByDisplay?( value?:any ): Ext.data.IModel; - /** [Method] Finds the record by searching values in the valueField - * @param value Object The value to match the field against. - */ - findRecordByValue?( value?:any ): Ext.data.IModel; - /** [Method] Returns the store associated with this ComboBox */ - getStore?(): Ext.data.IStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] The picker the dropdown must have its zIndex managed by the same ZIndexManager which is providing the zIndex of our - * @param container Ext.container.IContainer Container which holds the component. - * @param pos Number Position at which the component was added. - */ - onAdded?( container?:Ext.container.IContainer, pos?:number ): void; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Handles the trigger click by default toggles between expanding and collapsing the picker component */ - onTriggerClick?(): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Selects an item by a Model or by a key value - * @param r Object - */ - select?( r?:any ): void; - /** [Method] Sets the specified value s into the field - * @param value any The value(s) to be set. Can be either a single String or Ext.data.Model, or an Array of Strings or Models. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): any; - setValue?( value?:string[] ): any; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.form { - export interface IComboBox extends Ext.form.field.IPicker,Ext.util.IBindable { - /** [Config Option] (String) The text query to send to the server to return all records for the list with no filtering ... */ - allQuery?: string; - /** [Config Option] (Boolean) true to automatically highlight the first result gathered by the data store in the dropdown list when it is opened. ... */ - autoSelect?: boolean; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Object) Set of options that will be used as defaults for the user-configured listConfig object. ... */ - defaultListConfig?: any; - /** [Config Option] (String) The character(s) used to separate the display values of multiple selected items when multiSelect = true. ... */ - delimiter?: string; - /** [Config Option] (String) The underlying data field name to bind to this ComboBox. ... */ - displayField?: string; - /** [Config Option] (Boolean) When queryMode is 'local' only Set to true to have the ComboBox use the typed value as a RegExp source to filter the... */ - enableRegEx?: boolean; - /** [Config Option] (Ext.XTemplate) The content of the field body is defined by this config option. ... */ - fieldSubTpl?: Ext.IXTemplate; - /** [Config Option] (Boolean) true to restrict the selected value to one of the values in the list, false to allow the user to set arbitrary text i... */ - forceSelection?: boolean; - /** [Config Option] (Boolean) false to not allow the component to resize itself when its data changes (and its grow property is true) ... */ - growToLongestValue?: boolean; - /** [Config Option] (String) The name of an underlying hidden field which will be synchronized with the underlying value of the combo. ... */ - hiddenName?: string; - /** [Config Option] (Object) An optional set of configuration properties that will be passed to the Ext.view.BoundList's constructor. ... */ - listConfig?: any; - /** [Config Option] (Number) The minimum number of characters the user must type before autocomplete and typeAhead activate. ... */ - minChars?: number; - /** [Config Option] (Boolean) If set to true, allows the combo field to hold more than one value at a time, and allows selecting multiple items fro... */ - multiSelect?: boolean; - /** [Config Option] (Number) If greater than 0, a Ext.toolbar.Paging is displayed in the footer of the dropdown list and the filter queries will e... */ - pageSize?: number; - /** [Config Option] (Boolean) When true, this prevents the combo from re-querying (either locally or remotely) when the current query is the same a... */ - queryCaching?: boolean; - /** [Config Option] (Number) The length of time in milliseconds to delay between the start of typing and sending the query to filter the dropdown ... */ - queryDelay?: number; - /** [Config Option] (String) The mode in which the ComboBox uses the configured Store. ... */ - queryMode?: string; - /** [Config Option] (String) Name of the parameter used by the Store to pass the typed string when the ComboBox is configured with queryMode: 'rem... */ - queryParam?: string; - /** [Config Option] (Boolean) Whether the Tab key should select the currently highlighted item. ... */ - selectOnTab?: boolean; - /** [Config Option] (Ext.data.Store/String/Array) The data source to which this combo is bound. ... */ - store?: any; - /** [Config Option] (String/HTMLElement/Ext.Element) The id, DOM node or Ext.Element of an existing HTML <select> element to convert into a ComboBox. ... */ - transform?: any; - /** [Config Option] (String) The action to execute when the trigger is clicked. ... */ - triggerAction?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (Boolean) true to populate and autoselect the remainder of the text being typed after a configurable delay (typeAheadDelay) if ... */ - typeAhead?: boolean; - /** [Config Option] (Number) The length of time in milliseconds to wait until the typeahead text is displayed if typeAhead = true ... */ - typeAheadDelay?: number; - /** [Config Option] (String) The underlying data value name to bind to this ComboBox. ... */ - valueField?: string; - /** [Config Option] (String) When using a name/value combo, if the value passed to setValue is not found in the store, valueNotFoundText will be d... */ - valueNotFoundText?: string; - /** [Property] (String) The value of the match string used to filter the store. ... */ - lastQuery?: string; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Aligns the picker to the input element */ - alignPicker?(): void; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Clears any value currently set in the ComboBox */ - clearValue?(): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Executes a query to filter the dropdown list - * @param queryString String The SQL query to execute - * @param forceAll Boolean true to force the query to execute even if there are currently fewer characters in the field than the minimum specified by the minChars config option. It also clears any filter previously saved in the current store. - * @param rawQuery Boolean Pass as true if the raw typed value is being used as the query string. This causes the resulting store load to leave the raw value undisturbed. - */ - doQuery?( queryString?:string, forceAll?:boolean, rawQuery?:boolean ): boolean; - /** [Method] Finds the record by searching for a specific field value combination - * @param field String The name of the field to test. - * @param value Object The value to match the field against. - */ - findRecord?( field?:string, value?:any ): Ext.data.IModel; - /** [Method] Finds the record by searching values in the displayField - * @param value Object The value to match the field against. - */ - findRecordByDisplay?( value?:any ): Ext.data.IModel; - /** [Method] Finds the record by searching values in the valueField - * @param value Object The value to match the field against. - */ - findRecordByValue?( value?:any ): Ext.data.IModel; - /** [Method] Returns the store associated with this ComboBox */ - getStore?(): Ext.data.IStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] The picker the dropdown must have its zIndex managed by the same ZIndexManager which is providing the zIndex of our - * @param container Ext.container.IContainer Container which holds the component. - * @param pos Number Position at which the component was added. - */ - onAdded?( container?:Ext.container.IContainer, pos?:number ): void; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Handles the trigger click by default toggles between expanding and collapsing the picker component */ - onTriggerClick?(): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Selects an item by a Model or by a key value - * @param r Object - */ - select?( r?:any ): void; - /** [Method] Sets the specified value s into the field - * @param value any The value(s) to be set. Can be either a single String or Ext.data.Model, or an Array of Strings or Models. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): any; - setValue?( value?:string[] ): any; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.form.field { - export interface IDate extends Ext.form.field.IPicker { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it does not match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String[]) An array of "dates" to disable, as strings. ... */ - disabledDates?: string[]; - /** [Config Option] (String) The tooltip text to display when the date falls on a disabled date. ... */ - disabledDatesText?: string; - /** [Config Option] (Number[]) An array of days to disable, 0 based. ... */ - disabledDays?: number[]; - /** [Config Option] (String) The tooltip to display when the date falls on a disabled day. ... */ - disabledDaysText?: string; - /** [Config Option] (String) The default date format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (String) The error text to display when the date in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (Boolean) Whether the picker dropdown's width should be explicitly set to match the width of the field. ... */ - matchFieldWidth?: boolean; - /** [Config Option] (String) The error text to display when the date in the cell is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed date. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the date in the cell is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed date. ... */ - minValue?: any; - /** [Config Option] (Boolean) false to hide the footer area of the Date picker containing the Today button and disable the keyboard handler for spa... */ - showToday?: boolean; - /** [Config Option] (Number) Day index at which the week should begin, 0-based. ... */ - startDay?: number; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (Boolean) True to enforce strict date parsing to prevent the default Javascript "date rollover". ... */ - useStrict?: boolean; - /** [Method] private Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Runs all of Date s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Attempts to parse a given string value using a given date format. ... */ - safeParse?: any; - /** [Method] Replaces any existing disabled dates with new values and refreshes the Date picker - * @param disabledDates String[] An array of date strings (see the disabledDates config for details on supported values) used to disable a pattern of dates. - */ - setDisabledDates?( disabledDates?:string[] ): void; - /** [Method] Replaces any existing disabled days by index 0 6 with new values and refreshes the Date picker - * @param disabledDays Number[] An array of disabled day indexes. See the disabledDays config for details on supported values. - */ - setDisabledDays?( disabledDays?:number[] ): void; - /** [Method] Replaces any existing maxValue with the new value and refreshes the Date picker - * @param value Date The maximum date that can be selected - */ - setMaxValue?( value?:any ): void; - /** [Method] Replaces any existing minValue with the new value and refreshes the Date picker - * @param value Date The minimum date that can be selected - */ - setMinValue?( value?:any ): void; - /** [Method] Sets the value of the date field - * @param date any The date or valid date string - */ - setValue?( date?:any ): any; - setValue?( date?:string ): Ext.form.field.IDate; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface IDate extends Ext.form.field.IPicker { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it does not match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String[]) An array of "dates" to disable, as strings. ... */ - disabledDates?: string[]; - /** [Config Option] (String) The tooltip text to display when the date falls on a disabled date. ... */ - disabledDatesText?: string; - /** [Config Option] (Number[]) An array of days to disable, 0 based. ... */ - disabledDays?: number[]; - /** [Config Option] (String) The tooltip to display when the date falls on a disabled day. ... */ - disabledDaysText?: string; - /** [Config Option] (String) The default date format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (String) The error text to display when the date in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (Boolean) Whether the picker dropdown's width should be explicitly set to match the width of the field. ... */ - matchFieldWidth?: boolean; - /** [Config Option] (String) The error text to display when the date in the cell is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed date. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the date in the cell is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed date. ... */ - minValue?: any; - /** [Config Option] (Boolean) false to hide the footer area of the Date picker containing the Today button and disable the keyboard handler for spa... */ - showToday?: boolean; - /** [Config Option] (Number) Day index at which the week should begin, 0-based. ... */ - startDay?: number; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (Boolean) True to enforce strict date parsing to prevent the default Javascript "date rollover". ... */ - useStrict?: boolean; - /** [Method] private Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Runs all of Date s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Attempts to parse a given string value using a given date format. ... */ - safeParse?: any; - /** [Method] Replaces any existing disabled dates with new values and refreshes the Date picker - * @param disabledDates String[] An array of date strings (see the disabledDates config for details on supported values) used to disable a pattern of dates. - */ - setDisabledDates?( disabledDates?:string[] ): void; - /** [Method] Replaces any existing disabled days by index 0 6 with new values and refreshes the Date picker - * @param disabledDays Number[] An array of disabled day indexes. See the disabledDays config for details on supported values. - */ - setDisabledDays?( disabledDays?:number[] ): void; - /** [Method] Replaces any existing maxValue with the new value and refreshes the Date picker - * @param value Date The maximum date that can be selected - */ - setMaxValue?( value?:any ): void; - /** [Method] Replaces any existing minValue with the new value and refreshes the Date picker - * @param value Date The minimum date that can be selected - */ - setMinValue?( value?:any ): void; - /** [Method] Sets the value of the date field - * @param date any The date or valid date string - */ - setValue?( date?:any ): any; - setValue?( date?:string ): Ext.form.field.IDate; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface IDateField extends Ext.form.field.IPicker { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it does not match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String[]) An array of "dates" to disable, as strings. ... */ - disabledDates?: string[]; - /** [Config Option] (String) The tooltip text to display when the date falls on a disabled date. ... */ - disabledDatesText?: string; - /** [Config Option] (Number[]) An array of days to disable, 0 based. ... */ - disabledDays?: number[]; - /** [Config Option] (String) The tooltip to display when the date falls on a disabled day. ... */ - disabledDaysText?: string; - /** [Config Option] (String) The default date format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (String) The error text to display when the date in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (Boolean) Whether the picker dropdown's width should be explicitly set to match the width of the field. ... */ - matchFieldWidth?: boolean; - /** [Config Option] (String) The error text to display when the date in the cell is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed date. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the date in the cell is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed date. ... */ - minValue?: any; - /** [Config Option] (Boolean) false to hide the footer area of the Date picker containing the Today button and disable the keyboard handler for spa... */ - showToday?: boolean; - /** [Config Option] (Number) Day index at which the week should begin, 0-based. ... */ - startDay?: number; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (Boolean) True to enforce strict date parsing to prevent the default Javascript "date rollover". ... */ - useStrict?: boolean; - /** [Method] private Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Runs all of Date s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Attempts to parse a given string value using a given date format. ... */ - safeParse?: any; - /** [Method] Replaces any existing disabled dates with new values and refreshes the Date picker - * @param disabledDates String[] An array of date strings (see the disabledDates config for details on supported values) used to disable a pattern of dates. - */ - setDisabledDates?( disabledDates?:string[] ): void; - /** [Method] Replaces any existing disabled days by index 0 6 with new values and refreshes the Date picker - * @param disabledDays Number[] An array of disabled day indexes. See the disabledDays config for details on supported values. - */ - setDisabledDays?( disabledDays?:number[] ): void; - /** [Method] Replaces any existing maxValue with the new value and refreshes the Date picker - * @param value Date The maximum date that can be selected - */ - setMaxValue?( value?:any ): void; - /** [Method] Replaces any existing minValue with the new value and refreshes the Date picker - * @param value Date The minimum date that can be selected - */ - setMinValue?( value?:any ): void; - /** [Method] Sets the value of the date field - * @param date any The date or valid date string - */ - setValue?( date?:any ): any; - setValue?( date?:string ): Ext.form.field.IDate; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface IDisplay extends Ext.form.field.IBase { - /** [Config Option] (String) The default CSS class for the field. ... */ - fieldCls?: string; - /** [Config Option] (Boolean) True to escape HTML in text when rendering it. ... */ - htmlEncode?: boolean; - /** [Config Option] (Function) A function to transform the raw value for display in the field. ... */ - renderer?: any; - /** [Config Option] (Object) The scope to execute the renderer function. ... */ - scope?: any; - /** [Config Option] (Boolean) Setting this to false will prevent the field from being submitted even when it is not disabled. ... */ - submitValue?: boolean; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - } -} -declare module Ext.form { - export interface IDisplay extends Ext.form.field.IBase { - /** [Config Option] (String) The default CSS class for the field. ... */ - fieldCls?: string; - /** [Config Option] (Boolean) True to escape HTML in text when rendering it. ... */ - htmlEncode?: boolean; - /** [Config Option] (Function) A function to transform the raw value for display in the field. ... */ - renderer?: any; - /** [Config Option] (Object) The scope to execute the renderer function. ... */ - scope?: any; - /** [Config Option] (Boolean) Setting this to false will prevent the field from being submitted even when it is not disabled. ... */ - submitValue?: boolean; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - } -} -declare module Ext.form { - export interface IDisplayField extends Ext.form.field.IBase { - /** [Config Option] (String) The default CSS class for the field. ... */ - fieldCls?: string; - /** [Config Option] (Boolean) True to escape HTML in text when rendering it. ... */ - htmlEncode?: boolean; - /** [Config Option] (Function) A function to transform the raw value for display in the field. ... */ - renderer?: any; - /** [Config Option] (Object) The scope to execute the renderer function. ... */ - scope?: any; - /** [Config Option] (Boolean) Setting this to false will prevent the field from being submitted even when it is not disabled. ... */ - submitValue?: boolean; - /** [Method] Returns the raw value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the processed raw value of the field */ - isValid?(): boolean; - /** [Method] Sets the field s raw value directly bypassing value conversion change detection and validation - * @param value Object The value to set - */ - setRawValue?( value?:any ): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): boolean; - } -} -declare module Ext.form.field { - export interface IField extends Ext.IBase { - /** [Config Option] (Boolean) True to disable the field. ... */ - disabled?: boolean; - /** [Config Option] (String) The name of the field. ... */ - name?: string; - /** [Config Option] (Boolean) Setting this to false will prevent the field from being submitted even when it is not disabled. ... */ - submitValue?: boolean; - /** [Config Option] (Boolean) Specifies whether this field should be validated immediately whenever a change in its value is detected. ... */ - validateOnChange?: boolean; - /** [Config Option] (Object) */ - value?: any; - /** [Property] (Boolean) Flag denoting that this component is a Field. ... */ - isFormField?: boolean; - /** [Property] (Object) The original value of the field as configured in the value configuration, or as loaded by the last form load operatio... */ - originalValue?: any; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): any; - /** [Method] Template method before a field is reset */ - beforeReset?(): any; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): any; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): any; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): any; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): any; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): any; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): any; - /** [Method] Returns the parameter s that would be included in a standard form submit for this field */ - getSubmitData?(): any; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): any; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): any; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): any; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): any; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value */ - isValid?(): any; - /** [Method] Associate one or more error messages with this field - * @param errors any The error message(s) for the field. - */ - markInvalid?( errors?:any ): any; - markInvalid?( errors?:string ): any; - markInvalid?( errors?:string[] ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): any; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): any; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value and fires the vali */ - validate?(): any; - } -} -declare module Ext.form.field { - export interface IFile extends Ext.form.field.ITrigger { - /** [Config Option] (Object) */ - buttonConfig?: any; - /** [Config Option] (Number) The number of pixels of space reserved between the button and the text field. ... */ - buttonMargin?: number; - /** [Config Option] (Boolean) True to display the file upload field as a button with no visible text field. ... */ - buttonOnly?: boolean; - /** [Config Option] (String) The button text to display on the upload button. ... */ - buttonText?: string; - /** [Config Option] (Boolean) True to clear the selected file value when the form this field belongs to is submitted to the server. ... */ - clearOnSubmit?: boolean; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (Boolean) Unlike with other form fields, the readOnly config defaults to true in File field. ... */ - readOnly?: boolean; - /** [Property] (Ext.button.Button) A reference to the trigger Button component created for this upload field. ... */ - button?: Ext.button.IButton; - /** [Property] (Ext.Element) A reference to the invisible file input element created for this upload field. ... */ - fileInputEl?: Ext.IElement; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the markup to be inserted into the subTplMarkup */ - getTriggerMarkup?(): void; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Overridden to do nothing */ - setValue?(): void; - } -} -declare module Ext.form { - export interface IFile extends Ext.form.field.ITrigger { - /** [Config Option] (Object) */ - buttonConfig?: any; - /** [Config Option] (Number) The number of pixels of space reserved between the button and the text field. ... */ - buttonMargin?: number; - /** [Config Option] (Boolean) True to display the file upload field as a button with no visible text field. ... */ - buttonOnly?: boolean; - /** [Config Option] (String) The button text to display on the upload button. ... */ - buttonText?: string; - /** [Config Option] (Boolean) True to clear the selected file value when the form this field belongs to is submitted to the server. ... */ - clearOnSubmit?: boolean; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (Boolean) Unlike with other form fields, the readOnly config defaults to true in File field. ... */ - readOnly?: boolean; - /** [Property] (Ext.button.Button) A reference to the trigger Button component created for this upload field. ... */ - button?: Ext.button.IButton; - /** [Property] (Ext.Element) A reference to the invisible file input element created for this upload field. ... */ - fileInputEl?: Ext.IElement; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the markup to be inserted into the subTplMarkup */ - getTriggerMarkup?(): void; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Overridden to do nothing */ - setValue?(): void; - } -} -declare module Ext.form { - export interface IFileUploadField extends Ext.form.field.ITrigger { - /** [Config Option] (Object) */ - buttonConfig?: any; - /** [Config Option] (Number) The number of pixels of space reserved between the button and the text field. ... */ - buttonMargin?: number; - /** [Config Option] (Boolean) True to display the file upload field as a button with no visible text field. ... */ - buttonOnly?: boolean; - /** [Config Option] (String) The button text to display on the upload button. ... */ - buttonText?: string; - /** [Config Option] (Boolean) True to clear the selected file value when the form this field belongs to is submitted to the server. ... */ - clearOnSubmit?: boolean; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (Boolean) Unlike with other form fields, the readOnly config defaults to true in File field. ... */ - readOnly?: boolean; - /** [Property] (Ext.button.Button) A reference to the trigger Button component created for this upload field. ... */ - button?: Ext.button.IButton; - /** [Property] (Ext.Element) A reference to the invisible file input element created for this upload field. ... */ - fileInputEl?: Ext.IElement; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the markup to be inserted into the subTplMarkup */ - getTriggerMarkup?(): void; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Overridden to do nothing */ - setValue?(): void; - } -} -declare module Ext.ux.form { - export interface IFileUploadField extends Ext.form.field.ITrigger { - /** [Config Option] (Object) */ - buttonConfig?: any; - /** [Config Option] (Number) The number of pixels of space reserved between the button and the text field. ... */ - buttonMargin?: number; - /** [Config Option] (Boolean) True to display the file upload field as a button with no visible text field. ... */ - buttonOnly?: boolean; - /** [Config Option] (String) The button text to display on the upload button. ... */ - buttonText?: string; - /** [Config Option] (Boolean) True to clear the selected file value when the form this field belongs to is submitted to the server. ... */ - clearOnSubmit?: boolean; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (Boolean) Unlike with other form fields, the readOnly config defaults to true in File field. ... */ - readOnly?: boolean; - /** [Property] (Ext.button.Button) A reference to the trigger Button component created for this upload field. ... */ - button?: Ext.button.IButton; - /** [Property] (Ext.Element) A reference to the invisible file input element created for this upload field. ... */ - fileInputEl?: Ext.IElement; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Gets the markup to be inserted into the subTplMarkup */ - getTriggerMarkup?(): void; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Overridden to do nothing */ - setValue?(): void; - } -} -declare module Ext.form.field { - export interface IFileButton extends Ext.button.IButton { - /** [Config Option] (String) A CSS class string to apply to the button's main element. ... */ - cls?: string; - /** [Config Option] (Boolean) True to prevent the default action when the clickEvent is processed. ... */ - preventDefault?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] This method returns an object which provides substitution parameters for the XTemplate used to create this Button s D */ - getTemplateArgs?(): any; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - } -} -declare module Ext.form.field { - export interface IHidden extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Set to true to completely hide the label element (fieldLabel and labelSeparator). ... */ - hideLabel?: boolean; - /** [Config Option] (String) private The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] These are all private overrides Initialize any events on this component */ - initEvents?(): void; - /** [Method] Display one or more error messages associated with this field using msgTarget to determine how to display the messag - * @param errors String The validation message(s) to display. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] Sets the height of the component - * @param height Number The new height to set. This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. undefined to leave the height unchanged. - */ - setHeight?( height?:number ): Ext.IComponent; - /** [Method] Sets the page XY position of the component - * @param x any The new x position or an array of [x,y]. - * @param y any The new y position. - * @param animate any True to animate the Component into its new position. You may also pass an animation configuration. - */ - setPagePosition?( x?:any, y?:any, animate?:any ): any; - setPagePosition?( x?:number, y?:number, animate?:any ): Ext.IComponent; - setPagePosition?( x?:number[], y?:number, animate?:any ): Ext.IComponent; - /** [Method] Sets the left and top of the component - * @param x any The new left, an array of [x,y], or animation config object containing x and y properties. - * @param y Number The new top. - * @param animate any If true, the Component is animated into its new position. You may also pass an animation configuration. - */ - setPosition?( x?:any, y?:number, animate?:any ): Ext.IComponent; - /** [Method] Sets the width and height of this Component - * @param width any The new width to set. This may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. A size object in the format {width: widthValue, height: heightValue}. undefined to leave the width unchanged. - * @param height any The new height to set (not required if a size object is passed as the first arg). This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. undefined to leave the height unchanged. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:any, height?:number ): Ext.IComponent; - setSize?( width?:any, height?:string ): Ext.IComponent; - /** [Method] Sets the width of the component - * @param width Number The new width to setThis may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. - */ - setWidth?( width?:number ): Ext.IComponent; - } -} -declare module Ext.form { - export interface IHidden extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Set to true to completely hide the label element (fieldLabel and labelSeparator). ... */ - hideLabel?: boolean; - /** [Config Option] (String) private The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] These are all private overrides Initialize any events on this component */ - initEvents?(): void; - /** [Method] Display one or more error messages associated with this field using msgTarget to determine how to display the messag - * @param errors String The validation message(s) to display. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] Sets the height of the component - * @param height Number The new height to set. This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. undefined to leave the height unchanged. - */ - setHeight?( height?:number ): Ext.IComponent; - /** [Method] Sets the page XY position of the component - * @param x any The new x position or an array of [x,y]. - * @param y any The new y position. - * @param animate any True to animate the Component into its new position. You may also pass an animation configuration. - */ - setPagePosition?( x?:any, y?:any, animate?:any ): any; - setPagePosition?( x?:number, y?:number, animate?:any ): Ext.IComponent; - setPagePosition?( x?:number[], y?:number, animate?:any ): Ext.IComponent; - /** [Method] Sets the left and top of the component - * @param x any The new left, an array of [x,y], or animation config object containing x and y properties. - * @param y Number The new top. - * @param animate any If true, the Component is animated into its new position. You may also pass an animation configuration. - */ - setPosition?( x?:any, y?:number, animate?:any ): Ext.IComponent; - /** [Method] Sets the width and height of this Component - * @param width any The new width to set. This may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. A size object in the format {width: widthValue, height: heightValue}. undefined to leave the width unchanged. - * @param height any The new height to set (not required if a size object is passed as the first arg). This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. undefined to leave the height unchanged. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:any, height?:number ): Ext.IComponent; - setSize?( width?:any, height?:string ): Ext.IComponent; - /** [Method] Sets the width of the component - * @param width Number The new width to setThis may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. - */ - setWidth?( width?:number ): Ext.IComponent; - } -} -declare module Ext.form.field { - export interface IHtmlEditor extends Ext.form.IFieldContainer,Ext.form.field.IField { - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the iframe element. ... */ - afterIFrameTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the textarea element. ... */ - afterTextAreaTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the iframe element. ... */ - beforeIFrameTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the textarea element. ... */ - beforeTextAreaTpl?: any; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The default text for the create link prompt ... */ - createLinkText?: string; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default value for the create link prompt ... */ - defaultLinkValue?: string; - /** [Config Option] (String) A default value to be put into the editor to resolve focus issues. ... */ - defaultValue?: string; - /** [Config Option] (Boolean) Enable the left, center, right alignment buttons ... */ - enableAlignments?: boolean; - /** [Config Option] (Boolean) Enable the fore/highlight color buttons ... */ - enableColors?: boolean; - /** [Config Option] (Boolean) Enable font selection. ... */ - enableFont?: boolean; - /** [Config Option] (Boolean) Enable the increase/decrease font size buttons ... */ - enableFontSize?: boolean; - /** [Config Option] (Boolean) Enable the bold, italic and underline buttons ... */ - enableFormat?: boolean; - /** [Config Option] (Boolean) Enable the create link button. ... */ - enableLinks?: boolean; - /** [Config Option] (Boolean) Enable the bullet and numbered list buttons. ... */ - enableLists?: boolean; - /** [Config Option] (Boolean) Enable the switch to source edit button. ... */ - enableSourceEdit?: boolean; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (String[]) An array of available font families ... */ - fontFamilies?: string[]; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the iframe element (as attributes). ... */ - iframeAttrTpl?: any; - /** [Property] (Object) Object collection of toolbar tooltips for the buttons in the editor. ... */ - buttonTips?: any; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] If you need want custom HTML cleanup this is the method you should override - * @param html String The HTML to be cleaned - */ - cleanHtml?( html?:string ): string; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] Called when the editor creates its toolbar - * @param editor Ext.form.field.IHtmlEditor - */ - createToolbar?( editor?:Ext.form.field.IHtmlEditor ): void; - /** [Method] Executes a Midas editor command directly on the editor document - * @param cmd String The Midas command - * @param value String The value to pass to the command - */ - execCmd?( cmd?:string, value?:string ): void; - execCmd?( cmd?:string, value?:boolean ): void; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Try to focus this component - * @param selectText any If applicable, true to also select the text in this component - * @param delay any Delay the focus this number of milliseconds (true for 10 milliseconds). - */ - focus?( selectText?:any, delay?:any ): any; - focus?( selectText?:boolean, delay?:boolean ): Ext.IComponent; - focus?( selectText?:boolean, delay?:number ): Ext.IComponent; - /** [Method] Called when the editor initializes the iframe with HTML contents */ - getDocMarkup?(): void; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Returns the parameter s that would be included in a standard form submit for this field */ - getSubmitData?(): any; - /** [Method] Returns the editor s toolbar */ - getToolbar?(): Ext.toolbar.IToolbar; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Inserts the passed text at the current cursor position - * @param text String - */ - insertAtCursor?( text?:string ): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value */ - isValid?(): boolean; - /** [Method] Associate one or more error messages with this field - * @param errors String The error message(s) for the field. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] Pushes the value of the textarea into the iframe editor */ - pushValue?(): void; - /** [Method] Executes a Midas editor command on the editor document and performs necessary focus and toolbar updates - * @param cmd String The Midas command - * @param value String The value to pass to the command - */ - relayCmd?( cmd?:string, value?:string ): void; - relayCmd?( cmd?:string, value?:boolean ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Syncs the contents of the editor iframe with the textarea */ - syncValue?(): void; - /** [Method] Toggles the editor between standard and source edit mode - * @param sourceEditMode Boolean True for source edit, false for standard - */ - toggleSourceEdit?( sourceEditMode?:boolean ): void; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Triggers a toolbar update by reading the markup state of the current selection in the editor */ - updateToolbar?(): void; - } -} -declare module Ext.form { - export interface IHtmlEditor extends Ext.form.IFieldContainer,Ext.form.field.IField { - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the iframe element. ... */ - afterIFrameTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the textarea element. ... */ - afterTextAreaTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the iframe element. ... */ - beforeIFrameTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the textarea element. ... */ - beforeTextAreaTpl?: any; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The default text for the create link prompt ... */ - createLinkText?: string; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default value for the create link prompt ... */ - defaultLinkValue?: string; - /** [Config Option] (String) A default value to be put into the editor to resolve focus issues. ... */ - defaultValue?: string; - /** [Config Option] (Boolean) Enable the left, center, right alignment buttons ... */ - enableAlignments?: boolean; - /** [Config Option] (Boolean) Enable the fore/highlight color buttons ... */ - enableColors?: boolean; - /** [Config Option] (Boolean) Enable font selection. ... */ - enableFont?: boolean; - /** [Config Option] (Boolean) Enable the increase/decrease font size buttons ... */ - enableFontSize?: boolean; - /** [Config Option] (Boolean) Enable the bold, italic and underline buttons ... */ - enableFormat?: boolean; - /** [Config Option] (Boolean) Enable the create link button. ... */ - enableLinks?: boolean; - /** [Config Option] (Boolean) Enable the bullet and numbered list buttons. ... */ - enableLists?: boolean; - /** [Config Option] (Boolean) Enable the switch to source edit button. ... */ - enableSourceEdit?: boolean; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (String[]) An array of available font families ... */ - fontFamilies?: string[]; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the iframe element (as attributes). ... */ - iframeAttrTpl?: any; - /** [Property] (Object) Object collection of toolbar tooltips for the buttons in the editor. ... */ - buttonTips?: any; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] A utility for grouping a set of modifications which may trigger value changes into a single transaction to prevent e - * @param fn Object A function containing the transaction code - */ - batchChanges?( fn?:any ): void; - /** [Method] Template method before a field is reset */ - beforeReset?(): void; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Checks the isDirty state of the field and if it has changed since the last time it was checked fires the dirtychange */ - checkDirty?(): void; - /** [Method] If you need want custom HTML cleanup this is the method you should override - * @param html String The HTML to be cleaned - */ - cleanHtml?( html?:string ): string; - /** [Method] Clear any invalid styles messages for this field */ - clearInvalid?(): void; - /** [Method] Called when the editor creates its toolbar - * @param editor Ext.form.field.IHtmlEditor - */ - createToolbar?( editor?:Ext.form.field.IHtmlEditor ): void; - /** [Method] Executes a Midas editor command directly on the editor document - * @param cmd String The Midas command - * @param value String The value to pass to the command - */ - execCmd?( cmd?:string, value?:string ): void; - execCmd?( cmd?:string, value?:boolean ): void; - /** [Method] Only relevant if the instance s isFileUpload method returns true */ - extractFileInput?(): HTMLElement; - /** [Method] Try to focus this component - * @param selectText any If applicable, true to also select the text in this component - * @param delay any Delay the focus this number of milliseconds (true for 10 milliseconds). - */ - focus?( selectText?:any, delay?:any ): any; - focus?( selectText?:boolean, delay?:boolean ): Ext.IComponent; - focus?( selectText?:boolean, delay?:number ): Ext.IComponent; - /** [Method] Called when the editor initializes the iframe with HTML contents */ - getDocMarkup?(): void; - /** [Method] Runs this field s validators and returns an array of error messages for any validation failures - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the name attribute of the field */ - getName?(): string; - /** [Method] Returns the parameter s that would be included in a standard form submit for this field */ - getSubmitData?(): any; - /** [Method] Returns the editor s toolbar */ - getToolbar?(): Ext.toolbar.IToolbar; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes this Field mixin on the current instance */ - initField?(): void; - /** [Method] Initializes the field s value based on the initial config */ - initValue?(): void; - /** [Method] Inserts the passed text at the current cursor position - * @param text String - */ - insertAtCursor?( text?:string ): void; - /** [Method] Returns true if the value of this Field has been changed from its originalValue */ - isDirty?(): boolean; - /** [Method] Returns whether two field values are logically equal - * @param value1 Object The first value to compare - * @param value2 Object The second value to compare - */ - isEqual?( value1?:any, value2?:any ): boolean; - /** [Method] Returns whether this Field is a file upload field if it returns true forms will use special techniques for submitti */ - isFileUpload?(): boolean; - /** [Method] Returns whether or not the field value is currently valid by validating the field s current value */ - isValid?(): boolean; - /** [Method] Associate one or more error messages with this field - * @param errors String The error message(s) for the field. - */ - markInvalid?( errors?:string ): void; - markInvalid?( errors?:string[] ): void; - /** [Method] Pushes the value of the textarea into the iframe editor */ - pushValue?(): void; - /** [Method] Executes a Midas editor command on the editor document and performs necessary focus and toolbar updates - * @param cmd String The Midas command - * @param value String The value to pass to the command - */ - relayCmd?( cmd?:string, value?:string ): void; - relayCmd?( cmd?:string, value?:boolean ): void; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Resets the field s originalValue property so it matches the current value */ - resetOriginalValue?(): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - /** [Method] Syncs the contents of the editor iframe with the textarea */ - syncValue?(): void; - /** [Method] Toggles the editor between standard and source edit mode - * @param sourceEditMode Boolean True for source edit, false for standard - */ - toggleSourceEdit?( sourceEditMode?:boolean ): void; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] Triggers a toolbar update by reading the markup state of the current selection in the editor */ - updateToolbar?(): void; - } -} -declare module Ext.form.field { - export interface INumber extends Ext.form.field.ISpinner { - /** [Config Option] (Boolean) False to disallow decimal values ... */ - allowDecimals?: boolean; - /** [Config Option] (Boolean) True to automatically strip not allowed characters from the field. ... */ - autoStripChars?: boolean; - /** [Config Option] (String) The base set of characters to evaluate as valid numbers. ... */ - baseChars?: string; - /** [Config Option] (Number) The maximum precision to display after the decimal separator ... */ - decimalPrecision?: number; - /** [Config Option] (String) Character(s) to allow as the decimal separator ... */ - decimalSeparator?: string; - /** [Config Option] (String) Error text to display if the maximum value validation fails. ... */ - maxText?: string; - /** [Config Option] (Number) The maximum allowed value. ... */ - maxValue?: number; - /** [Config Option] (String) Error text to display if the minimum value validation fails. ... */ - minText?: string; - /** [Config Option] (Number) The minimum allowed value. ... */ - minValue?: number; - /** [Config Option] (String) Error text to display if the value is not a valid number. ... */ - nanText?: string; - /** [Config Option] (String) Error text to display if the value is negative and minValue is set to 0. ... */ - negativeText?: string; - /** [Config Option] (Number) Specifies a numeric interval by which the field's value will be incremented or decremented when the user invokes the ... */ - step?: number; - /** [Config Option] (Boolean) False to ensure that the getSubmitValue method strips always uses . ... */ - submitLocaleSeparator?: boolean; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Runs all of Number s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] This method is called when the spinner down button is clicked or when the down arrow key is pressed if keyNavEnabled */ - onSpinDown?(): void; - /** [Method] This method is called when the spinner up button is clicked or when the up arrow key is pressed if keyNavEnabled is */ - onSpinUp?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new value - * @param value Number The maximum value - */ - setMaxValue?( value?:number ): void; - /** [Method] Replaces any existing minValue with the new value - * @param value Number The minimum value - */ - setMinValue?( value?:number ): void; - /** [Method] Sets whether the spinner down button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinDownEnabled?( enabled?:boolean ): void; - /** [Method] Sets whether the spinner up button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinUpEnabled?( enabled?:boolean ): void; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface INumber extends Ext.form.field.ISpinner { - /** [Config Option] (Boolean) False to disallow decimal values ... */ - allowDecimals?: boolean; - /** [Config Option] (Boolean) True to automatically strip not allowed characters from the field. ... */ - autoStripChars?: boolean; - /** [Config Option] (String) The base set of characters to evaluate as valid numbers. ... */ - baseChars?: string; - /** [Config Option] (Number) The maximum precision to display after the decimal separator ... */ - decimalPrecision?: number; - /** [Config Option] (String) Character(s) to allow as the decimal separator ... */ - decimalSeparator?: string; - /** [Config Option] (String) Error text to display if the maximum value validation fails. ... */ - maxText?: string; - /** [Config Option] (Number) The maximum allowed value. ... */ - maxValue?: number; - /** [Config Option] (String) Error text to display if the minimum value validation fails. ... */ - minText?: string; - /** [Config Option] (Number) The minimum allowed value. ... */ - minValue?: number; - /** [Config Option] (String) Error text to display if the value is not a valid number. ... */ - nanText?: string; - /** [Config Option] (String) Error text to display if the value is negative and minValue is set to 0. ... */ - negativeText?: string; - /** [Config Option] (Number) Specifies a numeric interval by which the field's value will be incremented or decremented when the user invokes the ... */ - step?: number; - /** [Config Option] (Boolean) False to ensure that the getSubmitValue method strips always uses . ... */ - submitLocaleSeparator?: boolean; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Runs all of Number s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] This method is called when the spinner down button is clicked or when the down arrow key is pressed if keyNavEnabled */ - onSpinDown?(): void; - /** [Method] This method is called when the spinner up button is clicked or when the up arrow key is pressed if keyNavEnabled is */ - onSpinUp?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new value - * @param value Number The maximum value - */ - setMaxValue?( value?:number ): void; - /** [Method] Replaces any existing minValue with the new value - * @param value Number The minimum value - */ - setMinValue?( value?:number ): void; - /** [Method] Sets whether the spinner down button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinDownEnabled?( enabled?:boolean ): void; - /** [Method] Sets whether the spinner up button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinUpEnabled?( enabled?:boolean ): void; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface INumberField extends Ext.form.field.ISpinner { - /** [Config Option] (Boolean) False to disallow decimal values ... */ - allowDecimals?: boolean; - /** [Config Option] (Boolean) True to automatically strip not allowed characters from the field. ... */ - autoStripChars?: boolean; - /** [Config Option] (String) The base set of characters to evaluate as valid numbers. ... */ - baseChars?: string; - /** [Config Option] (Number) The maximum precision to display after the decimal separator ... */ - decimalPrecision?: number; - /** [Config Option] (String) Character(s) to allow as the decimal separator ... */ - decimalSeparator?: string; - /** [Config Option] (String) Error text to display if the maximum value validation fails. ... */ - maxText?: string; - /** [Config Option] (Number) The maximum allowed value. ... */ - maxValue?: number; - /** [Config Option] (String) Error text to display if the minimum value validation fails. ... */ - minText?: string; - /** [Config Option] (Number) The minimum allowed value. ... */ - minValue?: number; - /** [Config Option] (String) Error text to display if the value is not a valid number. ... */ - nanText?: string; - /** [Config Option] (String) Error text to display if the value is negative and minValue is set to 0. ... */ - negativeText?: string; - /** [Config Option] (Number) Specifies a numeric interval by which the field's value will be incremented or decremented when the user invokes the ... */ - step?: number; - /** [Config Option] (Boolean) False to ensure that the getSubmitValue method strips always uses . ... */ - submitLocaleSeparator?: boolean; - /** [Method] Template method to do any pre blur processing - * @param e Ext.IEventObject The event object - */ - beforeBlur?( e?:Ext.IEventObject ): void; - /** [Method] Runs all of Number s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] This method is called when the spinner down button is clicked or when the down arrow key is pressed if keyNavEnabled */ - onSpinDown?(): void; - /** [Method] This method is called when the spinner up button is clicked or when the up arrow key is pressed if keyNavEnabled is */ - onSpinUp?(): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new value - * @param value Number The maximum value - */ - setMaxValue?( value?:number ): void; - /** [Method] Replaces any existing minValue with the new value - * @param value Number The minimum value - */ - setMinValue?( value?:number ): void; - /** [Method] Sets whether the spinner down button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinDownEnabled?( enabled?:boolean ): void; - /** [Method] Sets whether the spinner up button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinUpEnabled?( enabled?:boolean ): void; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface IPicker extends Ext.form.field.ITrigger { - /** [Config Option] (Boolean) False to prevent the user from typing text directly into the field; the field can only have its value set via selecti... */ - editable?: boolean; - /** [Config Option] (Boolean) Whether the picker dropdown's width should be explicitly set to match the width of the field. ... */ - matchFieldWidth?: boolean; - /** [Config Option] (String) A class to be added to the field's bodyEl element when the picker is opened. ... */ - openCls?: string; - /** [Config Option] (String) The alignment position with which to align the picker. ... */ - pickerAlign?: string; - /** [Config Option] (Number[]) An offset [x,y] to use in addition to the pickerAlign when positioning the picker. ... */ - pickerOffset?: number[]; - /** [Property] (Boolean) */ - isExpanded?: boolean; - /** [Method] Aligns the picker to the input element */ - alignPicker?(): void; - /** [Method] Collapses this field s picker dropdown */ - collapse?(): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Expands this field s picker dropdown */ - expand?(): void; - /** [Method] Returns a reference to the picker component for this field creating it if necessary by calling createPicker */ - getPicker?(): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Handles the trigger click by default toggles between expanding and collapsing the picker component */ - onTriggerClick?(): void; - } -} -declare module Ext.form { - export interface IPicker extends Ext.form.field.ITrigger { - /** [Config Option] (Boolean) False to prevent the user from typing text directly into the field; the field can only have its value set via selecti... */ - editable?: boolean; - /** [Config Option] (Boolean) Whether the picker dropdown's width should be explicitly set to match the width of the field. ... */ - matchFieldWidth?: boolean; - /** [Config Option] (String) A class to be added to the field's bodyEl element when the picker is opened. ... */ - openCls?: string; - /** [Config Option] (String) The alignment position with which to align the picker. ... */ - pickerAlign?: string; - /** [Config Option] (Number[]) An offset [x,y] to use in addition to the pickerAlign when positioning the picker. ... */ - pickerOffset?: number[]; - /** [Property] (Boolean) */ - isExpanded?: boolean; - /** [Method] Aligns the picker to the input element */ - alignPicker?(): void; - /** [Method] Collapses this field s picker dropdown */ - collapse?(): void; - /** [Method] Creates and returns the component to be used as this field s picker */ - createPicker?(): void; - /** [Method] Expands this field s picker dropdown */ - expand?(): void; - /** [Method] Returns a reference to the picker component for this field creating it if necessary by calling createPicker */ - getPicker?(): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Handles the trigger click by default toggles between expanding and collapsing the picker component */ - onTriggerClick?(): void; - } -} -declare module Ext.form.field { - export interface IRadio extends Ext.form.field.ICheckbox { - /** [Config Option] (String) The CSS class to use when the radio field receives focus ... */ - focusCls?: string; - /** [Config Option] (String) private The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Radio, or subclass thereof. ... */ - isRadio?: boolean; - /** [Method] If this radio is part of a group it will return the selected value */ - getGroupValue?(): string; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the submit value for the checkbox which can be used when submitting forms */ - getSubmitValue?(): string; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Sets either the checked unchecked status of this Radio or if a string value is passed checks a sibling Radio of th - * @param value any Checked value, or the value of the sibling radio button to check. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): Ext.form.field.IRadio; - setValue?( value?:boolean ): Ext.form.field.IRadio; - } -} -declare module Ext.form { - export interface IRadio extends Ext.form.field.ICheckbox { - /** [Config Option] (String) The CSS class to use when the radio field receives focus ... */ - focusCls?: string; - /** [Config Option] (String) private The type attribute for input fields -- e.g. ... */ - inputType?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Radio, or subclass thereof. ... */ - isRadio?: boolean; - /** [Method] If this radio is part of a group it will return the selected value */ - getGroupValue?(): string; - /** [Method] Returns the value s that should be saved to the Ext data Model instance for this field when Ext form Basic updateRe */ - getModelData?(): any; - /** [Method] Returns the submit value for the checkbox which can be used when submitting forms */ - getSubmitValue?(): string; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Sets either the checked unchecked status of this Radio or if a string value is passed checks a sibling Radio of th - * @param value any Checked value, or the value of the sibling radio button to check. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): Ext.form.field.IRadio; - setValue?( value?:boolean ): Ext.form.field.IRadio; - } -} -declare module Ext.form.field { - export interface ISpinner extends Ext.form.field.ITrigger { - /** [Config Option] (Boolean) Specifies whether the up and down arrow keys should trigger spinning up and down. ... */ - keyNavEnabled?: boolean; - /** [Config Option] (Boolean) Specifies whether the mouse wheel should trigger spinning up and down while the field has focus. ... */ - mouseWheelEnabled?: boolean; - /** [Config Option] (Boolean) Whether a click repeater should be attached to the spinner buttons. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) Specifies whether the down spinner button is enabled. ... */ - spinDownEnabled?: boolean; - /** [Config Option] (Boolean) Specifies whether the up spinner button is enabled. ... */ - spinUpEnabled?: boolean; - /** [Property] (Ext.Element) */ - spinDownEl?: Ext.IElement; - /** [Property] (Ext.Element) */ - spinUpEl?: Ext.IElement; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the spinner button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] This method is called when the spinner down button is clicked or when the down arrow key is pressed if keyNavEnabled */ - onSpinDown?(): void; - /** [Method] This method is called when the spinner up button is clicked or when the up arrow key is pressed if keyNavEnabled is */ - onSpinUp?(): void; - /** [Method] Sets whether the spinner down button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinDownEnabled?( enabled?:boolean ): void; - /** [Method] Sets whether the spinner up button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinUpEnabled?( enabled?:boolean ): void; - /** [Method] Triggers the spinner to step down fires the spin and spindown events and calls the onSpinDown method */ - spinDown?(): void; - /** [Method] Triggers the spinner to step up fires the spin and spinup events and calls the onSpinUp method */ - spinUp?(): void; - } -} -declare module Ext.form { - export interface ISpinner extends Ext.form.field.ITrigger { - /** [Config Option] (Boolean) Specifies whether the up and down arrow keys should trigger spinning up and down. ... */ - keyNavEnabled?: boolean; - /** [Config Option] (Boolean) Specifies whether the mouse wheel should trigger spinning up and down while the field has focus. ... */ - mouseWheelEnabled?: boolean; - /** [Config Option] (Boolean) Whether a click repeater should be attached to the spinner buttons. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) Specifies whether the down spinner button is enabled. ... */ - spinDownEnabled?: boolean; - /** [Config Option] (Boolean) Specifies whether the up spinner button is enabled. ... */ - spinUpEnabled?: boolean; - /** [Property] (Ext.Element) */ - spinDownEl?: Ext.IElement; - /** [Property] (Ext.Element) */ - spinUpEl?: Ext.IElement; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the spinner button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] This method is called when the spinner down button is clicked or when the down arrow key is pressed if keyNavEnabled */ - onSpinDown?(): void; - /** [Method] This method is called when the spinner up button is clicked or when the up arrow key is pressed if keyNavEnabled is */ - onSpinUp?(): void; - /** [Method] Sets whether the spinner down button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinDownEnabled?( enabled?:boolean ): void; - /** [Method] Sets whether the spinner up button is enabled - * @param enabled Boolean true to enable the button, false to disable it. - */ - setSpinUpEnabled?( enabled?:boolean ): void; - /** [Method] Triggers the spinner to step down fires the spin and spindown events and calls the onSpinDown method */ - spinDown?(): void; - /** [Method] Triggers the spinner to step up fires the spin and spinup events and calls the onSpinUp method */ - spinUp?(): void; - } -} -declare module Ext.form.field { - export interface IText extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Specify false to validate that the value's length must be > 0. ... */ - allowBlank?: boolean; - /** [Config Option] (Boolean) Specify false to automatically trim the value before validating the whether the value is blank. ... */ - allowOnlyWhitespace?: boolean; - /** [Config Option] (String) The error text to display if the allowBlank validation fails ... */ - blankText?: string; - /** [Config Option] (Boolean) Specify true to disable input keystroke filtering ... */ - disableKeyFilter?: boolean; - /** [Config Option] (String) The CSS class to apply to an empty field to style the emptyText. ... */ - emptyCls?: string; - /** [Config Option] (String) The default text to place into an empty field. ... */ - emptyText?: string; - /** [Config Option] (Boolean) true to enable the proxying of key events for the HTML input field ... */ - enableKeyEvents?: boolean; - /** [Config Option] (Boolean) True to set the maxLength property on the underlying input field. ... */ - enforceMaxLength?: boolean; - /** [Config Option] (Boolean) true if this field should automatically grow and shrink to its content ... */ - grow?: boolean; - /** [Config Option] (String) A string that will be appended to the field's current value for the purposes of calculating the target field size. ... */ - growAppend?: string; - /** [Config Option] (Number) The maximum width to allow when grow = true ... */ - growMax?: number; - /** [Config Option] (Number) The minimum width to allow when grow = true ... */ - growMin?: number; - /** [Config Option] (RegExp) An input mask regular expression that will be used to filter keystrokes (character being typed) that do not match. ... */ - maskRe?: RegExp; - /** [Config Option] (Number) Maximum input field length allowed by validation. ... */ - maxLength?: number; - /** [Config Option] (String) Error text to display if the maximum length validation fails ... */ - maxLengthText?: string; - /** [Config Option] (Number) Minimum input field length required ... */ - minLength?: number; - /** [Config Option] (String) Error text to display if the minimum length validation fails. ... */ - minLengthText?: string; - /** [Config Option] (RegExp) A JavaScript RegExp object to be tested against the field value during validation. ... */ - regex?: RegExp; - /** [Config Option] (String) The error text to display if regex is used and the test fails during validation ... */ - regexText?: string; - /** [Config Option] (String) The CSS class to apply to a required field, i.e. ... */ - requiredCls?: string; - /** [Config Option] (Boolean) true to automatically select any existing field text when the field receives input focus ... */ - selectOnFocus?: boolean; - /** [Config Option] (Number) An initial value for the 'size' attribute on the text input element. ... */ - size?: number; - /** [Config Option] (RegExp) A JavaScript RegExp object used to strip unwanted content from the value during input. ... */ - stripCharsRe?: RegExp; - /** [Config Option] (Boolean) Specify as true to modify the behaviour of allowBlank so that blank values are not passed as valid, but are subject t... */ - validateBlank?: boolean; - /** [Config Option] (Function) A custom validation function to be called during field validation (getErrors). ... */ - validator?: any; - /** [Config Option] (String) */ - vtype?: string; - /** [Config Option] (String) A custom error message to display in place of the default message provided for the vtype currently set for this field. ... */ - vtypeText?: string; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Automatically grows the field to accomodate the width of the text up to the maximum field width allowed */ - autoSize?(): void; - /** [Method] private Template method to do any pre focus processing - * @param e Ext.IEventObject The event object - */ - beforeFocus?( e?:Ext.IEventObject ): void; - /** [Method] Validates a value according to the field s validation rules and returns an array of errors for any failing validations - * @param value Object The value to validate. The processed raw value will be used if nothing is passed. - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the raw String value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Performs any necessary manipulation of a raw String value to prepare it for conversion and or validation - * @param value String The unprocessed string value - */ - processRawValue?( value?:string ): string; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Selects text in this field - * @param start Number The index where the selection should start - * @param end Number The index where the selection should end (defaults to the text length) - */ - selectText?( start?:number, end?:number ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - } -} -declare module Ext.form { - export interface IText extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Specify false to validate that the value's length must be > 0. ... */ - allowBlank?: boolean; - /** [Config Option] (Boolean) Specify false to automatically trim the value before validating the whether the value is blank. ... */ - allowOnlyWhitespace?: boolean; - /** [Config Option] (String) The error text to display if the allowBlank validation fails ... */ - blankText?: string; - /** [Config Option] (Boolean) Specify true to disable input keystroke filtering ... */ - disableKeyFilter?: boolean; - /** [Config Option] (String) The CSS class to apply to an empty field to style the emptyText. ... */ - emptyCls?: string; - /** [Config Option] (String) The default text to place into an empty field. ... */ - emptyText?: string; - /** [Config Option] (Boolean) true to enable the proxying of key events for the HTML input field ... */ - enableKeyEvents?: boolean; - /** [Config Option] (Boolean) True to set the maxLength property on the underlying input field. ... */ - enforceMaxLength?: boolean; - /** [Config Option] (Boolean) true if this field should automatically grow and shrink to its content ... */ - grow?: boolean; - /** [Config Option] (String) A string that will be appended to the field's current value for the purposes of calculating the target field size. ... */ - growAppend?: string; - /** [Config Option] (Number) The maximum width to allow when grow = true ... */ - growMax?: number; - /** [Config Option] (Number) The minimum width to allow when grow = true ... */ - growMin?: number; - /** [Config Option] (RegExp) An input mask regular expression that will be used to filter keystrokes (character being typed) that do not match. ... */ - maskRe?: RegExp; - /** [Config Option] (Number) Maximum input field length allowed by validation. ... */ - maxLength?: number; - /** [Config Option] (String) Error text to display if the maximum length validation fails ... */ - maxLengthText?: string; - /** [Config Option] (Number) Minimum input field length required ... */ - minLength?: number; - /** [Config Option] (String) Error text to display if the minimum length validation fails. ... */ - minLengthText?: string; - /** [Config Option] (RegExp) A JavaScript RegExp object to be tested against the field value during validation. ... */ - regex?: RegExp; - /** [Config Option] (String) The error text to display if regex is used and the test fails during validation ... */ - regexText?: string; - /** [Config Option] (String) The CSS class to apply to a required field, i.e. ... */ - requiredCls?: string; - /** [Config Option] (Boolean) true to automatically select any existing field text when the field receives input focus ... */ - selectOnFocus?: boolean; - /** [Config Option] (Number) An initial value for the 'size' attribute on the text input element. ... */ - size?: number; - /** [Config Option] (RegExp) A JavaScript RegExp object used to strip unwanted content from the value during input. ... */ - stripCharsRe?: RegExp; - /** [Config Option] (Boolean) Specify as true to modify the behaviour of allowBlank so that blank values are not passed as valid, but are subject t... */ - validateBlank?: boolean; - /** [Config Option] (Function) A custom validation function to be called during field validation (getErrors). ... */ - validator?: any; - /** [Config Option] (String) */ - vtype?: string; - /** [Config Option] (String) A custom error message to display in place of the default message provided for the vtype currently set for this field. ... */ - vtypeText?: string; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Automatically grows the field to accomodate the width of the text up to the maximum field width allowed */ - autoSize?(): void; - /** [Method] private Template method to do any pre focus processing - * @param e Ext.IEventObject The event object - */ - beforeFocus?( e?:Ext.IEventObject ): void; - /** [Method] Validates a value according to the field s validation rules and returns an array of errors for any failing validations - * @param value Object The value to validate. The processed raw value will be used if nothing is passed. - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the raw String value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Performs any necessary manipulation of a raw String value to prepare it for conversion and or validation - * @param value String The unprocessed string value - */ - processRawValue?( value?:string ): string; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Selects text in this field - * @param start Number The index where the selection should start - * @param end Number The index where the selection should end (defaults to the text length) - */ - selectText?( start?:number, end?:number ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - } -} -declare module Ext.form { - export interface ITextField extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Specify false to validate that the value's length must be > 0. ... */ - allowBlank?: boolean; - /** [Config Option] (Boolean) Specify false to automatically trim the value before validating the whether the value is blank. ... */ - allowOnlyWhitespace?: boolean; - /** [Config Option] (String) The error text to display if the allowBlank validation fails ... */ - blankText?: string; - /** [Config Option] (Boolean) Specify true to disable input keystroke filtering ... */ - disableKeyFilter?: boolean; - /** [Config Option] (String) The CSS class to apply to an empty field to style the emptyText. ... */ - emptyCls?: string; - /** [Config Option] (String) The default text to place into an empty field. ... */ - emptyText?: string; - /** [Config Option] (Boolean) true to enable the proxying of key events for the HTML input field ... */ - enableKeyEvents?: boolean; - /** [Config Option] (Boolean) True to set the maxLength property on the underlying input field. ... */ - enforceMaxLength?: boolean; - /** [Config Option] (Boolean) true if this field should automatically grow and shrink to its content ... */ - grow?: boolean; - /** [Config Option] (String) A string that will be appended to the field's current value for the purposes of calculating the target field size. ... */ - growAppend?: string; - /** [Config Option] (Number) The maximum width to allow when grow = true ... */ - growMax?: number; - /** [Config Option] (Number) The minimum width to allow when grow = true ... */ - growMin?: number; - /** [Config Option] (RegExp) An input mask regular expression that will be used to filter keystrokes (character being typed) that do not match. ... */ - maskRe?: RegExp; - /** [Config Option] (Number) Maximum input field length allowed by validation. ... */ - maxLength?: number; - /** [Config Option] (String) Error text to display if the maximum length validation fails ... */ - maxLengthText?: string; - /** [Config Option] (Number) Minimum input field length required ... */ - minLength?: number; - /** [Config Option] (String) Error text to display if the minimum length validation fails. ... */ - minLengthText?: string; - /** [Config Option] (RegExp) A JavaScript RegExp object to be tested against the field value during validation. ... */ - regex?: RegExp; - /** [Config Option] (String) The error text to display if regex is used and the test fails during validation ... */ - regexText?: string; - /** [Config Option] (String) The CSS class to apply to a required field, i.e. ... */ - requiredCls?: string; - /** [Config Option] (Boolean) true to automatically select any existing field text when the field receives input focus ... */ - selectOnFocus?: boolean; - /** [Config Option] (Number) An initial value for the 'size' attribute on the text input element. ... */ - size?: number; - /** [Config Option] (RegExp) A JavaScript RegExp object used to strip unwanted content from the value during input. ... */ - stripCharsRe?: RegExp; - /** [Config Option] (Boolean) Specify as true to modify the behaviour of allowBlank so that blank values are not passed as valid, but are subject t... */ - validateBlank?: boolean; - /** [Config Option] (Function) A custom validation function to be called during field validation (getErrors). ... */ - validator?: any; - /** [Config Option] (String) */ - vtype?: string; - /** [Config Option] (String) A custom error message to display in place of the default message provided for the vtype currently set for this field. ... */ - vtypeText?: string; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Automatically grows the field to accomodate the width of the text up to the maximum field width allowed */ - autoSize?(): void; - /** [Method] private Template method to do any pre focus processing - * @param e Ext.IEventObject The event object - */ - beforeFocus?( e?:Ext.IEventObject ): void; - /** [Method] Validates a value according to the field s validation rules and returns an array of errors for any failing validations - * @param value Object The value to validate. The processed raw value will be used if nothing is passed. - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the raw String value of the field without performing any normalization conversion or validation */ - getRawValue?(): string; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] private Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] private Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Performs any necessary manipulation of a raw String value to prepare it for conversion and or validation - * @param value String The unprocessed string value - */ - processRawValue?( value?:string ): string; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): void; - /** [Method] Selects text in this field - * @param start Number The index where the selection should start - * @param end Number The index where the selection should end (defaults to the text length) - */ - selectText?( start?:number, end?:number ): void; - /** [Method] Sets a data value into the field and runs the change detection and validation - * @param value Object The value to set - */ - setValue?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface ITextArea extends Ext.form.field.IText { - /** [Config Option] (Number) An initial value for the 'cols' attribute on the textarea element. ... */ - cols?: number; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (Boolean) True if you want the ENTER key to be classed as a special key and the specialkey event to be fired when ENTER is pres... */ - enterIsSpecial?: boolean; - /** [Config Option] (String) A string that will be appended to the field's current value for the purposes of calculating the target field size. ... */ - growAppend?: string; - /** [Config Option] (Number) The maximum height to allow when grow=true ... */ - growMax?: number; - /** [Config Option] (Number) The minimum height to allow when grow=true ... */ - growMin?: number; - /** [Config Option] (Boolean) true to prevent scrollbars from appearing regardless of how much text is in the field. ... */ - preventScrollbars?: boolean; - /** [Config Option] (Number) An initial value for the 'rows' attribute on the textarea element. ... */ - rows?: number; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Automatically grows the field to accomodate the height of the text up to the maximum field height allowed */ - autoSize?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] private Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] The following overrides deal with an issue whereby some browsers will strip carriage returns from the textarea input - * @param value Object The value - */ - transformRawValue?( value?:any ): any; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface ITextArea extends Ext.form.field.IText { - /** [Config Option] (Number) An initial value for the 'cols' attribute on the textarea element. ... */ - cols?: number; - /** [Config Option] (String/Object) private The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layou... */ - componentLayout?: any; - /** [Config Option] (Boolean) True if you want the ENTER key to be classed as a special key and the specialkey event to be fired when ENTER is pres... */ - enterIsSpecial?: boolean; - /** [Config Option] (String) A string that will be appended to the field's current value for the purposes of calculating the target field size. ... */ - growAppend?: string; - /** [Config Option] (Number) The maximum height to allow when grow=true ... */ - growMax?: number; - /** [Config Option] (Number) The minimum height to allow when grow=true ... */ - growMin?: number; - /** [Config Option] (Boolean) true to prevent scrollbars from appearing regardless of how much text is in the field. ... */ - preventScrollbars?: boolean; - /** [Config Option] (Number) An initial value for the 'rows' attribute on the textarea element. ... */ - rows?: number; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Automatically grows the field to accomodate the height of the text up to the maximum field height allowed */ - autoSize?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] private Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] Allows for any necessary modifications before the original value is set - * @param value Object The initial value - */ - transformOriginalValue?( value?:any ): any; - /** [Method] The following overrides deal with an issue whereby some browsers will strip carriage returns from the textarea input - * @param value Object The value - */ - transformRawValue?( value?:any ): any; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface ITime extends Ext.form.field.IComboBox { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String) The underlying data field name to bind to this ComboBox. ... */ - displayField?: string; - /** [Config Option] (String) The default time format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Number) The number of minutes between each time value in the list. ... */ - increment?: number; - /** [Config Option] (String) The error text to display when the time in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (String) The error text to display when the entered time is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed time. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the entered time is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed time. ... */ - minValue?: any; - /** [Config Option] (Number) The maximum height of the Ext.picker.Time dropdown. ... */ - pickerMaxHeight?: number; - /** [Config Option] (String) The mode in which the ComboBox uses the configured Store. ... */ - queryMode?: string; - /** [Config Option] (Boolean) Whether the Tab key should select the currently highlighted item. ... */ - selectOnTab?: boolean; - /** [Config Option] (Boolean) Specify as true to enforce that only values on the increment boundary are accepted. ... */ - snapToIncrement?: boolean; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The underlying data value name to bind to this ComboBox. ... */ - valueField?: string; - /** [Method] Runs all of Time s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new time and refreshes the picker s range - * @param value String The maximum time that can be selected - */ - setMaxValue?( value?:string ): void; - /** [Method] Replaces any existing minValue with the new time and refreshes the picker s range - * @param value String The minimum time that can be selected - */ - setMinValue?( value?:string ): void; - /** [Method] Sets the specified value s into the field - * @param value any The value(s) to be set. Can be either a single String or Ext.data.Model, or an Array of Strings or Models. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): any; - setValue?( value?:string[] ): any; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface ITime extends Ext.form.field.IComboBox { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String) The underlying data field name to bind to this ComboBox. ... */ - displayField?: string; - /** [Config Option] (String) The default time format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Number) The number of minutes between each time value in the list. ... */ - increment?: number; - /** [Config Option] (String) The error text to display when the time in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (String) The error text to display when the entered time is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed time. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the entered time is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed time. ... */ - minValue?: any; - /** [Config Option] (Number) The maximum height of the Ext.picker.Time dropdown. ... */ - pickerMaxHeight?: number; - /** [Config Option] (String) The mode in which the ComboBox uses the configured Store. ... */ - queryMode?: string; - /** [Config Option] (Boolean) Whether the Tab key should select the currently highlighted item. ... */ - selectOnTab?: boolean; - /** [Config Option] (Boolean) Specify as true to enforce that only values on the increment boundary are accepted. ... */ - snapToIncrement?: boolean; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The underlying data value name to bind to this ComboBox. ... */ - valueField?: string; - /** [Method] Runs all of Time s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new time and refreshes the picker s range - * @param value String The maximum time that can be selected - */ - setMaxValue?( value?:string ): void; - /** [Method] Replaces any existing minValue with the new time and refreshes the picker s range - * @param value String The minimum time that can be selected - */ - setMinValue?( value?:string ): void; - /** [Method] Sets the specified value s into the field - * @param value any The value(s) to be set. Can be either a single String or Ext.data.Model, or an Array of Strings or Models. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): any; - setValue?( value?:string[] ): any; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form { - export interface ITimeField extends Ext.form.field.IComboBox { - /** [Config Option] (String) Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined format. ... */ - altFormats?: string; - /** [Config Option] (String) The underlying data field name to bind to this ComboBox. ... */ - displayField?: string; - /** [Config Option] (String) The default time format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Number) The number of minutes between each time value in the list. ... */ - increment?: number; - /** [Config Option] (String) The error text to display when the time in the field is invalid. ... */ - invalidText?: string; - /** [Config Option] (String) The error text to display when the entered time is after maxValue. ... */ - maxText?: string; - /** [Config Option] (Date/String) The maximum allowed time. ... */ - maxValue?: any; - /** [Config Option] (String) The error text to display when the entered time is before minValue. ... */ - minText?: string; - /** [Config Option] (Date/String) The minimum allowed time. ... */ - minValue?: any; - /** [Config Option] (Number) The maximum height of the Ext.picker.Time dropdown. ... */ - pickerMaxHeight?: number; - /** [Config Option] (String) The mode in which the ComboBox uses the configured Store. ... */ - queryMode?: string; - /** [Config Option] (Boolean) Whether the Tab key should select the currently highlighted item. ... */ - selectOnTab?: boolean; - /** [Config Option] (Boolean) Specify as true to enforce that only values on the increment boundary are accepted. ... */ - snapToIncrement?: boolean; - /** [Config Option] (String) The date format string which will be submitted to the server. ... */ - submitFormat?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The underlying data value name to bind to this ComboBox. ... */ - valueField?: string; - /** [Method] Runs all of Time s validations and returns an array of any errors - * @param value Object The value to get errors for (defaults to the current field value) - */ - getErrors?( value?:any ): string[]; - /** [Method] Returns the current data value of the field */ - getValue?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method to do any post blur processing - * @param e Ext.IEventObject The event object - */ - postBlur?( e?:Ext.IEventObject ): void; - /** [Method] Converts a raw input field value into a mixed type value that is suitable for this particular field type - * @param rawValue Object - */ - rawToValue?( rawValue?:any ): any; - /** [Method] Replaces any existing maxValue with the new time and refreshes the picker s range - * @param value String The maximum time that can be selected - */ - setMaxValue?( value?:string ): void; - /** [Method] Replaces any existing minValue with the new time and refreshes the picker s range - * @param value String The minimum time that can be selected - */ - setMinValue?( value?:string ): void; - /** [Method] Sets the specified value s into the field - * @param value any The value(s) to be set. Can be either a single String or Ext.data.Model, or an Array of Strings or Models. - */ - setValue?( value?:any ): any; - setValue?( value?:string ): any; - setValue?( value?:string[] ): any; - /** [Method] Converts a mixed type value to a raw representation suitable for displaying in the field - * @param value Object The mixed-type value to convert to the raw representation. - */ - valueToRaw?( value?:any ): any; - } -} -declare module Ext.form.field { - export interface ITrigger extends Ext.form.field.IText { - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) false to prevent the user from typing text directly into the field; the field can only have its value set via an acti... */ - editable?: boolean; - /** [Config Option] (Boolean) true to hide the trigger element and display only the base text field ... */ - hideTrigger?: boolean; - /** [Config Option] (Boolean) true to prevent the user from changing the field, and hides the trigger. ... */ - readOnly?: boolean; - /** [Config Option] (Boolean) true to attach a click repeater to the trigger. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) true to select any existing text in the field immediately on focus. ... */ - selectOnFocus?: boolean; - /** [Config Option] (String) The base CSS class that is always added to the trigger button. ... */ - triggerBaseCls?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The CSS class that is added to the text field when component is read-only or not editable. ... */ - triggerNoEditCls?: string; - /** [Config Option] (String) The CSS class that is added to the div wrapping the trigger button(s). ... */ - triggerWrapCls?: string; - /** [Property] (Ext.Element) A reference to the TD element wrapping the input element. ... */ - inputCell?: Ext.IElement; - /** [Property] (Ext.CompositeElement) A composite of all the trigger button elements. ... */ - triggerEl?: Ext.ICompositeElement; - /** [Property] (Ext.Element) A reference to the TABLE element which encapsulates the input field and all trigger button(s). ... */ - triggerWrap?: Ext.IElement; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the trigger button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] The function that should handle the trigger s click event - * @param e Ext.IEventObject - */ - onTriggerClick?( e?:Ext.IEventObject ): void; - /** [Method] Sets the editable state of this field - * @param editable Boolean True to allow the user to directly edit the field text. If false is passed, the user will only be able to modify the field using the trigger. Will also add a click event to the text field which will call the trigger. - */ - setEditable?( editable?:boolean ): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean True to prevent the user changing the field and explicitly hide the trigger. Setting this to true will supercede settings editable and hideTrigger. Setting this to false will defer back to editable and hideTrigger. - */ - setReadOnly?( readOnly?:boolean ): void; - } -} -declare module Ext.form { - export interface ITrigger extends Ext.form.field.IText { - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) false to prevent the user from typing text directly into the field; the field can only have its value set via an acti... */ - editable?: boolean; - /** [Config Option] (Boolean) true to hide the trigger element and display only the base text field ... */ - hideTrigger?: boolean; - /** [Config Option] (Boolean) true to prevent the user from changing the field, and hides the trigger. ... */ - readOnly?: boolean; - /** [Config Option] (Boolean) true to attach a click repeater to the trigger. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) true to select any existing text in the field immediately on focus. ... */ - selectOnFocus?: boolean; - /** [Config Option] (String) The base CSS class that is always added to the trigger button. ... */ - triggerBaseCls?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The CSS class that is added to the text field when component is read-only or not editable. ... */ - triggerNoEditCls?: string; - /** [Config Option] (String) The CSS class that is added to the div wrapping the trigger button(s). ... */ - triggerWrapCls?: string; - /** [Property] (Ext.Element) A reference to the TD element wrapping the input element. ... */ - inputCell?: Ext.IElement; - /** [Property] (Ext.CompositeElement) A composite of all the trigger button elements. ... */ - triggerEl?: Ext.ICompositeElement; - /** [Property] (Ext.Element) A reference to the TABLE element which encapsulates the input field and all trigger button(s). ... */ - triggerWrap?: Ext.IElement; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the trigger button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] The function that should handle the trigger s click event - * @param e Ext.IEventObject - */ - onTriggerClick?( e?:Ext.IEventObject ): void; - /** [Method] Sets the editable state of this field - * @param editable Boolean True to allow the user to directly edit the field text. If false is passed, the user will only be able to modify the field using the trigger. Will also add a click event to the text field which will call the trigger. - */ - setEditable?( editable?:boolean ): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean True to prevent the user changing the field and explicitly hide the trigger. Setting this to true will supercede settings editable and hideTrigger. Setting this to false will defer back to editable and hideTrigger. - */ - setReadOnly?( readOnly?:boolean ): void; - } -} -declare module Ext.form { - export interface ITriggerField extends Ext.form.field.IText { - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) false to prevent the user from typing text directly into the field; the field can only have its value set via an acti... */ - editable?: boolean; - /** [Config Option] (Boolean) true to hide the trigger element and display only the base text field ... */ - hideTrigger?: boolean; - /** [Config Option] (Boolean) true to prevent the user from changing the field, and hides the trigger. ... */ - readOnly?: boolean; - /** [Config Option] (Boolean) true to attach a click repeater to the trigger. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) true to select any existing text in the field immediately on focus. ... */ - selectOnFocus?: boolean; - /** [Config Option] (String) The base CSS class that is always added to the trigger button. ... */ - triggerBaseCls?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The CSS class that is added to the text field when component is read-only or not editable. ... */ - triggerNoEditCls?: string; - /** [Config Option] (String) The CSS class that is added to the div wrapping the trigger button(s). ... */ - triggerWrapCls?: string; - /** [Property] (Ext.Element) A reference to the TD element wrapping the input element. ... */ - inputCell?: Ext.IElement; - /** [Property] (Ext.CompositeElement) A composite of all the trigger button elements. ... */ - triggerEl?: Ext.ICompositeElement; - /** [Property] (Ext.Element) A reference to the TABLE element which encapsulates the input field and all trigger button(s). ... */ - triggerWrap?: Ext.IElement; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the trigger button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] The function that should handle the trigger s click event - * @param e Ext.IEventObject - */ - onTriggerClick?( e?:Ext.IEventObject ): void; - /** [Method] Sets the editable state of this field - * @param editable Boolean True to allow the user to directly edit the field text. If false is passed, the user will only be able to modify the field using the trigger. Will also add a click event to the text field which will call the trigger. - */ - setEditable?( editable?:boolean ): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean True to prevent the user changing the field and explicitly hide the trigger. Setting this to true will supercede settings editable and hideTrigger. Setting this to false will defer back to editable and hideTrigger. - */ - setReadOnly?( readOnly?:boolean ): void; - } -} -declare module Ext.form { - export interface ITwinTriggerField extends Ext.form.field.IText { - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) false to prevent the user from typing text directly into the field; the field can only have its value set via an acti... */ - editable?: boolean; - /** [Config Option] (Boolean) true to hide the trigger element and display only the base text field ... */ - hideTrigger?: boolean; - /** [Config Option] (Boolean) true to prevent the user from changing the field, and hides the trigger. ... */ - readOnly?: boolean; - /** [Config Option] (Boolean) true to attach a click repeater to the trigger. ... */ - repeatTriggerClick?: boolean; - /** [Config Option] (Boolean) true to select any existing text in the field immediately on focus. ... */ - selectOnFocus?: boolean; - /** [Config Option] (String) The base CSS class that is always added to the trigger button. ... */ - triggerBaseCls?: string; - /** [Config Option] (String) An additional CSS class used to style the trigger button. ... */ - triggerCls?: string; - /** [Config Option] (String) The CSS class that is added to the text field when component is read-only or not editable. ... */ - triggerNoEditCls?: string; - /** [Config Option] (String) The CSS class that is added to the div wrapping the trigger button(s). ... */ - triggerWrapCls?: string; - /** [Property] (Ext.Element) A reference to the TD element wrapping the input element. ... */ - inputCell?: Ext.IElement; - /** [Property] (Ext.CompositeElement) A composite of all the trigger button elements. ... */ - triggerEl?: Ext.ICompositeElement; - /** [Property] (Ext.Element) A reference to the TABLE element which encapsulates the input field and all trigger button(s). ... */ - triggerWrap?: Ext.IElement; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): void; - /** [Method] Get the total width of the trigger button area */ - getTriggerWidth?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] The function that should handle the trigger s click event - * @param e Ext.IEventObject - */ - onTriggerClick?( e?:Ext.IEventObject ): void; - /** [Method] Sets the editable state of this field - * @param editable Boolean True to allow the user to directly edit the field text. If false is passed, the user will only be able to modify the field using the trigger. Will also add a click event to the text field which will call the trigger. - */ - setEditable?( editable?:boolean ): void; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean True to prevent the user changing the field and explicitly hide the trigger. Setting this to true will supercede settings editable and hideTrigger. Setting this to false will defer back to editable and hideTrigger. - */ - setReadOnly?( readOnly?:boolean ): void; - } -} -declare module Ext.form.field { - export interface IVTypes extends Ext.IBase { - } - export class VTypes { - /** [Method] The function used to validate alpha values - * @param value String The value - */ - static alpha( value?:string ): boolean; - /** [Method] The function used to validate alphanumeric values - * @param value String The value - */ - static alphanum( value?:string ): boolean; - /** [Method] The function used to validate email addresses - * @param value String The email address - */ - static email( value?:string ): boolean; - /** [Method] The function used to validate URLs - * @param value String The URL - */ - static url( value?:string ): boolean; - } -} -declare module Ext.form { - export interface IVTypes extends Ext.IBase { - } - export class VTypes { - /** [Method] The function used to validate alpha values - * @param value String The value - */ - static alpha( value?:string ): boolean; - /** [Method] The function used to validate alphanumeric values - * @param value String The value - */ - static alphanum( value?:string ): boolean; - /** [Method] The function used to validate email addresses - * @param value String The email address - */ - static email( value?:string ): boolean; - /** [Method] The function used to validate URLs - * @param value String The URL - */ - static url( value?:string ): boolean; - } -} -declare module Ext.form { - export interface IFieldAncestor extends Ext.IBase { - /** [Config Option] (Object) If specified, the properties in this object are used as default config values for each Ext.form.Labelable instance (e.g. ... */ - fieldDefaults?: any; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Fired when the error message of any field within the container changes - * @param field Ext.form.ILabelable The sub-field whose active error changed - * @param error String The new active error message - */ - onFieldErrorChange?( field?:Ext.form.ILabelable, error?:string ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - } -} -declare module Ext.form { - export interface IFieldContainer extends Ext.container.IContainer,Ext.form.IFieldAncestor,Ext.form.ILabelable { - /** [Config Option] (Boolean) If set to true, the field container will automatically combine and display the validation errors from all the fields ... */ - combineErrors?: boolean; - /** [Config Option] (Boolean) If set to true, and there is no defined fieldLabel, the field container will automatically generate its label by comb... */ - combineLabels?: boolean; - /** [Config Option] (String) CSS Class to be added to a components root level element to give distinction to it via styling. ... */ - componentCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The string to use when joining the labels of individual sub-fields, when combineLabels is set to true. ... */ - labelConnector?: string; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Method] Gets the active error message for this component if any */ - getActiveError?(): string; - /** [Method] Gets an Array of any active error messages currently applied to the field */ - getActiveErrors?(): string[]; - /** [Method] Takes an Array of invalid Ext form field Field objects and builds a combined list of error messages from them - * @param invalidFields Ext.form.field.IField[] An Array of the sub-fields which are currently invalid. - */ - getCombinedErrors?( invalidFields?:Ext.form.field.IField[] ): string[]; - /** [Method] Returns the combined field label if combineLabels is set to true and if there is no set fieldLabel */ - getFieldLabel?(): string; - /** [Method] Get the input id if any for this component */ - getInputId?(): string; - /** [Method] Gets the width of the label if visible */ - getLabelWidth?(): number; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): string; - /** [Method] Tells whether the field currently has an active error message */ - hasActiveError?(): boolean; - /** [Method] Checks if the field has a visible label */ - hasVisibleLabel?(): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Performs initialization of this mixin */ - initLabelable?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Called when a Ext form Labelable instance is added to the container s subtree - * @param labelable Ext.form.ILabelable The instance that was added - */ - onAdd?( labelable?:Ext.form.ILabelable ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - /** [Method] Called when a Ext form Labelable instance is removed from the container s subtree - * @param labelable Ext.form.ILabelable The instance that was removed - */ - onRemove?( labelable?:Ext.form.ILabelable ): void; - /** [Method] Sets the active error message to the given string - * @param msg String The error message - */ - setActiveError?( msg?:string ): void; - /** [Method] Set the active error message to an Array of error messages - * @param errors String[] The error messages - */ - setActiveErrors?( errors?:string[] ): void; - /** [Method] Applies a set of default configuration values to this Labelable instance - * @param defaults Object The defaults to apply to the object. - */ - setFieldDefaults?( defaults?:any ): void; - /** [Method] Set the label of this field - * @param label String The new label. The labelSeparator will be automatically appended to the label string. - */ - setFieldLabel?( label?:string ): void; - /** [Method] Returns the trimmed label by slicing off the label separator character */ - trimLabelSeparator?(): string; - /** [Method] Clears the active error message s */ - unsetActiveError?(): void; - } -} -declare module Ext.form { - export interface IFieldSet extends Ext.container.IContainer,Ext.form.IFieldAncestor { - /** [Config Option] (String/Object) A tag name or DomHelper spec used to create the Element which will encapsulate this Component. ... */ - autoEl?: any; - /** [Config Option] (String) The base CSS class applied to the fieldset. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String) */ - checkboxName?: string; - /** [Config Option] (Boolean) Set to true to render a checkbox into the fieldset frame just in front of the legend to expand/collapse the fieldset ... */ - checkboxToggle?: boolean; - /** [Config Option] (Boolean) Set to true to render the fieldset as collapsed by default. ... */ - collapsed?: boolean; - /** [Config Option] (Boolean) Set to true to make the fieldset collapsible and have the expand/collapse toggle button automatically rendered into t... */ - collapsible?: boolean; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Ext.enums.Layout/Object) The Ext.container.Container.layout for the fieldset's immediate child items. ... */ - layout?: any; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String[]) An array of events that, when fired, should trigger this object to save its state. ... */ - stateEvents?: string[]; - /** [Config Option] (String) A title to be displayed in the fieldset's legend. ... */ - title?: string; - /** [Config Option] (Boolean) Set to true will add a listener to the titleCmp property for the click event which will execute the toggle method. ... */ - toggleOnTitleClick?: boolean; - /** [Property] (Ext.form.field.Checkbox) Refers to the Ext.form.field.Checkbox component that is added next to the title in the legend. ... */ - checkboxCmp?: Ext.form.field.ICheckbox; - /** [Property] (Ext.Component) The component for the fieldset's legend. ... */ - legend?: Ext.IComponent; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Property] (Ext.panel.Tool) Refers to the Ext.panel.Tool component that is added as the collapse/expand button next to the title in the legend. ... */ - toggleCmp?: Ext.panel.ITool; - /** [Method] Collapses the fieldset */ - collapse?(): Ext.form.IFieldSet; - /** [Method] Creates the checkbox component */ - createCheckboxCmp?(): Ext.IComponent; - /** [Method] Creates the legend title component */ - createTitleCmp?(): Ext.IComponent; - /** [Method] Creates the toggle button component */ - createToggleCmp?(): Ext.IComponent; - /** [Method] Expands the fieldset */ - expand?(): Ext.form.IFieldSet; - /** [Method] Used by ComponentQuery child and down to retrieve all of the items which can potentially be considered a child of th - * @param deep Object - */ - getRefItems?( deep?:any ): void; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Fired when the error message of any field within the container changes - * @param field Ext.form.ILabelable The sub-field whose active error changed - * @param error String The new active error message - */ - onFieldErrorChange?( field?:Ext.form.ILabelable, error?:string ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - /** [Method] Sets the title of this fieldset - * @param title String The new title. - */ - setTitle?( title?:string ): Ext.form.IFieldSet; - /** [Method] Toggle the fieldset s collapsed state to the opposite of what it is currently */ - toggle?(): void; - } -} -declare module Ext.form { - export interface ILabel extends Ext.IComponent { - /** [Config Option] (String/Object) A tag name or DomHelper spec used to create the Element which will encapsulate this Component. ... */ - autoEl?: any; - /** [Config Option] (String) The id of the input element to which this label will be bound via the standard HTML 'for' attribute. ... */ - forId?: string; - /** [Config Option] (String) An HTML fragment that will be used as the label's innerHTML. ... */ - html?: string; - /** [Config Option] (String) The plain text to display within the label. ... */ - text?: string; - /** [Method] Updates the label s innerHTML with the specified string - * @param text String The new label text - * @param encode Boolean False to skip HTML-encoding the text when rendering it to the label. This might be useful if you want to include tags in the label's innerHTML rather than rendering them as string literals per the default logic. - */ - setText?( text?:string, encode?:boolean ): Ext.form.ILabel; - } -} -declare module Ext.form { - export interface ILabelable extends Ext.IBase { - /** [Config Option] (String) If specified, then the component will be displayed with this value as its active error when first rendered. ... */ - activeError?: string; - /** [Config Option] (String/String[]/Ext.XTemplate) The template used to format the Array of error messages passed to setActiveErrors into a single HTML string. ... */ - activeErrorsTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup at the end of the input containing element. ... */ - afterBodyEl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the label text. ... */ - afterLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the label element. ... */ - afterLabelTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup after the subTpl markup. ... */ - afterSubTpl?: any; - /** [Config Option] (Boolean) Whether to adjust the component's body area to make room for 'side' or 'under' error messages. ... */ - autoFitErrors?: boolean; - /** [Config Option] (String) The CSS class to be applied to the body content element. ... */ - baseBodyCls?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup at the beginning of the input containing ... */ - beforeBodyEl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the label text. ... */ - beforeLabelTextTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the label element. ... */ - beforeLabelTpl?: any; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup before the subTpl markup. ... */ - beforeSubTpl?: any; - /** [Config Option] (String) The CSS class to be applied to the special clearing div rendered directly after the field contents wrapper to provide... */ - clearCls?: string; - /** [Config Option] (String) The CSS class to be applied to the error message element. ... */ - errorMsgCls?: string; - /** [Config Option] (String) An extra CSS class to be applied to the body content element in addition to baseBodyCls. ... */ - fieldBodyCls?: string; - /** [Config Option] (String) The label for the field. ... */ - fieldLabel?: string; - /** [Config Option] (String) A CSS class to be applied to the outermost element to denote that it is participating in the form field layout. ... */ - formItemCls?: string; - /** [Config Option] (Boolean) When set to true, the label element (fieldLabel and labelSeparator) will be automatically hidden if the fieldLabel is... */ - hideEmptyLabel?: boolean; - /** [Config Option] (Boolean) Set to true to completely hide the label element (fieldLabel and labelSeparator). ... */ - hideLabel?: boolean; - /** [Config Option] (String) The CSS class to use when marking the component invalid. ... */ - invalidCls?: string; - /** [Config Option] (String) Controls the position and alignment of the fieldLabel. ... */ - labelAlign?: string; - /** [Config Option] (String/Array/Ext.XTemplate) An optional string or XTemplate configuration to insert in the field markup inside the label element (as attributes). ... */ - labelAttrTpl?: any; - /** [Config Option] (String) The CSS class to be applied to the label element. ... */ - labelCls?: string; - /** [Config Option] (String) An optional string of one or more additional CSS classes to add to the label element. ... */ - labelClsExtra?: string; - /** [Config Option] (Number) The amount of space in pixels between the fieldLabel and the input field. ... */ - labelPad?: number; - /** [Config Option] (String) Character(s) to be inserted at the end of the label text. ... */ - labelSeparator?: string; - /** [Config Option] (String) */ - labelStyle?: string; - /** [Config Option] (Number) The width of the fieldLabel in pixels. ... */ - labelWidth?: number; - /** [Config Option] (String) The location where the error message text should display. ... */ - msgTarget?: string; - /** [Config Option] (Boolean) true to disable displaying any error message set on this object. ... */ - preventMark?: boolean; - /** [Property] (Ext.Element) The div Element wrapping the component's contents. ... */ - bodyEl?: Ext.IElement; - /** [Property] (Ext.Element) The div Element that will contain the component's error message(s). ... */ - errorEl?: Ext.IElement; - /** [Property] (Boolean) Flag denoting that this object is labelable as a field. ... */ - isFieldLabelable?: boolean; - /** [Property] (Ext.Element) The <TD> Element which contains the label Element for this component. ... */ - labelCell?: Ext.IElement; - /** [Property] (Ext.Element) The label Element for this component. ... */ - labelEl?: Ext.IElement; - /** [Method] Gets the active error message for this component if any */ - getActiveError?(): string; - /** [Method] Gets an Array of any active error messages currently applied to the field */ - getActiveErrors?(): string[]; - /** [Method] Returns the label for the field */ - getFieldLabel?(): string; - /** [Method] Get the input id if any for this component */ - getInputId?(): any; - /** [Method] Gets the width of the label if visible */ - getLabelWidth?(): number; - /** [Method] Generates the arguments for the field decorations rendering template */ - getLabelableRenderData?(): any; - /** [Method] Gets the markup to be inserted into the outer template s bodyEl */ - getSubTplMarkup?(): any; - /** [Method] Tells whether the field currently has an active error message */ - hasActiveError?(): boolean; - /** [Method] Checks if the field has a visible label */ - hasVisibleLabel?(): boolean; - /** [Method] Performs initialization of this mixin */ - initLabelable?(): void; - /** [Method] Sets the active error message to the given string - * @param msg String The error message - */ - setActiveError?( msg?:string ): void; - /** [Method] Set the active error message to an Array of error messages - * @param errors String[] The error messages - */ - setActiveErrors?( errors?:string[] ): void; - /** [Method] Applies a set of default configuration values to this Labelable instance - * @param defaults Object The defaults to apply to the object. - */ - setFieldDefaults?( defaults?:any ): void; - /** [Method] Set the label of this field - * @param label String The new label. The labelSeparator will be automatically appended to the label string. - */ - setFieldLabel?( label?:string ): void; - /** [Method] Returns the trimmed label by slicing off the label separator character */ - trimLabelSeparator?(): string; - /** [Method] Clears the active error message s */ - unsetActiveError?(): void; - } -} -declare module Ext.form { - export interface IPanel extends Ext.panel.IPanel,Ext.form.IFieldAncestor { - /** [Config Option] (Ext.enums.Layout/Object) The Ext.container.Container.layout for the form panel's immediate child items. ... */ - layout?: any; - /** [Config Option] (Boolean) If set to true, sets up an interval task (using the pollInterval) in which the panel's fields are repeatedly checked ... */ - pollForChanges?: boolean; - /** [Config Option] (Number) Interval in milliseconds at which the form's fields are checked for value changes. ... */ - pollInterval?: number; - /** [Method] Forces each field within the form panel to check if its value has changed */ - checkChange?(): void; - /** [Method] Provides access to the Form which this Panel contains */ - getForm?(): Ext.form.IBasic; - /** [Method] Returns the currently loaded Ext data Model instance if one was loaded via loadRecord */ - getRecord?(): Ext.data.IModel; - /** [Method] Convenience function for fetching the current value of each field in the form - * @param asString Boolean If true, will return the key/value collection as a single URL-encoded param string. - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - * @param includeEmptyText Boolean If true, the configured emptyText of empty fields will be used. - * @param useDataValues Boolean If true, the getModelData method is used to retrieve values from fields, otherwise the getSubmitData method is used. - */ - getValues?( asString?:boolean, dirtyOnly?:boolean, includeEmptyText?:boolean, useDataValues?:boolean ): any; - /** [Method] Convenience function to check if the form has any invalid fields */ - hasInvalidField?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Convenience function to check if the form has any dirty fields */ - isDirty?(): boolean; - /** [Method] Convenience function to check if the form has all valid fields */ - isValid?(): boolean; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic load call - * @param options Object The options to pass to the action (see Ext.form.Basic.load and Ext.form.Basic.doAction for details) - */ - load?( options?:any ): void; - /** [Method] Loads an Ext data Model into this form internally just calls Ext form Basic loadRecord See also trackResetOnLoad - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Fired when the error message of any field within the container changes - * @param field Ext.form.ILabelable The sub-field whose active error changed - * @param error String The new active error message - */ - onFieldErrorChange?( field?:Ext.form.ILabelable, error?:string ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - /** [Method] Start an interval task to continuously poll all the fields in the form for changes in their values - * @param interval Number The interval in milliseconds at which the check should run. - */ - startPolling?( interval?:number ): void; - /** [Method] Stop a running interval task that was started by startPolling */ - stopPolling?(): void; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic submit call - * @param options Object The options to pass to the action (see Ext.form.Basic.submit and Ext.form.Basic.doAction for details) - */ - submit?( options?:any ): void; - } -} -declare module Ext { - export interface IFormPanel extends Ext.panel.IPanel,Ext.form.IFieldAncestor { - /** [Config Option] (Ext.enums.Layout/Object) The Ext.container.Container.layout for the form panel's immediate child items. ... */ - layout?: any; - /** [Config Option] (Boolean) If set to true, sets up an interval task (using the pollInterval) in which the panel's fields are repeatedly checked ... */ - pollForChanges?: boolean; - /** [Config Option] (Number) Interval in milliseconds at which the form's fields are checked for value changes. ... */ - pollInterval?: number; - /** [Method] Forces each field within the form panel to check if its value has changed */ - checkChange?(): void; - /** [Method] Provides access to the Form which this Panel contains */ - getForm?(): Ext.form.IBasic; - /** [Method] Returns the currently loaded Ext data Model instance if one was loaded via loadRecord */ - getRecord?(): Ext.data.IModel; - /** [Method] Convenience function for fetching the current value of each field in the form - * @param asString Boolean If true, will return the key/value collection as a single URL-encoded param string. - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - * @param includeEmptyText Boolean If true, the configured emptyText of empty fields will be used. - * @param useDataValues Boolean If true, the getModelData method is used to retrieve values from fields, otherwise the getSubmitData method is used. - */ - getValues?( asString?:boolean, dirtyOnly?:boolean, includeEmptyText?:boolean, useDataValues?:boolean ): any; - /** [Method] Convenience function to check if the form has any invalid fields */ - hasInvalidField?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Convenience function to check if the form has any dirty fields */ - isDirty?(): boolean; - /** [Method] Convenience function to check if the form has all valid fields */ - isValid?(): boolean; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic load call - * @param options Object The options to pass to the action (see Ext.form.Basic.load and Ext.form.Basic.doAction for details) - */ - load?( options?:any ): void; - /** [Method] Loads an Ext data Model into this form internally just calls Ext form Basic loadRecord See also trackResetOnLoad - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Fired when the error message of any field within the container changes - * @param field Ext.form.ILabelable The sub-field whose active error changed - * @param error String The new active error message - */ - onFieldErrorChange?( field?:Ext.form.ILabelable, error?:string ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - /** [Method] Start an interval task to continuously poll all the fields in the form for changes in their values - * @param interval Number The interval in milliseconds at which the check should run. - */ - startPolling?( interval?:number ): void; - /** [Method] Stop a running interval task that was started by startPolling */ - stopPolling?(): void; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic submit call - * @param options Object The options to pass to the action (see Ext.form.Basic.submit and Ext.form.Basic.doAction for details) - */ - submit?( options?:any ): void; - } -} -declare module Ext.form { - export interface IFormPanel extends Ext.panel.IPanel,Ext.form.IFieldAncestor { - /** [Config Option] (Ext.enums.Layout/Object) The Ext.container.Container.layout for the form panel's immediate child items. ... */ - layout?: any; - /** [Config Option] (Boolean) If set to true, sets up an interval task (using the pollInterval) in which the panel's fields are repeatedly checked ... */ - pollForChanges?: boolean; - /** [Config Option] (Number) Interval in milliseconds at which the form's fields are checked for value changes. ... */ - pollInterval?: number; - /** [Method] Forces each field within the form panel to check if its value has changed */ - checkChange?(): void; - /** [Method] Provides access to the Form which this Panel contains */ - getForm?(): Ext.form.IBasic; - /** [Method] Returns the currently loaded Ext data Model instance if one was loaded via loadRecord */ - getRecord?(): Ext.data.IModel; - /** [Method] Convenience function for fetching the current value of each field in the form - * @param asString Boolean If true, will return the key/value collection as a single URL-encoded param string. - * @param dirtyOnly Boolean If true, only fields that are dirty will be included in the result. - * @param includeEmptyText Boolean If true, the configured emptyText of empty fields will be used. - * @param useDataValues Boolean If true, the getModelData method is used to retrieve values from fields, otherwise the getSubmitData method is used. - */ - getValues?( asString?:boolean, dirtyOnly?:boolean, includeEmptyText?:boolean, useDataValues?:boolean ): any; - /** [Method] Convenience function to check if the form has any invalid fields */ - hasInvalidField?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initializes the FieldAncestor s state this must be called from the initComponent method of any components importing */ - initFieldAncestor?(): void; - /** [Method] Convenience function to check if the form has any dirty fields */ - isDirty?(): boolean; - /** [Method] Convenience function to check if the form has all valid fields */ - isValid?(): boolean; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic load call - * @param options Object The options to pass to the action (see Ext.form.Basic.load and Ext.form.Basic.doAction for details) - */ - load?( options?:any ): void; - /** [Method] Loads an Ext data Model into this form internally just calls Ext form Basic loadRecord See also trackResetOnLoad - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Fired when the error message of any field within the container changes - * @param field Ext.form.ILabelable The sub-field whose active error changed - * @param error String The new active error message - */ - onFieldErrorChange?( field?:Ext.form.ILabelable, error?:string ): void; - /** [Method] Fired when the validity of any field within the container changes - * @param field Ext.form.field.IField The sub-field whose validity changed - * @param valid Boolean The new validity state - */ - onFieldValidityChange?( field?:Ext.form.field.IField, valid?:boolean ): void; - /** [Method] Start an interval task to continuously poll all the fields in the form for changes in their values - * @param interval Number The interval in milliseconds at which the check should run. - */ - startPolling?( interval?:number ): void; - /** [Method] Stop a running interval task that was started by startPolling */ - stopPolling?(): void; - /** [Method] This is a proxy for the underlying BasicForm s Ext form Basic submit call - * @param options Object The options to pass to the action (see Ext.form.Basic.submit and Ext.form.Basic.doAction for details) - */ - submit?( options?:any ): void; - } -} -declare module Ext.form { - export interface IRadioGroup extends Ext.form.ICheckboxGroup { - /** [Config Option] (Boolean) True to allow every item in the group to be blank. ... */ - allowBlank?: boolean; - /** [Config Option] (String) Error text to display if the allowBlank validation fails ... */ - blankText?: string; - /** [Config Option] (String) private The default xtype of child Components to create in this Container when a child item is specified as a raw co... */ - defaultType?: string; - /** [Config Option] (Ext.form.field.Radio[]/Object[]) */ - items?: any; - /** [Method] Checks whether the value of the field has changed since the last time it was checked */ - checkChange?(): void; - /** [Method] Sets the value of the radio group - * @param value Object The map from names to values to be set. - */ - setValue?( value?:any ): Ext.form.ICheckboxGroup; - } -} -declare module Ext.form { - export interface IRadioManager extends Ext.util.IMixedCollection { - } - export class RadioManager { - } -} -declare module Ext { - export interface IFunction { - } - export class Function { - /** [Method] Create an alias to the provided method property with name methodName of object - * @param object any - * @param methodName String - */ - static alias( object?:any, methodName?:string ): any; - /** [Method] Create a new function from the provided fn change this to the provided scope optionally overrides arguments for the - * @param fn any The function to delegate. - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the default global environment object (usually the browser window). - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - static bind( fn?:any, scope?:any, args?:any, appendArgs?:any ): any; - static bind( fn?:any, scope?:any, args?:any[], appendArgs?:boolean ): any; - static bind( fn?:any, scope?:any, args?:any[], appendArgs?:number ): any; - /** [Method] Create a clone of the provided method - * @param method Function - */ - static clone( method?:any ): any; - /** [Method] Creates a delegate function optionally with a bound scope which when called buffers the execution of the passed fu - * @param fn Function The function to invoke on a buffered timer. - * @param buffer Number The number of milliseconds by which to buffer the invocation of the function. - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. - * @param args Array Override arguments for the call. Defaults to the arguments passed by the caller. - */ - static createBuffered( fn?:any, buffer?:number, scope?:any, args?:any[] ): any; - /** [Method] Creates a delegate callback which when called executes after a specific delay - * @param fn any The function which will be called on a delay when the returned function is called. Optionally, a replacement (or additional) argument list may be specified. - * @param delay any The number of milliseconds to defer execution by whenever called. - * @param scope any The scope (this reference) used by the function at execution time. - * @param args any Override arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position. - */ - static createDelayed( fn?:any, delay?:any, scope?:any, args?:any, appendArgs?:any ): any; - static createDelayed( fn?:any, delay?:number, scope?:any, args?:any[], appendArgs?:boolean ): any; - static createDelayed( fn?:any, delay?:number, scope?:any, args?:any[], appendArgs?:number ): any; - /** [Method] Creates an interceptor function - * @param origFn Function The original function. - * @param newFn Function The function to call before the original - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope in which the original function is called or the browser window. - * @param returnValue Object The value to return if the passed function return false. - */ - static createInterceptor( origFn?:any, newFn?:any, scope?:any, returnValue?:any ): any; - /** [Method] Create a combined function call sequence of the original function the passed function - * @param originalFn Function The original function. - * @param newFn Function The function to sequence - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope in which the original function is called or the default global environment object (usually the browser window). - */ - static createSequence( originalFn?:any, newFn?:any, scope?:any ): any; - /** [Method] Creates a throttled version of the passed function which when called repeatedly and rapidly invokes the passed func - * @param fn Function The function to execute at a regular time interval. - * @param interval Number The interval in milliseconds on which the passed function is executed. - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. - */ - static createThrottled( fn?:any, interval?:number, scope?:any ): any; - /** [Method] Calls this function after the number of millseconds specified optionally in a specific scope - * @param fn any The function to defer. - * @param millis any The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately) - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the browser window. - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - static defer( fn?:any, millis?:any, scope?:any, args?:any, appendArgs?:any ): any; - static defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:boolean ): number; - static defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:number ): number; - /** [Method] A very commonly used method throughout the framework - * @param setter Function - */ - static flexSetter( setter?:any ): any; - /** [Method] Adds behavior to an existing method that is executed after the original behavior of the function - * @param object Object The target object - * @param methodName String Name of the method to override - * @param fn Function Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method. - * @param scope Object The scope to execute the interceptor function. Defaults to the object. - */ - static interceptAfter( object?:any, methodName?:string, fn?:any, scope?:any ): any; - /** [Method] Adds behavior to an existing method that is executed before the original behavior of the function - * @param object Object The target object - * @param methodName String Name of the method to override - * @param fn Function Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method. - * @param scope Object The scope to execute the interceptor function. Defaults to the object. - */ - static interceptBefore( object?:any, methodName?:string, fn?:any, scope?:any ): any; - /** [Method] Create a new function from the provided fn the arguments of which are pre set to args - * @param fn Function The original function - * @param args Array The arguments to pass to new callback - * @param scope Object The scope (this reference) in which the function is executed. - */ - static pass( fn?:any, args?:any[], scope?:any ): any; - } -} -declare module Ext.util { - export interface IFunctions { - } - export class Functions { - /** [Method] Create an alias to the provided method property with name methodName of object - * @param object any - * @param methodName String - */ - static alias( object?:any, methodName?:string ): any; - /** [Method] Create a new function from the provided fn change this to the provided scope optionally overrides arguments for the - * @param fn any The function to delegate. - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the default global environment object (usually the browser window). - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - static bind( fn?:any, scope?:any, args?:any, appendArgs?:any ): any; - static bind( fn?:any, scope?:any, args?:any[], appendArgs?:boolean ): any; - static bind( fn?:any, scope?:any, args?:any[], appendArgs?:number ): any; - /** [Method] Create a clone of the provided method - * @param method Function - */ - static clone( method?:any ): any; - /** [Method] Creates a delegate function optionally with a bound scope which when called buffers the execution of the passed fu - * @param fn Function The function to invoke on a buffered timer. - * @param buffer Number The number of milliseconds by which to buffer the invocation of the function. - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. - * @param args Array Override arguments for the call. Defaults to the arguments passed by the caller. - */ - static createBuffered( fn?:any, buffer?:number, scope?:any, args?:any[] ): any; - /** [Method] Creates a delegate callback which when called executes after a specific delay - * @param fn any The function which will be called on a delay when the returned function is called. Optionally, a replacement (or additional) argument list may be specified. - * @param delay any The number of milliseconds to defer execution by whenever called. - * @param scope any The scope (this reference) used by the function at execution time. - * @param args any Override arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position. - */ - static createDelayed( fn?:any, delay?:any, scope?:any, args?:any, appendArgs?:any ): any; - static createDelayed( fn?:any, delay?:number, scope?:any, args?:any[], appendArgs?:boolean ): any; - static createDelayed( fn?:any, delay?:number, scope?:any, args?:any[], appendArgs?:number ): any; - /** [Method] Creates an interceptor function - * @param origFn Function The original function. - * @param newFn Function The function to call before the original - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope in which the original function is called or the browser window. - * @param returnValue Object The value to return if the passed function return false. - */ - static createInterceptor( origFn?:any, newFn?:any, scope?:any, returnValue?:any ): any; - /** [Method] Create a combined function call sequence of the original function the passed function - * @param originalFn Function The original function. - * @param newFn Function The function to sequence - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope in which the original function is called or the default global environment object (usually the browser window). - */ - static createSequence( originalFn?:any, newFn?:any, scope?:any ): any; - /** [Method] Creates a throttled version of the passed function which when called repeatedly and rapidly invokes the passed func - * @param fn Function The function to execute at a regular time interval. - * @param interval Number The interval in milliseconds on which the passed function is executed. - * @param scope Object The scope (this reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. - */ - static createThrottled( fn?:any, interval?:number, scope?:any ): any; - /** [Method] Calls this function after the number of millseconds specified optionally in a specific scope - * @param fn any The function to defer. - * @param millis any The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately) - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the browser window. - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - static defer( fn?:any, millis?:any, scope?:any, args?:any, appendArgs?:any ): any; - static defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:boolean ): number; - static defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:number ): number; - /** [Method] A very commonly used method throughout the framework - * @param setter Function - */ - static flexSetter( setter?:any ): any; - /** [Method] Adds behavior to an existing method that is executed after the original behavior of the function - * @param object Object The target object - * @param methodName String Name of the method to override - * @param fn Function Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method. - * @param scope Object The scope to execute the interceptor function. Defaults to the object. - */ - static interceptAfter( object?:any, methodName?:string, fn?:any, scope?:any ): any; - /** [Method] Adds behavior to an existing method that is executed before the original behavior of the function - * @param object Object The target object - * @param methodName String Name of the method to override - * @param fn Function Function with the new behavior. It will be called with the same arguments as the original method. The return value of this function will be the return value of the new method. - * @param scope Object The scope to execute the interceptor function. Defaults to the object. - */ - static interceptBefore( object?:any, methodName?:string, fn?:any, scope?:any ): any; - /** [Method] Create a new function from the provided fn the arguments of which are pre set to args - * @param fn Function The original function - * @param args Array The arguments to pass to new callback - * @param scope Object The scope (this reference) in which the function is executed. - */ - static pass( fn?:any, args?:any[], scope?:any ): any; - } -} -declare module Ext.fx { - export interface IAnim extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) Used in conjunction with iterations to reverse the animation each time an iteration completes. ... */ - alternate?: boolean; - /** [Config Option] (Function) */ - callback?: any; - /** [Config Option] (Number) Time to delay before starting the animation. ... */ - delay?: number; - /** [Config Option] (Number) Time in milliseconds for a single animation to last. ... */ - duration?: number; - /** [Config Option] (Boolean) Currently only for Component Animation: Only set a component's outer element size bypassing layouts. ... */ - dynamic?: boolean; - /** [Config Option] (String) This describes how the intermediate values used during a transition will be calculated. ... */ - easing?: string; - /** [Config Option] (Object) An object containing property/value pairs for the beginning of the animation. ... */ - from?: any; - /** [Config Option] (Number) Number of times to execute the animation. ... */ - iterations?: number; - /** [Config Option] (Object) Animation keyframes follow the CSS3 Animation configuration pattern. ... */ - keyframes?: any; - /** [Config Option] (Boolean) Run the animation from the end to the beginning Defaults to false. ... */ - reverse?: boolean; - /** [Config Option] (Function) */ - scope?: any; - /** [Config Option] (String/Object) The Ext.fx.target.Target to apply the animation to. ... */ - target?: any; - /** [Config Option] (Object) An object containing property/value pairs for the end of the animation. ... */ - to?: any; - /** [Property] (Number) Current iteration the animation is running. ... */ - currentIteration?: number; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Anim, or subclass thereof. ... */ - isAnimation?: boolean; - /** [Property] (Boolean) Flag to determine if the animation is paused. ... */ - paused?: boolean; - /** [Property] (Boolean) Flag to determine if the animation has started ... */ - running?: boolean; - /** [Property] (Date) Starting time of the animation. ... */ - startTime?: any; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fire afteranimate event and end the animation */ - end?(): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.fx { - export interface IAnimator extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Number) Time to delay before starting the animation. ... */ - delay?: number; - /** [Config Option] (Number) Time in milliseconds for the animation to last. ... */ - duration?: number; - /** [Config Option] (Boolean) Currently only for Component Animation: Only set a component's outer element size bypassing layouts. ... */ - dynamic?: boolean; - /** [Config Option] (String) This describes how the intermediate values used during a transition will be calculated. ... */ - easing?: string; - /** [Config Option] (Number) Number of times to execute the animation. ... */ - iterations?: number; - /** [Config Option] (Object) Animation keyframes follow the CSS3 Animation configuration pattern. ... */ - keyframes?: any; - /** [Config Option] (Ext.fx.target.Target) The Ext.fx.target to apply the animation to. ... */ - target?: Ext.fx.target.ITarget; - /** [Property] (Number) Current iteration the animation is running. ... */ - currentIteration?: number; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Animator, or subclass thereof. ... */ - isAnimator?: boolean; - /** [Property] (Number) Current keyframe step of the animation. ... */ - keyframeStep?: number; - /** [Property] (Boolean) Flag to determine if the animation is paused. ... */ - paused?: boolean; - /** [Property] (Boolean) Flag to determine if the animation has started ... */ - running?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fire afteranimate event and end the animation */ - end?(): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.fx { - export interface ICubicBezier extends Ext.IBase { - } - export class CubicBezier { - } -} -declare module Ext.fx { - export interface IEasing { - } - export class Easing { - } -} -declare module Ext.fx { - export interface IManager extends Ext.IBase,Ext.fx.IQueue { - } - export class Manager { - /** [Method] End Definitions */ - constructor(); - /** [Method] Add an Anim to the manager - * @param anim Ext.fx.IAnim - */ - static addAnim( anim?:Ext.fx.IAnim ): void; - /** [Method] Remove an Anim from the manager - * @param anim Ext.fx.IAnim - */ - static removeAnim( anim?:Ext.fx.IAnim ): void; - } -} -declare module Ext.fx { - export interface IPropertyHandler extends Ext.IBase { - } -} -declare module Ext.fx { - export interface IQueue extends Ext.IBase { - } -} -declare module Ext.fx.target { - export interface IComponent extends Ext.fx.target.ITarget { - } -} -declare module Ext.fx.target { - export interface ICompositeElement extends Ext.fx.target.IElement { - /** [Property] (Boolean) true in this class to identify an object as an instantiated CompositeElement, or subclass thereof. ... */ - isComposite?: boolean; - } -} -declare module Ext.fx.target { - export interface ICompositeElementCSS extends Ext.fx.target.ICompositeElement { - } -} -declare module Ext.fx.target { - export interface ICompositeSprite extends Ext.fx.target.ISprite { - } -} -declare module Ext.fx.target { - export interface IElement extends Ext.fx.target.ITarget { - } -} -declare module Ext.fx.target { - export interface IElementCSS extends Ext.fx.target.IElement { - } -} -declare module Ext.fx.target { - export interface ISprite extends Ext.fx.target.ITarget { - } -} -declare module Ext.fx.target { - export interface ITarget extends Ext.IBase { - } -} -declare module Ext.grid { - export interface ICellEditor extends Ext.IEditor { - /** [Config Option] (String) The position to align to (see Ext.util.Positionable.alignTo for more details). ... */ - alignment?: string; - /** [Config Option] (String) An optional extra CSS class that will be added to this component's Element. ... */ - cls?: string; - /** [Config Option] (Boolean) False to keep the bound element visible while the editor is displayed ... */ - hideEl?: boolean; - /** [Config Option] (Boolean/String) "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop" for bottom-right shadow. ... */ - shadow?: any; - } -} -declare module Ext.grid.column { - export interface IAction extends Ext.grid.column.IColumn { - /** [Config Option] (String) The alt text to use for the image element. ... */ - altText?: string; - /** [Config Option] (Boolean) If true, the action will not respond to click events, and will be displayed semi-opaque. ... */ - disabled?: boolean; - /** [Config Option] (Function) A function which returns the CSS class to apply to the icon image. ... */ - getClass?: any; - /** [Config Option] (Function) A function which returns the tooltip string for any row. ... */ - getTip?: any; - /** [Config Option] (Function) A function called when the icon is clicked. ... */ - handler?: any; - /** [Config Option] (String) The URL of an image to display as the clickable element in the column. ... */ - icon?: string; - /** [Config Option] (String) A CSS class to apply to the icon image. ... */ - iconCls?: string; - /** [Config Option] (Object[]) An Array which may contain multiple icon definitions, each element of which may contain: ... */ - items?: Object[]; - /** [Config Option] (String) Text to display in this column's menu item if no text was specified as a header. ... */ - menuText?: string; - /** [Config Option] (Object) The scope (this reference) in which the handler, getClass, isDisabled and getTip fuctions are executed. ... */ - scope?: any; - /** [Config Option] (Boolean) False to disable sorting of this column. ... */ - sortable?: boolean; - /** [Config Option] (Boolean) Prevent grid selection upon mousedown. ... */ - stopSelection?: boolean; - /** [Config Option] (String) A tooltip message to be displayed on hover. ... */ - tooltip?: string; - /** [Method] Cascades down the component container heirarchy from this component passed in the first call calling the specified - * @param fn Function The function to call - * @param scope Object The scope of the function (defaults to current component) - * @param args Array The args to call the function with. The current component always passed as the last argument. - */ - cascade?( fn?:any, scope?:any, args?:any[] ): Ext.IContainer; - /** [Method] Renderer closure iterates through items creating an element for each and tagging with an identifying class name x ac */ - defaultRenderer?(): void; - /** [Method] Disables this ActionColumn s action at the specified index - * @param index Number - * @param silent Boolean - */ - disableAction?( index?:number, silent?:boolean ): void; - disableAction?( index?:Ext.grid.column.IAction, silent?:boolean ): void; - /** [Method] Enables this ActionColumn s action at the specified index - * @param index Number - * @param silent Boolean - */ - enableAction?( index?:number, silent?:boolean ): void; - enableAction?( index?:Ext.grid.column.IAction, silent?:boolean ): void; - /** [Method] Private override because this cannot function as a Container and it has an items property which is an Array NOT a M - * @param deep Object - */ - getRefItems?( deep?:any ): void; - } -} -declare module Ext.grid { - export interface IActionColumn extends Ext.grid.column.IColumn { - /** [Config Option] (String) The alt text to use for the image element. ... */ - altText?: string; - /** [Config Option] (Boolean) If true, the action will not respond to click events, and will be displayed semi-opaque. ... */ - disabled?: boolean; - /** [Config Option] (Function) A function which returns the CSS class to apply to the icon image. ... */ - getClass?: any; - /** [Config Option] (Function) A function which returns the tooltip string for any row. ... */ - getTip?: any; - /** [Config Option] (Function) A function called when the icon is clicked. ... */ - handler?: any; - /** [Config Option] (String) The URL of an image to display as the clickable element in the column. ... */ - icon?: string; - /** [Config Option] (String) A CSS class to apply to the icon image. ... */ - iconCls?: string; - /** [Config Option] (Object[]) An Array which may contain multiple icon definitions, each element of which may contain: ... */ - items?: Object[]; - /** [Config Option] (String) Text to display in this column's menu item if no text was specified as a header. ... */ - menuText?: string; - /** [Config Option] (Object) The scope (this reference) in which the handler, getClass, isDisabled and getTip fuctions are executed. ... */ - scope?: any; - /** [Config Option] (Boolean) False to disable sorting of this column. ... */ - sortable?: boolean; - /** [Config Option] (Boolean) Prevent grid selection upon mousedown. ... */ - stopSelection?: boolean; - /** [Config Option] (String) A tooltip message to be displayed on hover. ... */ - tooltip?: string; - /** [Method] Cascades down the component container heirarchy from this component passed in the first call calling the specified - * @param fn Function The function to call - * @param scope Object The scope of the function (defaults to current component) - * @param args Array The args to call the function with. The current component always passed as the last argument. - */ - cascade?( fn?:any, scope?:any, args?:any[] ): Ext.IContainer; - /** [Method] Renderer closure iterates through items creating an element for each and tagging with an identifying class name x ac */ - defaultRenderer?(): void; - /** [Method] Disables this ActionColumn s action at the specified index - * @param index Number - * @param silent Boolean - */ - disableAction?( index?:number, silent?:boolean ): void; - disableAction?( index?:Ext.grid.column.IAction, silent?:boolean ): void; - /** [Method] Enables this ActionColumn s action at the specified index - * @param index Number - * @param silent Boolean - */ - enableAction?( index?:number, silent?:boolean ): void; - enableAction?( index?:Ext.grid.column.IAction, silent?:boolean ): void; - /** [Method] Private override because this cannot function as a Container and it has an items property which is an Array NOT a M - * @param deep Object - */ - getRefItems?( deep?:any ): void; - } -} -declare module Ext.grid.column { - export interface IBoolean extends Ext.grid.column.IColumn { - /** [Config Option] (String) The string returned by the renderer when the column value is falsey (but not undefined). ... */ - falseText?: string; - /** [Config Option] (String) The string returned by the renderer when the column value is not falsey. ... */ - trueText?: string; - /** [Config Option] (String) The string returned by the renderer when the column value is undefined. ... */ - undefinedText?: string; - } -} -declare module Ext.grid { - export interface IBooleanColumn extends Ext.grid.column.IColumn { - /** [Config Option] (String) The string returned by the renderer when the column value is falsey (but not undefined). ... */ - falseText?: string; - /** [Config Option] (String) The string returned by the renderer when the column value is not falsey. ... */ - trueText?: string; - /** [Config Option] (String) The string returned by the renderer when the column value is undefined. ... */ - undefinedText?: string; - } -} -declare module Ext.grid.column { - export interface ICheckColumn extends Ext.grid.column.IColumn { - /** [Config Option] (Boolean) Prevent grid selection upon mousedown. ... */ - stopSelection?: boolean; - /** [Config Option] (String) A CSS class names to apply to the table cells for this column. ... */ - tdCls?: string; - /** [Method] Disables this CheckColumn - * @param silent Boolean - */ - onDisable?( silent?:boolean ): void; - /** [Method] Enables this CheckColumn - * @param silent Boolean - */ - onEnable?( silent?:boolean ): void; - } -} -declare module Ext.ux { - export interface ICheckColumn extends Ext.grid.column.IColumn { - /** [Config Option] (Boolean) Prevent grid selection upon mousedown. ... */ - stopSelection?: boolean; - /** [Config Option] (String) A CSS class names to apply to the table cells for this column. ... */ - tdCls?: string; - /** [Method] Disables this CheckColumn - * @param silent Boolean - */ - onDisable?( silent?:boolean ): void; - /** [Method] Enables this CheckColumn - * @param silent Boolean - */ - onEnable?( silent?:boolean ): void; - } -} -declare module Ext.grid.column { - export interface IColumn extends Ext.grid.header.IContainer { - /** [Config Option] (String) Sets the alignment of the header and rendered columns. ... */ - align?: string; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Object[]) An optional array of sub-column definitions. ... */ - columns?: Object[]; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. ... */ - dataIndex?: string; - /** [Config Option] (Boolean) So that when removing from group headers which are then empty and then get destroyed, there's no child DOM left True... */ - detachOnRemove?: boolean; - /** [Config Option] (Boolean) False to disable drag-drop reordering of this column. ... */ - draggable?: boolean; - /** [Config Option] (Function) A renderer to be used in conjunction with RowEditing. ... */ - editRenderer?: any; - /** [Config Option] (Object/String) An optional xtype or config object for a Field to use for editing. ... */ - editor?: any; - /** [Config Option] (String) The text to diplay in empty cells (cells with a value of undefined, null, or ''). ... */ - emptyCellText?: string; - /** [Config Option] (Object/String) Alias for editor. ... */ - field?: any; - /** [Config Option] (Boolean) True to prevent the column from being resizable. ... */ - fixed?: boolean; - /** [Config Option] (Boolean) If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the... */ - groupable?: boolean; - /** [Config Option] (String) The header text. ... */ - header?: string; - /** [Config Option] (Boolean) False to prevent the user from hiding this column. ... */ - hideable?: boolean; - /** [Config Option] (Boolean) If the grid is configured with enableLocking, or has columns which are configured with a locked value, this option ma... */ - lockable?: boolean; - /** [Config Option] (Boolean) True to lock this column in place. ... */ - locked?: boolean; - /** [Config Option] (Boolean) True to disable the column header menu containing sort/hide options. ... */ - menuDisabled?: boolean; - /** [Config Option] (String) The text to render in the column visibility selection menu for this column. ... */ - menuText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Function/String) A renderer is an 'interceptor' method which can be used to transform data (value, appearance, etc.) before it is rend... */ - renderer?: any; - /** [Config Option] (Boolean) False to prevent the column from being resizable. ... */ - resizable?: boolean; - /** [Config Option] (Object) */ - scope?: any; - /** [Config Option] (Boolean) False to disable sorting of this column. ... */ - sortable?: boolean; - /** [Config Option] (String) An identifier which identifies this column uniquely within the owning grid's state. ... */ - stateId?: string; - /** [Config Option] (String) A CSS class names to apply to the table cells for this column. ... */ - tdCls?: string; - /** [Config Option] (String) The header text to be used as innerHTML (html tags are accepted) to display in the Grid. ... */ - text?: string; - /** [Config Option] (String) */ - tooltip?: string; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Property] (Boolean) Set in this class to identify, at runtime, instances which are not instances of the HeaderContainer base class, but a... */ - isHeader?: boolean; - /** [Property] (Ext.Element) */ - textEl?: Ext.IElement; - /** [Property] (Ext.Element) */ - triggerEl?: Ext.IElement; - /** [Method] private Inform the header container about the resize Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Sizes this Column to fit the max content width - * @param The Ext.grid.column.IColumn header (or index of header) to auto size. - */ - autoSize?( The?:Ext.grid.column.IColumn ): void; - autoSize?( The?:number ): void; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - /** [Method] Retrieves the editing field for editing associated with this header - * @param record Object The Model instance being edited. - * @param defaultField Object An object representing a default field to be created - */ - getEditor?( record?:any, defaultField?:any ): any; - /** [Method] Returns the index of this column only if this column is a base level Column */ - getIndex?(): number; - /** [Method] Returns the parameter to sort upon when sorting this header */ - getSortParam?(): string; - /** [Method] Returns the index of this column in the list of visible columns only if this column is a base level Column */ - getVisibleIndex?(): number; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Determines whether the UI should be allowed to offer an option to hide this column */ - isHideable?(): void; - /** [Method] Determines whether the UI should be allowed to offer an option to lock or unlock this column */ - isLockable?(): void; - /** [Method] This method is invoked after a new Component has been added - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] Sets the form field to be used for editing - * @param field Object An object representing a field to be created. If no xtype is specified a 'textfield' is assumed. - */ - setEditor?( field?:any ): void; - /** [Method] Sets the header text for this Column - * @param text String The header to display on this Column. - */ - setText?( text?:string ): void; - /** [Method] Shows this Component rendering it first if autoRender or floating are true - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening. - * @param callback any A callback function to call after the Component is displayed. Only necessary if animation was specified. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - show?( animateTarget?:any, callback?:any, scope?:any ): any; - show?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - show?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - } -} -declare module Ext.grid { - export interface IColumn extends Ext.grid.header.IContainer { - /** [Config Option] (String) Sets the alignment of the header and rendered columns. ... */ - align?: string; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Object[]) An optional array of sub-column definitions. ... */ - columns?: Object[]; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. ... */ - dataIndex?: string; - /** [Config Option] (Boolean) So that when removing from group headers which are then empty and then get destroyed, there's no child DOM left True... */ - detachOnRemove?: boolean; - /** [Config Option] (Boolean) False to disable drag-drop reordering of this column. ... */ - draggable?: boolean; - /** [Config Option] (Function) A renderer to be used in conjunction with RowEditing. ... */ - editRenderer?: any; - /** [Config Option] (Object/String) An optional xtype or config object for a Field to use for editing. ... */ - editor?: any; - /** [Config Option] (String) The text to diplay in empty cells (cells with a value of undefined, null, or ''). ... */ - emptyCellText?: string; - /** [Config Option] (Object/String) Alias for editor. ... */ - field?: any; - /** [Config Option] (Boolean) True to prevent the column from being resizable. ... */ - fixed?: boolean; - /** [Config Option] (Boolean) If the grid uses a Ext.grid.feature.Grouping, this option may be used to disable the header menu item to group by the... */ - groupable?: boolean; - /** [Config Option] (String) The header text. ... */ - header?: string; - /** [Config Option] (Boolean) False to prevent the user from hiding this column. ... */ - hideable?: boolean; - /** [Config Option] (Boolean) If the grid is configured with enableLocking, or has columns which are configured with a locked value, this option ma... */ - lockable?: boolean; - /** [Config Option] (Boolean) True to lock this column in place. ... */ - locked?: boolean; - /** [Config Option] (Boolean) True to disable the column header menu containing sort/hide options. ... */ - menuDisabled?: boolean; - /** [Config Option] (String) The text to render in the column visibility selection menu for this column. ... */ - menuText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Function/String) A renderer is an 'interceptor' method which can be used to transform data (value, appearance, etc.) before it is rend... */ - renderer?: any; - /** [Config Option] (Boolean) False to prevent the column from being resizable. ... */ - resizable?: boolean; - /** [Config Option] (Object) */ - scope?: any; - /** [Config Option] (Boolean) False to disable sorting of this column. ... */ - sortable?: boolean; - /** [Config Option] (String) An identifier which identifies this column uniquely within the owning grid's state. ... */ - stateId?: string; - /** [Config Option] (String) A CSS class names to apply to the table cells for this column. ... */ - tdCls?: string; - /** [Config Option] (String) The header text to be used as innerHTML (html tags are accepted) to display in the Grid. ... */ - text?: string; - /** [Config Option] (String) */ - tooltip?: string; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Property] (Boolean) Set in this class to identify, at runtime, instances which are not instances of the HeaderContainer base class, but a... */ - isHeader?: boolean; - /** [Property] (Ext.Element) */ - textEl?: Ext.IElement; - /** [Property] (Ext.Element) */ - triggerEl?: Ext.IElement; - /** [Method] private Inform the header container about the resize Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Sizes this Column to fit the max content width - * @param The Ext.grid.column.IColumn header (or index of header) to auto size. - */ - autoSize?( The?:Ext.grid.column.IColumn ): void; - autoSize?( The?:number ): void; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - /** [Method] Retrieves the editing field for editing associated with this header - * @param record Object The Model instance being edited. - * @param defaultField Object An object representing a default field to be created - */ - getEditor?( record?:any, defaultField?:any ): any; - /** [Method] Returns the index of this column only if this column is a base level Column */ - getIndex?(): number; - /** [Method] Returns the parameter to sort upon when sorting this header */ - getSortParam?(): string; - /** [Method] Returns the index of this column in the list of visible columns only if this column is a base level Column */ - getVisibleIndex?(): number; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Determines whether the UI should be allowed to offer an option to hide this column */ - isHideable?(): void; - /** [Method] Determines whether the UI should be allowed to offer an option to lock or unlock this column */ - isLockable?(): void; - /** [Method] This method is invoked after a new Component has been added - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] Sets the form field to be used for editing - * @param field Object An object representing a field to be created. If no xtype is specified a 'textfield' is assumed. - */ - setEditor?( field?:any ): void; - /** [Method] Sets the header text for this Column - * @param text String The header to display on this Column. - */ - setText?( text?:string ): void; - /** [Method] Shows this Component rendering it first if autoRender or floating are true - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening. - * @param callback any A callback function to call after the Component is displayed. Only necessary if animation was specified. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - show?( animateTarget?:any, callback?:any, scope?:any ): any; - show?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - show?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - } -} -declare module Ext.grid.column { - export interface IDate extends Ext.grid.column.IColumn { - /** [Config Option] (String) A formatting string as used by Ext.Date.format to format a Date for this Column. ... */ - format?: string; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - } -} -declare module Ext.grid { - export interface IDateColumn extends Ext.grid.column.IColumn { - /** [Config Option] (String) A formatting string as used by Ext.Date.format to format a Date for this Column. ... */ - format?: string; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - } -} -declare module Ext.grid.column { - export interface INumber extends Ext.grid.column.IColumn { - /** [Config Option] (String) A formatting string as used by Ext.util.Format.number to format a numeric value for this Column. ... */ - format?: string; - } -} -declare module Ext.grid { - export interface INumberColumn extends Ext.grid.column.IColumn { - /** [Config Option] (String) A formatting string as used by Ext.util.Format.number to format a numeric value for this Column. ... */ - format?: string; - } -} -declare module Ext.grid.column { - export interface ITemplate extends Ext.grid.column.IColumn { - /** [Config Option] (String/Ext.XTemplate) */ - tpl?: any; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - } -} -declare module Ext.grid { - export interface ITemplateColumn extends Ext.grid.column.IColumn { - /** [Config Option] (String/Ext.XTemplate) */ - tpl?: any; - /** [Method] When defined this will take precedence over the renderer config */ - defaultRenderer?(): void; - } -} -declare module Ext.grid { - export interface IColumnComponentLayout extends Ext.layout.component.IAuto { - /** [Config Option] (Boolean) When publishing width of an auto Component, it is usually not written to the DOM. ... */ - setWidthInDom?: boolean; - } -} -declare module Ext.grid { - export interface IColumnLayout extends Ext.layout.container.IHBox { - /** [Method] Collect the height of the table of data upon layout begin In addition to work done by our base classes containers b - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Set up padding in items This method if implemented is called after all layouts have completed - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finalizeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - } -} -declare module Ext.grid.feature { - export interface IAbstractSummary extends Ext.grid.feature.IFeature { - /** [Config Option] (String) The name of the property which contains the Array of summary objects. ... */ - remoteRoot?: string; - /** [Config Option] (Boolean) True to show the summary row. ... */ - showSummaryRow?: boolean; - /** [Method] Toggle whether or not to show the summary row - * @param visible Boolean True to show the summary row - */ - toggleSummaryRow?( visible?:boolean ): void; - } -} -declare module Ext.grid.feature { - export interface IFeature extends Ext.util.IObservable { - /** [Property] (Boolean) True when feature is disabled. ... */ - disabled?: boolean; - /** [Property] (String) Prefix to use when firing events on the view. ... */ - eventPrefix?: string; - /** [Property] (String) */ - eventSelector?: string; - /** [Property] (Ext.grid.Panel) */ - grid?: Ext.grid.IPanel; - /** [Property] (Boolean) Most features will expose additional events, some may not and will need to change this to false. ... */ - hasFeatureEvent?: boolean; - /** [Property] (Ext.view.Table) */ - view?: Ext.view.ITable; - /** [Method] Disables the feature */ - disable?(): void; - /** [Method] Enables the feature */ - enable?(): void; - /** [Method] Abstract method to be overriden when a feature should add additional arguments to its event signature - * @param eventName Object - * @param view Object - * @param featureTarget Object - * @param e Object - */ - getFireEventArgs?( eventName?:any, view?:any, featureTarget?:any, e?:any ): void; - } -} -declare module Ext.grid.feature { - export interface IGrouping extends Ext.grid.feature.IFeature,Ext.grid.feature.IAbstractSummary { - /** [Config Option] (Boolean) Set to false to disable collapsing groups from the UI. ... */ - collapsible?: boolean; - /** [Config Option] (Number) Number of pixels to indent per grouping level ... */ - depthToIndent?: number; - /** [Config Option] (Boolean) True to enable the grouping control in the header menu. ... */ - enableGroupingMenu?: boolean; - /** [Config Option] (Boolean) True to allow the user to turn off grouping. ... */ - enableNoGroups?: boolean; - /** [Config Option] (String) Text displayed in the grid header menu for grouping by header. ... */ - groupByText?: string; - /** [Config Option] (String/Array/Ext.Template) A string Template snippet, an array of strings (optionally followed by an object containing Template methods) to be u... */ - groupHeaderTpl?: any; - /** [Config Option] (Boolean) True to hide the header that is currently grouped. ... */ - hideGroupedHeader?: boolean; - /** [Config Option] (String) Text displayed in the grid header for enabling/disabling grouping. ... */ - showGroupsText?: string; - /** [Config Option] (Boolean) True to show the summary row. ... */ - showSummaryRow?: boolean; - /** [Config Option] (Boolean) True to start all groups collapsed. ... */ - startCollapsed?: boolean; - /** [Property] (String) Prefix to use when firing events on the view. ... */ - eventPrefix?: string; - /** [Property] (String) Selector used to determine when to fire the event with the eventPrefix. ... */ - eventSelector?: string; - /** [Method] Collapse a group - * @param groupName String The group name - * @param focus Boolean Pass true to focus the group after expand. - */ - collapse?( groupName?:string, focus?:boolean ): void; - /** [Method] Collapse all groups */ - collapseAll?(): void; - /** [Method] Disables the feature */ - disable?(): void; - /** [Method] Enables the feature */ - enable?(): void; - /** [Method] Expand a group - * @param groupName String The group name - * @param focus Boolean Pass true to focus the group after expand. - */ - expand?( groupName?:string, focus?:boolean ): void; - /** [Method] Expand all groups */ - expandAll?(): void; - /** [Method] Abstract method to be overriden when a feature should add additional arguments to its event signature - * @param eventName Object - * @param view Object - * @param featureTarget Object - * @param e Object - */ - getFireEventArgs?( eventName?:any, view?:any, featureTarget?:any, e?:any ): void; - /** [Method] Returns the group data object for the group to which the passed record belongs if the Store is grouped - * @param record Ext.data.IModel The record for which to return group information. - */ - getRecordGroup?( record?:Ext.data.IModel ): any; - /** [Method] Returns true if the named group is expanded - * @param groupName String The group name as returned from getGroupString. This is usually the value of the groupField. - */ - isExpanded?( groupName?:string ): boolean; - /** [Method] Toggle whether or not to show the summary row - * @param visible Boolean True to show the summary row - */ - toggleSummaryRow?( visible?:boolean ): void; - } -} -declare module Ext.grid.feature { - export interface IGroupingSummary extends Ext.grid.feature.IGrouping { - /** [Config Option] (Boolean) True to show the summary row. ... */ - showSummaryRow?: boolean; - } -} -declare module Ext.grid.feature { - export interface IGroupStore extends Ext.util.IObservable { - } -} -declare module Ext.grid.feature { - export interface IRowBody extends Ext.grid.feature.IFeature { - /** [Property] (String) Prefix to use when firing events on the view. ... */ - eventPrefix?: string; - /** [Property] (String) Selector used to determine when to fire the event with the eventPrefix. ... */ - eventSelector?: string; - /** [Method] Provides additional data to the prepareData call within the grid view - * @param data Object The data for this particular record. - * @param idx Number The row index for this record. - * @param record Ext.data.IModel The record instance - * @param orig Object The original result from the prepareData call to massage. - */ - getAdditionalData?( data?:any, idx?:number, record?:Ext.data.IModel, orig?:any ): void; - } -} -declare module Ext.grid.feature { - export interface IRowWrap extends Ext.grid.feature.IFeature { - /** [Property] (Boolean) turn off feature events. ... */ - hasFeatureEvent?: boolean; - } -} -declare module Ext.grid.feature { - export interface ISummary extends Ext.grid.feature.IAbstractSummary { - /** [Config Option] (String) */ - dock?: string; - } -} -declare module Ext.grid.header { - export interface IContainer extends Ext.container.IContainer { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Number) Width of the header if no width or flex is specified. ... */ - defaultWidth?: number; - /** [Config Option] (Boolean) True to move any component to the detachedBody when the component is removed from this container. ... */ - detachOnRemove?: boolean; - /** [Config Option] (Boolean) False to disable column hiding within this grid. ... */ - enableColumnHide?: boolean; - /** [Config Option] (Boolean) Specify as true to constrain column dragging so that a column cannot be dragged into or out of this column. ... */ - sealed?: boolean; - /** [Config Option] (Boolean) Provides the default sortable state for all Headers within this HeaderContainer. ... */ - sortable?: boolean; - /** [Config Option] (Number) HeaderContainer overrides the default weight of 0 for all docked items to 100. ... */ - weight?: number; - /** [Property] (Boolean) */ - isGroupHeader?: boolean; - /** [Method] Returns the number of grid columns descended from this HeaderContainer */ - getColumnCount?(): void; - /** [Method] Returns an array of menu CheckItems corresponding to all immediate children of the passed Container which have been c - * @param headerContainer Object - */ - getColumnMenu?( headerContainer?:any ): void; - /** [Method] Gets the full width of all columns that are visible */ - getFullWidth?(): void; - /** [Method] Returns an array of all columns which appear in the grid s View - * @param inResult Object - * @param hiddenAncestor Object - */ - getGridColumns?( inResult?:any, hiddenAncestor?:any ): any[]; - /** [Method] Get a leaf level header by index regardless of what the nesting structure is - * @param index Number The column index for which to retrieve the column. - */ - getHeaderAtIndex?( index?:number ): void; - /** [Method] Returns the index of a leaf level header regardless of what the nesting structure is - * @param header Ext.grid.column.IColumn The header to find the index of - */ - getHeaderIndex?( header?:Ext.grid.column.IColumn ): number; - /** [Method] Returns an array of menu items to be placed into the shared menu across all headers in this header container */ - getMenuItems?(): any[]; - /** [Method] Returns an array of the visible columns in the grid */ - getVisibleGridColumns?(): any[]; - /** [Method] When passed a column index returns the closet visible column to that - * @param index Number Position at which to find the closest visible column. - */ - getVisibleHeaderClosestToIndex?( index?:number ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Determines whether this Component is the root of a layout */ - isLayoutRoot?(): void; - /** [Method] Invalidate column cache on add We cannot refresh the View on every add because this method is called when the HeaderD - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Invalidate column cache on remove We cannot refresh the View on every remove because this method is called when the H - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - } -} -declare module Ext.grid.header { - export interface IDragZone extends Ext.dd.IDragZone { - /** [Method] Called when a mousedown occurs in this container - * @param e Event The mouse down event - */ - getDragData?( e?:Event ): any; - /** [Method] Called before a repair of an invalid drop to get the XY to animate to - * @param e Event The mouse up event - */ - getRepairXY?( e?:Event ): number[]; - /** [Method] An empty function by default but provided so that you can perform a custom action before the initial drag event begi - * @param data Object An object containing arbitrary data to be shared with drop targets - * @param e Event The event object - */ - onBeforeDrag?( data?:any, e?:Event ): boolean; - /** [Method] Abstract method called when this item is dropped on another DragDrop obj - * @param e Event the mouseup event - * @param id String In POINT mode, the element id this was dropped on. In INTERSECT mode, an array of dd items this was dropped on. - */ - onDragDrop?( e?:Event, id?:string ): void; - onDragDrop?( e?:Event, id?:Ext.dd.IDragDrop[] ): void; - /** [Method] Called once drag threshold has been reached to initialize the proxy element - * @param x Number The x position of the click on the dragged object - * @param y Number The y position of the click on the dragged object - */ - onInitDrag?( x?:number, y?:number ): boolean; - } -} -declare module Ext.grid.header { - export interface IDropZone extends Ext.dd.IDropZone { - /** [Method] Returns a custom data object associated with the DOM node that is the target of the event - * @param e Event The event - */ - getTargetFromEvent?( e?:Event ): any; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dropped onto the drop node - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeDrop?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dragged out of the drop node without dropping - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOut?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called while the DropZone determines that a Ext dd DragSource is over a drop node that has either been registered or - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOver?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - } -} -declare module Ext.grid.locking { - export interface IHeaderContainer extends Ext.grid.header.IContainer { - /** [Method] This is the function which all other column access methods are based upon Return the full column set for the whole Lo - * @param inResult Object - * @param hiddenAncestor Object - */ - getGridColumns?( inResult?:any, hiddenAncestor?:any ): any[]; - } -} -declare module Ext.grid.locking { - export interface ILockable extends Ext.IBase { - /** [Config Option] (Object) */ - lockedGridConfig?: any; - /** [Config Option] (Object) A view configuration to be applied to the locked side of the grid. ... */ - lockedViewConfig?: any; - /** [Config Option] (Object) */ - normalGridConfig?: any; - /** [Config Option] (Object) A view configuration to be applied to the normal/unlocked side of the grid. ... */ - normalViewConfig?: any; - /** [Config Option] (Number) Number of pixels to scroll when scrolling the locked section with mousewheel. ... */ - scrollDelta?: number; - /** [Config Option] (String) The xtype of the subgrid to specify. ... */ - subGridXType?: string; - /** [Config Option] (Boolean) Synchronize rowHeight between the normal and locked grid view. ... */ - syncRowHeight?: boolean; - /** [Method] Synchronizes the row heights between the locked and non locked portion of the grid for each row */ - syncRowHeights?(): void; - } -} -declare module Ext.grid { - export interface ILockable extends Ext.IBase { - /** [Config Option] (Object) */ - lockedGridConfig?: any; - /** [Config Option] (Object) A view configuration to be applied to the locked side of the grid. ... */ - lockedViewConfig?: any; - /** [Config Option] (Object) */ - normalGridConfig?: any; - /** [Config Option] (Object) A view configuration to be applied to the normal/unlocked side of the grid. ... */ - normalViewConfig?: any; - /** [Config Option] (Number) Number of pixels to scroll when scrolling the locked section with mousewheel. ... */ - scrollDelta?: number; - /** [Config Option] (String) The xtype of the subgrid to specify. ... */ - subGridXType?: string; - /** [Config Option] (Boolean) Synchronize rowHeight between the normal and locked grid view. ... */ - syncRowHeight?: boolean; - /** [Method] Synchronizes the row heights between the locked and non locked portion of the grid for each row */ - syncRowHeights?(): void; - } -} -declare module Ext.grid.locking { - export interface IView extends Ext.IBase,Ext.util.IObservable { - /** [Property] (Boolean) true in this class to identify an object as an instantiated LockingView, or subclass thereof. ... */ - isLockingView?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.grid { - export interface ILockingView extends Ext.IBase,Ext.util.IObservable { - /** [Property] (Boolean) true in this class to identify an object as an instantiated LockingView, or subclass thereof. ... */ - isLockingView?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.grid { - export interface IPanel extends Ext.panel.ITable { - /** [Config Option] (Ext.grid.column.Column[]/Object) An array of column definition objects which define all columns that appear in this grid. ... */ - columns?: any; - /** [Config Option] (Boolean) False to remove row line styling ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Reconfigures the grid with a new store columns - * @param store Ext.data.IStore The new store. - * @param columns Object[] An array of column configs - */ - reconfigure?( store?:Ext.data.IStore, columns?:Object[] ): void; - } -} -declare module Ext { - export interface IListView extends Ext.panel.ITable { - /** [Config Option] (Ext.grid.column.Column[]/Object) An array of column definition objects which define all columns that appear in this grid. ... */ - columns?: any; - /** [Config Option] (Boolean) False to remove row line styling ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Reconfigures the grid with a new store columns - * @param store Ext.data.IStore The new store. - * @param columns Object[] An array of column configs - */ - reconfigure?( store?:Ext.data.IStore, columns?:Object[] ): void; - } -} -declare module Ext.grid { - export interface IGridPanel extends Ext.panel.ITable { - /** [Config Option] (Ext.grid.column.Column[]/Object) An array of column definition objects which define all columns that appear in this grid. ... */ - columns?: any; - /** [Config Option] (Boolean) False to remove row line styling ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Reconfigures the grid with a new store columns - * @param store Ext.data.IStore The new store. - * @param columns Object[] An array of column configs - */ - reconfigure?( store?:Ext.data.IStore, columns?:Object[] ): void; - } -} -declare module Ext.list { - export interface IListView extends Ext.panel.ITable { - /** [Config Option] (Ext.grid.column.Column[]/Object) An array of column definition objects which define all columns that appear in this grid. ... */ - columns?: any; - /** [Config Option] (Boolean) False to remove row line styling ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Reconfigures the grid with a new store columns - * @param store Ext.data.IStore The new store. - * @param columns Object[] An array of column configs - */ - reconfigure?( store?:Ext.data.IStore, columns?:Object[] ): void; - } -} -declare module Ext.grid.plugin { - export interface IBufferedRenderer extends Ext.IAbstractPlugin { - /** [Config Option] (Number) The number of extra rows to render on the leading side of scrolling outside the numFromEdge buffer as scrolling proce... */ - leadingBufferZone?: number; - /** [Config Option] (Number) The zone which causes new rows to be appended to the view. ... */ - numFromEdge?: number; - /** [Config Option] (Number) ... */ - percentageFromEdge?: number; - /** [Config Option] (Number) This is the time in milliseconds to buffer load requests when scrolling the PagingScrollbar. ... */ - scrollToLoadBuffer?: number; - /** [Config Option] (Boolean) By default, on detection of a scroll event which brings the end of the rendered table within numFromEdge rows of the ... */ - synchronousRender?: boolean; - /** [Config Option] (Number) The number of extra rows to render on the trailing side of scrolling outside the numFromEdge buffer as scrolling proc... */ - trailingBufferZone?: number; - /** [Config Option] (Boolean) Configure as true if the row heights are not all the same height as the first row. ... */ - variableRowHeight?: boolean; - /** [Property] (Number) Current pixel scroll position of the associated View. ... */ - position?: number; - /** [Method] The destroy method is invoked by the owning Component at the time the Component is being destroyed */ - destroy?(): void; - /** [Method] Initialize this as a plugin The init method is invoked after initComponent method has been run for the client Compon - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - /** [Method] Scrolls to and optionlly selects the specified row index in the total dataset - * @param recordIdx Number The zero-based position in the dataset to scroll to. - * @param doSelect Boolean Pass as true to select the specified row. - * @param callback Function A function to call when the row has been scrolled to. - * @param scope Object The scope (this reference) in which to execute the callback. Defaults to this BufferedRenderer. - */ - scrollTo?( recordIdx?:number, doSelect?:boolean, callback?:any, scope?:any ): void; - } -} -declare module Ext.grid.plugin { - export interface ICellEditing extends Ext.grid.plugin.IEditing { - /** [Method] Cancels any active editing */ - cancelEdit?(): void; - /** [Method] Completes the edit if there is an active edit in progress */ - completeEdit?(): void; - /** [Method] Starts editing the specified record using the specified Column definition to define which field is being edited - * @param record any The Store data record which backs the row to be edited, or index of the record. - * @param columnHeader any The Column object defining the column to be edited, or index of the column. - */ - startEdit?( record?:any, columnHeader?:any ): any; - startEdit?( record?:Ext.data.IModel, columnHeader?:Ext.grid.column.IColumn ): boolean; - startEdit?( record?:number, columnHeader?:Ext.grid.column.IColumn ): boolean; - startEdit?( record?:Ext.data.IModel, columnHeader?:number ): boolean; - startEdit?( record?:number, columnHeader?:number ): boolean; - /** [Method] Starts editing by position row column - * @param position Object A position with keys of row and column. - */ - startEditByPosition?( position?:any ): void; - } -} -declare module Ext.grid.plugin { - export interface IDragDrop extends Ext.IAbstractPlugin { - /** [Config Option] (Object/Boolean) true to register this container with the Scrollmanager for auto scrolling during drag operations. ... */ - containerScroll?: any; - /** [Config Option] (String) A named drag drop group to which this object belongs. ... */ - ddGroup?: string; - /** [Config Option] (String) The ddGroup to which the DragZone will belong. ... */ - dragGroup?: string; - /** [Config Option] (String) The text to show while dragging. ... */ - dragText?: string; - /** [Config Option] (String) The ddGroup to which the DropZone will belong. ... */ - dropGroup?: string; - /** [Config Option] (Boolean) false to disallow dragging items from the View. ... */ - enableDrag?: boolean; - /** [Config Option] (Boolean) false to disallow the View from accepting drop gestures. ... */ - enableDrop?: boolean; - /** [Method] The base implementation just sets the plugin s disabled flag to true Plugin subclasses which need more complex proce */ - disable?(): void; - /** [Method] The base implementation just sets the plugin s disabled flag to false Plugin subclasses which need more complex proc */ - enable?(): void; - /** [Method] The init method is invoked after initComponent method has been run for the client Component - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - } -} -declare module Ext.grid.plugin { - export interface IEditing extends Ext.IAbstractPlugin,Ext.util.IObservable { - /** [Config Option] (Number) The number of clicks on a grid required to display the editor. ... */ - clicksToEdit?: number; - /** [Config Option] (String) The event which triggers editing. ... */ - triggerEvent?: string; - /** [Property] (Boolean) */ - editing?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Template method called before editing begins - * @param context Object The current editing context - */ - beforeEdit?( context?:any ): boolean; - /** [Method] Cancels any active edit that is in progress */ - cancelEdit?(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Completes the edit if there is an active edit in progress */ - completeEdit?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Starts editing the specified record using the specified Column definition to define which field is being edited - * @param record Ext.data.IModel The Store data record which backs the row to be edited, or index of the record in Store. - * @param columnHeader Ext.grid.column.IColumn The Column object defining the column to be edited, or index of the column. - */ - startEdit?( record?:Ext.data.IModel, columnHeader?:Ext.grid.column.IColumn ): void; - startEdit?( record?:number, columnHeader?:Ext.grid.column.IColumn ): void; - startEdit?( record?:Ext.data.IModel, columnHeader?:number ): void; - startEdit?( record?:number, columnHeader?:number ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.grid.plugin { - export interface IHeaderReorderer extends Ext.IAbstractPlugin { - /** [Method] The base implementation just sets the plugin s disabled flag to true Plugin subclasses which need more complex proce */ - disable?(): void; - /** [Method] The base implementation just sets the plugin s disabled flag to false Plugin subclasses which need more complex proc */ - enable?(): void; - /** [Method] The init method is invoked after initComponent method has been run for the client Component - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - } -} -declare module Ext.grid.plugin { - export interface IHeaderResizer extends Ext.IAbstractPlugin { - /** [Config Option] (Boolean) True to resize on the fly rather than using a proxy marker. ... */ - dynamic?: boolean; - /** [Method] The base implementation just sets the plugin s disabled flag to true Plugin subclasses which need more complex proce */ - disable?(): void; - /** [Method] The base implementation just sets the plugin s disabled flag to false Plugin subclasses which need more complex proc */ - enable?(): void; - /** [Method] Returns the value of dynamic */ - getDynamic?(): boolean; - /** [Method] not using w and e resize bc we are only ever resizing one column wResizeCursor Ext isWebKit w resize col resi - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - /** [Method] Sets the value of dynamic - * @param dynamic Boolean - */ - setDynamic?( dynamic?:boolean ): void; - } -} -declare module Ext.grid.plugin { - export interface IRowEditing extends Ext.grid.plugin.IEditing { - /** [Config Option] (Boolean) true to automatically cancel any pending changes when the row editor begins editing a new row. ... */ - autoCancel?: boolean; - /** [Config Option] (Number) The number of clicks to move the row editor to a new row while it is visible and actively editing another row. ... */ - clicksToMoveEditor?: number; - /** [Config Option] (Boolean) True to show a tooltip that summarizes all validation errors present in the row editor. ... */ - errorSummary?: boolean; - /** [Method] Starts editing the specified record using the specified Column definition to define which field is being edited - * @param record Ext.data.IModel The Store data record which backs the row to be edited. - * @param columnHeader Ext.data.IModel The Column object defining the column to be edited. - */ - startEdit?( record?:Ext.data.IModel, columnHeader?:Ext.data.IModel ): boolean; - } -} -declare module Ext.grid.plugin { - export interface IRowExpander extends Ext.IAbstractPlugin { - /** [Config Option] (Boolean) true to toggle a row between expanded/collapsed when double clicked (defaults to true). ... */ - expandOnDblClick?: boolean; - /** [Config Option] (Boolean) true to toggle selected row(s) between expanded/collapsed when the enter key is pressed (defaults to true). ... */ - expandOnEnter?: boolean; - /** [Config Option] (Boolean) true to select a row when clicking on the expander icon (defaults to false). ... */ - selectRowOnExpand?: boolean; - /** [Method] The init method is invoked after initComponent method has been run for the client Component - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - } -} -declare module Ext.grid.property { - export interface IGrid extends Ext.grid.IPanel { - /** [Config Option] (Boolean) Adds column line styling ... */ - columnLines?: boolean; - /** [Config Option] (Object) An object containing name/value pairs of custom editor type definitions that allow the grid to support additional typ... */ - customEditors?: any; - /** [Config Option] (Object) An object containing name/value pairs of custom renderer type definitions that allow the grid to support custom rende... */ - customRenderers?: any; - /** [Config Option] (Boolean) private config overrides False to disable column dragging within this grid. ... */ - enableColumnMove?: boolean; - /** [Config Option] (Boolean) True to automatically infer the type based on the initial value passed for each field. ... */ - inferTypes?: boolean; - /** [Config Option] (Number/String) Specify the width for the name column. ... */ - nameColumnWidth?: any; - /** [Config Option] (String) The name of the field from the property store to use as the property field name. ... */ - nameField?: string; - /** [Config Option] (Object) An object containing custom property name/display name pairs. ... */ - propertyNames?: any; - /** [Config Option] (Object) */ - source?: any; - /** [Config Option] (Object) This option allows various configurations to be set for each field in the property grid. ... */ - sourceConfig?: any; - /** [Config Option] (String) The name of the field from the property store to use as the value field name. ... */ - valueField?: string; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets the source data object containing the property data */ - getSource?(): any; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Removes a property from the grid - * @param prop String The name of the property to remove. - */ - removeProperty?( prop?:string ): void; - /** [Method] Sets the value of a property - * @param prop String The name of the property to set. - * @param value Object The value to test. - * @param create Boolean true to create the property if it doesn't already exist. - */ - setProperty?( prop?:string, value?:any, create?:boolean ): void; - /** [Method] Sets the source data object containing the property data - * @param source Object The data object. - * @param sourceConfig Object A new object. If this argument is not passed the current configuration will be re-used. To reset the config, pass null or an empty object literal. - */ - setSource?( source?:any, sourceConfig?:any ): void; - } -} -declare module Ext.grid { - export interface IPropertyGrid extends Ext.grid.IPanel { - /** [Config Option] (Boolean) Adds column line styling ... */ - columnLines?: boolean; - /** [Config Option] (Object) An object containing name/value pairs of custom editor type definitions that allow the grid to support additional typ... */ - customEditors?: any; - /** [Config Option] (Object) An object containing name/value pairs of custom renderer type definitions that allow the grid to support custom rende... */ - customRenderers?: any; - /** [Config Option] (Boolean) private config overrides False to disable column dragging within this grid. ... */ - enableColumnMove?: boolean; - /** [Config Option] (Boolean) True to automatically infer the type based on the initial value passed for each field. ... */ - inferTypes?: boolean; - /** [Config Option] (Number/String) Specify the width for the name column. ... */ - nameColumnWidth?: any; - /** [Config Option] (String) The name of the field from the property store to use as the property field name. ... */ - nameField?: string; - /** [Config Option] (Object) An object containing custom property name/display name pairs. ... */ - propertyNames?: any; - /** [Config Option] (Object) */ - source?: any; - /** [Config Option] (Object) This option allows various configurations to be set for each field in the property grid. ... */ - sourceConfig?: any; - /** [Config Option] (String) The name of the field from the property store to use as the value field name. ... */ - valueField?: string; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets the source data object containing the property data */ - getSource?(): any; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Removes a property from the grid - * @param prop String The name of the property to remove. - */ - removeProperty?( prop?:string ): void; - /** [Method] Sets the value of a property - * @param prop String The name of the property to set. - * @param value Object The value to test. - * @param create Boolean true to create the property if it doesn't already exist. - */ - setProperty?( prop?:string, value?:any, create?:boolean ): void; - /** [Method] Sets the source data object containing the property data - * @param source Object The data object. - * @param sourceConfig Object A new object. If this argument is not passed the current configuration will be re-used. To reset the config, pass null or an empty object literal. - */ - setSource?( source?:any, sourceConfig?:any ): void; - } -} -declare module Ext.grid.property { - export interface IHeaderContainer extends Ext.grid.header.IContainer { - } -} -declare module Ext.grid { - export interface IPropertyColumnModel extends Ext.grid.header.IContainer { - } -} -declare module Ext.grid.property { - export interface IProperty extends Ext.data.IModel { - /** [Config Option] (String/Object/Ext.data.Field) The name of the field treated as this Model's unique id. ... */ - idProperty?: any; - /** [Property] (Ext.util.MixedCollection) A Collection of the fields defined for this Model (including fields defined in superclasses) This is a collection of... */ - fields?: Ext.util.IMixedCollection; - } -} -declare module Ext { - export interface IPropGridProperty extends Ext.data.IModel { - /** [Config Option] (String/Object/Ext.data.Field) The name of the field treated as this Model's unique id. ... */ - idProperty?: any; - /** [Property] (Ext.util.MixedCollection) A Collection of the fields defined for this Model (including fields defined in superclasses) This is a collection of... */ - fields?: Ext.util.IMixedCollection; - } -} -declare module Ext.grid.property { - export interface IStore extends Ext.data.IStore { - /** [Config Option] (Boolean) If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - sortOnLoad?: boolean; - /** [Method] Return a singleton customized Proxy object which configures itself with a custom Reader Returns the proxy currently */ - getProxy?(): Ext.data.proxy.IProxy; - /** [Method] Should only be called by the grid */ - getSource?(): void; - /** [Method] Should only be called by the grid - * @param dataObject Object - */ - setSource?( dataObject?:any ): void; - } -} -declare module Ext.grid { - export interface IPropertyStore extends Ext.data.IStore { - /** [Config Option] (Boolean) If true, any sorters attached to this Store will be run after loading data, before the datachanged event is fired. ... */ - sortOnLoad?: boolean; - /** [Method] Return a singleton customized Proxy object which configures itself with a custom Reader Returns the proxy currently */ - getProxy?(): Ext.data.proxy.IProxy; - /** [Method] Should only be called by the grid */ - getSource?(): void; - /** [Method] Should only be called by the grid - * @param dataObject Object - */ - setSource?( dataObject?:any ): void; - } -} -declare module Ext.grid { - export interface IRowEditor extends Ext.form.IPanel { - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String) Change the hideMode to offsets so that we get accurate measurements when the roweditor is hidden for laying out thing... */ - hideMode?: string; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Returns the x coordinate of this element reletive to its offsetParent */ - getLocalX?(): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Returns true if any fields in this form have changed from their original values */ - isDirty?(): boolean; - /** [Method] Loads an Ext data Model into this form internally just calls Ext form Basic loadRecord See also trackResetOnLoad - * @param record Ext.data.IModel The record to load - */ - loadRecord?( record?:Ext.data.IModel ): Ext.form.IBasic; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Start editing the specified grid at the specified position - * @param record Ext.data.IModel The Store data record which backs the row to be edited. - * @param columnHeader Ext.data.IModel The Column object defining the column to be edited. - */ - startEdit?( record?:Ext.data.IModel, columnHeader?:Ext.data.IModel ): void; - } -} -declare module Ext.grid { - export interface IRowEditorButtons extends Ext.container.IContainer { - /** [Config Option] (Boolean) Specify as true to have the Component inject framing elements within the Component at render time to provide a graphi... */ - frame?: boolean; - /** [Method] Work round position absolute 100 width bug in IEQuirks Called by the layout system after the Component has been lai - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - } -} -declare module Ext.grid { - export interface IRowNumberer extends Ext.grid.column.IColumn { - /** [Config Option] (String) Sets the alignment of the header and rendered columns. ... */ - align?: string; - /** [Config Option] (String) An optional extra CSS class that will be added to this component's Element. ... */ - cls?: string; - /** [Config Option] (String) The name of the field in the grid's Ext.data.Store's Ext.data.Model definition from which to draw the column's value. ... */ - dataIndex?: string; - /** [Config Option] (Boolean) False to disable drag-drop reordering of this column. ... */ - draggable?: boolean; - /** [Config Option] (Boolean) False to prevent the user from hiding this column. ... */ - hideable?: boolean; - /** [Config Option] (Boolean) May not be moved from its preferred locked side when grid is enableLocking:true If the grid is configured with enabl... */ - lockable?: boolean; - /** [Config Option] (Boolean) True to disable the column header menu containing sort/hide options. ... */ - menuDisabled?: boolean; - /** [Config Option] (Boolean) private False to prevent the column from being resizable. ... */ - resizable?: boolean; - /** [Config Option] (String) Any valid text or HTML fragment to display in the header cell for the row number column. ... */ - text?: string; - /** [Config Option] (Number) The default width in pixels of the row number column. ... */ - width?: number; - } -} -declare module Ext.grid { - export interface IView extends Ext.view.ITable { - /** [Config Option] (Boolean) true to use overflow:'auto' on the components layout element and show scroll bars automatically when necessary, false... */ - autoScroll?: boolean; - /** [Config Option] (Boolean) True to stripe the rows. ... */ - stripeRows?: boolean; - } -} -declare module Ext.grid { - export interface IViewDropZone extends Ext.view.IDropZone { - } -} -declare module Ext { - export interface IImg extends Ext.IComponent { - /** [Config Option] (String) The descriptive text for non-visual UI description. ... */ - alt?: string; - /** [Config Option] (String/Object) A tag name or DomHelper spec used to create the Element which will encapsulate this Component. ... */ - autoEl?: any; - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number/String) A numeric unicode character code to serve as the image. ... */ - glyph?: any; - /** [Config Option] (String) Optional CSS classes to add to the img element. ... */ - imgCls?: string; - /** [Config Option] (String) The image src. ... */ - src?: string; - /** [Config Option] (String) Specifies addtional information about the image. ... */ - title?: string; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Updates the src of the image - * @param src String - */ - setSrc?( src?:string ): void; - } -} -declare module Ext { - export interface Iis { - } - export class is { - } -} -declare module Ext { - /** [Property] (String) URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images. ... */ - export var BLANK_IMAGE_URL: string; - /** [Property] (String) URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent the IE insecure content... */ - export var SSL_SECURE_URL: string; - /** [Property] (Boolean) Indicates whether to use native browser parsing for JSON methods. ... */ - export var USE_NATIVE_JSON: boolean; - /** [Property] (Number) */ - export var chromeVersion: number; - /** [Property] (Function) */ - export var emptyFn: any; - /** [Property] (Object) A zero length string which will pass a truth test. ... */ - export var emptyString: any; - /** [Property] (Boolean) */ - export var enableFx: boolean; - /** [Property] (Boolean) True to automatically uncache orphaned Ext.Elements periodically ... */ - export var enableGarbageCollector: boolean; - /** [Property] (Boolean) True to automatically purge event listeners during garbageCollection. ... */ - export var enableListenerCollection: boolean; - /** [Property] (Boolean) Experimental. ... */ - export var enableNestedListenerRemoval: boolean; - /** [Property] (String[]) */ - export var enumerables: string[]; - /** [Property] (Number) */ - export var firefoxVersion: number; - /** [Property] (Ext.util.Observable) An instance of Ext.util.Observable through which Ext fires global events. ... */ - export var globalEvents: Ext.util.IObservable; - /** [Property] (Number) The current version of IE (0 if the browser is not IE). ... */ - export var ieVersion: number; - /** [Property] (Boolean) */ - export var isChrome: boolean; - /** [Property] (Boolean) */ - export var isFF10: boolean; - /** [Property] (Boolean) */ - export var isFF3_0: boolean; - /** [Property] (Boolean) */ - export var isFF3_5: boolean; - /** [Property] (Boolean) */ - export var isFF3_6: boolean; - /** [Property] (Boolean) */ - export var isFF4: boolean; - /** [Property] (Boolean) */ - export var isFF5: boolean; - /** [Property] (Boolean) True if the detected browser uses the Gecko layout engine (e.g. ... */ - export var isGecko: boolean; - /** [Property] (Boolean) True if the detected browser uses a Gecko 5.0+ layout engine (e.g. ... */ - export var isGecko10: boolean; - /** [Property] (Boolean) True if the detected browser uses a Gecko 1.9+ layout engine (e.g. ... */ - export var isGecko3: boolean; - /** [Property] (Boolean) True if the detected browser uses a Gecko 2.0+ layout engine (e.g. ... */ - export var isGecko4: boolean; - /** [Property] (Boolean) True if the detected browser uses a Gecko 5.0+ layout engine (e.g. ... */ - export var isGecko5: boolean; - /** [Property] (Boolean) */ - export var isIE: boolean; - /** [Property] (Boolean) */ - export var isIE10: boolean; - /** [Property] (Boolean) */ - export var isIE10m: boolean; - /** [Property] (Boolean) */ - export var isIE10p: boolean; - /** [Property] (Boolean) */ - export var isIE6: boolean; - /** [Property] (Boolean) */ - export var isIE7: boolean; - /** [Property] (Boolean) */ - export var isIE7m: boolean; - /** [Property] (Boolean) */ - export var isIE7p: boolean; - /** [Property] (Boolean) */ - export var isIE8: boolean; - /** [Property] (Boolean) */ - export var isIE8m: boolean; - /** [Property] (Boolean) */ - export var isIE8p: boolean; - /** [Property] (Boolean) */ - export var isIE9: boolean; - /** [Property] (Boolean) */ - export var isIE9m: boolean; - /** [Property] (Boolean) */ - export var isIE9p: boolean; - /** [Property] (Boolean) */ - export var isLinux: boolean; - /** [Property] (Boolean) */ - export var isMac: boolean; - /** [Property] (Boolean) */ - export var isOpera: boolean; - /** [Property] (Boolean) */ - export var isOpera10_5: boolean; - /** [Property] (Boolean) True when the document is fully initialized and ready for action ... */ - export var isReady: boolean; - /** [Property] (Boolean) */ - export var isSafari: boolean; - /** [Property] (Boolean) */ - export var isSafari2: boolean; - /** [Property] (Boolean) */ - export var isSafari3: boolean; - /** [Property] (Boolean) */ - export var isSafari4: boolean; - /** [Property] (Boolean) */ - export var isSafari5: boolean; - /** [Property] (Boolean) */ - export var isSafari5_0: boolean; - /** [Property] (Boolean) */ - export var isSecure: boolean; - /** [Property] (Boolean) */ - export var isWebKit: boolean; - /** [Property] (Boolean) */ - export var isWindows: boolean; - /** [Property] (String) The name of the property in the global namespace (The window in browser environments) which refers to the current ins... */ - export var name: string; - /** [Property] (Number) */ - export var operaVersion: number; - /** [Property] (Number) */ - export var safariVersion: number; - /** [Property] (Boolean) By default, Ext intelligently decides whether floating elements should be shimmed. ... */ - export var useShims: boolean; - /** [Property] (Number) */ - export var webKitVersion: number; - /** [Method] Applies event listeners to elements by selectors when the document is ready - * @param obj Object The list of behaviors to apply - */ - export function addBehaviors( obj?:any ): void; - /** [Method] Adds namespace s to known list - * @param namespace String - */ - export function addNamespaces( namespace?:string ): void; - export function addNamespaces( namespace?:string[] ): void; - /** [Method] Loads Ext app Application class and starts it up with given configuration after the page is ready - * @param config any Application config object or name of a class derived from Ext.app.Application. - */ - export function application( config?:any ): void; - /** [Method] Copies all the properties of config to the specified object - * @param object Object The receiver of the properties - * @param config Object The source of the properties - * @param defaults Object A different object that will also be applied for default values - */ - export function apply( object?:any, config?:any, defaults?:any ): any; - /** [Method] Copies all the properties of config to object if they don t already exist - * @param object Object The receiver of the properties - * @param config Object The source of the properties - */ - export function applyIf( object?:any, config?:any ): any; - /** [Method] Utility wrapper that suspends layouts of all components for the duration of a given function - * @param fn Function The function to execute. - * @param scope Object The scope (this reference) in which the specified function is executed. - */ - export function batchLayouts( fn?:any, scope?:any ): void; - /** [Method] Create a new function from the provided fn change this to the provided scope optionally overrides arguments for the - * @param fn any The function to delegate. - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the default global environment object (usually the browser window). - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - export function bind( fn?:any, scope?:any, args?:any, appendArgs?:any ): any; - export function bind( fn?:any, scope?:any, args?:any[], appendArgs?:boolean ): any; - export function bind( fn?:any, scope?:any, args?:any[], appendArgs?:number ): any; - /** [Method] Execute a callback function in a particular scope - * @param callback Function The callback to execute - * @param scope Object The scope to execute in - * @param args Array The arguments to pass to the function - * @param delay Number Pass a number to delay the call by a number of milliseconds. - */ - export function callback( callback?:any, scope?:any, args?:any[], delay?:number ): void; - /** [Method] Clone simple variables including array like objects DOM nodes and Date without keeping the old reference - * @param item Object The variable to clone - */ - export function clone( item?:any ): any; - /** [Method] Coerces the first value if possible so that it is comparable to the second value - * @param from Mixed The value to coerce - * @param to Mixed The value it must be compared against - */ - export function coerce( from?:any, to?:any ): any; - /** [Method] Copies a set of named properties fom the source object to the destination object - * @param dest any The destination object. - * @param source any The source object. - * @param names any Either an Array of property names, or a comma-delimited list of property names to copy. - * @param usePrototypeKeys any Defaults to false. Pass true to copy keys off of the prototype as well as the instance. - */ - export function copyTo( dest?:any, source?:any, names?:any, usePrototypeKeys?:any ): any; - export function copyTo( dest?:any, source?:any, names?:string, usePrototypeKeys?:boolean ): any; - export function copyTo( dest?:any, source?:any, names?:string[], usePrototypeKeys?:boolean ): any; - /** [Method] Instantiate a class by either full name alias or alternate name - * @param name String The class name or alias. Can be specified as xclass property if only one object parameter is specified. - * @param args Object... Additional arguments after the name will be passed to the class' constructor. - */ - export function create( name:string, ...args:any[] ): any; - /** [Method] Instantiate a class by its alias - * @param alias String - * @param args Object... Additional arguments after the alias will be passed to the class constructor. - */ - export function createByAlias( alias:string, ...args:any[] ): any; - /** [Method] Shorthand for Ext JSON decode Decodes parses a JSON string to an object - * @param json String The JSON string - * @param safe Boolean True to return null, false to throw an exception if the JSON is invalid. - */ - export function decode( json?:string, safe?:boolean ): any; - /** [Method] Calls this function after the number of millseconds specified optionally in a specific scope - * @param fn any The function to defer. - * @param millis any The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately) - * @param scope any The scope (this reference) in which the function is executed. If omitted, defaults to the browser window. - * @param args any Overrides arguments for the call. (Defaults to the arguments passed by the caller) - * @param appendArgs any if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position - */ - export function defer( fn?:any, millis?:any, scope?:any, args?:any, appendArgs?:any ): any; - export function defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:boolean ): number; - export function defer( fn?:any, millis?:number, scope?:any, args?:any[], appendArgs?:number ): number; - /** [Method] Defines a class or override - * @param className String The class name to create in string dot-namespaced format, for example: 'My.very.awesome.Class', 'FeedViewer.plugin.CoolPager' It is highly recommended to follow this simple convention: - The root and the class name are 'CamelCased' - Everything else is lower-cased Pass null to create an anonymous class. - * @param data Object The key - value pairs of properties to apply to this class. Property names can be of any valid strings, except those in the reserved listed below: - mixins - statics - config - alias - self - singleton - alternateClassName - override - * @param createdFn Function Optional callback to execute after the class is created, the execution scope of which (this) will be the newly created class itself. - */ - export function define( className?:string, data?:any, createdFn?:any ): Ext.IBase; - /** [Method] Create a closure for deprecated code - * @param packageName String The package name - * @param since String The last version before it's deprecated - * @param closure Function The callback function to be executed with the specified version is less than the current version - * @param scope Object The execution scope (this) if the closure - */ - export function deprecate( packageName?:string, since?:string, closure?:any, scope?:any ): void; - /** [Method] Attempts to destroy any objects passed to it by removing all event listeners removing them from the DOM if applicab - * @param args Ext.IElement An Ext.Element, Ext.Component, or an Array of either of these to destroy - */ - export function destroy( args?:Ext.IElement ): void; - export function destroy( args?:Ext.IComponent ): void; - export function destroy( args?:Ext.IElement[] ): void; - export function destroy( args:Ext.IComponent[] ): void; - /** [Method] Attempts to destroy and then remove a set of named properties of the passed object - * @param o Object The object (most likely a Component) who's properties you wish to destroy. - * @param args String... One or more names of the properties to destroy and remove from the object. - */ - export function destroyMembers( o:any, ...args:any[] ): void; - /** [Method] Iterates an array or an iterable value and invoke the given callback function for each item - * @param iterable any The value to be iterated. If this argument is not iterable, the callback function is called once. - * @param fn Function The callback function. If it returns false, the iteration stops and this method returns the current index. - * @param scope Object The scope (this reference) in which the specified function is executed. - * @param reverse Boolean Reverse the iteration order (loop from the end to the beginning) Defaults false - */ - export function each( iterable?:any, fn?:any, scope?:any, reverse?:boolean ): boolean; - /** [Method] Shorthand for Ext JSON encode Encodes an Object Array or other value - * @param o Object The variable to encode - */ - export function encode( o?:any ): string; - /** [Method] Convenient shortcut to Ext Loader exclude Explicitly exclude files from being loaded - * @param excludes Array - */ - export function exclude( excludes?:any[] ): any; - /** [Method] Gets the singleton flyweight element with the passed node as the active element - * @param dom any The dom node or id - * @param named any Allows for creation of named reusable flyweights to prevent conflicts (e.g. internally Ext uses "_global") - */ - export function fly( dom?:any, named?:any ): any; - export function fly( dom?:string, named?:string ): Ext.dom.element.IFly; - export function fly( dom?:HTMLElement, named?:string ): Ext.dom.element.IFly; - /** [Method] Retrieves Ext dom Element objects - * @param el any The id of the node, a DOM Node or an existing Element. - */ - export function get( el?:any ): any; - export function get( el?:string ): Ext.dom.IElement; - export function get( el?:HTMLElement ): Ext.dom.IElement; - export function get( el?:Ext.IElement ): Ext.dom.IElement; - /** [Method] Returns the current document body as an Ext Element */ - export function getBody(): Ext.IElement; - /** [Method] Get the class of the provided object returns null if it s not an instance of any class created with Ext define - * @param object Object - */ - export function getClass( object?:any ): Ext.IClass; - /** [Method] Get the name of the class by its reference or its instance Ext ClassManager getName is usually invoked by the short - * @param object any - */ - export function getClassName( object?:any ): string; - /** [Method] This is shorthand reference to Ext ComponentManager get - * @param id String The component id - */ - export function getCmp( id?:string ): any; - /** [Method] Returns the current HTML document object as an Ext Element */ - export function getDoc(): Ext.IElement; - /** [Method] Returns the dom node for the passed String id dom node or Ext Element - * @param el any - */ - export function getDom( el?:any ): any; - export function getDom( el?:string ): any; - export function getDom( el?:HTMLElement ): any; - export function getDom( el?:Ext.IElement ): any; - /** [Method] Returns the current document head as an Ext Element */ - export function getHead(): Ext.IElement; - /** [Method] Get namespace prefix for a class name - * @param className String - */ - export function getNamespace( className?:string ): string; - /** [Method] Returns the current orientation of the mobile device */ - export function getOrientation(): string; - /** [Method] Returns the size of the browser scrollbars - * @param force Boolean true to force a recalculation of the value. - */ - export function getScrollbarSize( force?:boolean ): any; - /** [Method] Shortcut to Ext data StoreManager lookup - * @param store any The id of the Store, or a Store instance, or a store configuration - */ - export function getStore( store?:any ): Ext.data.IStore; - /** [Method] Get the version number of the supplied package name will return the last registered version last Ext setVersion cal - * @param packageName String The package name, for example: 'core', 'touch', 'extjs' - */ - export function getVersion( packageName?:string ): Ext.IVersion; - /** [Method] Generates unique ids - * @param el any The element to generate an id for - * @param prefix any Id prefix (defaults "ext-gen") - */ - export function id( el?:any, prefix?:any ): any; - export function id( el?:HTMLElement, prefix?:string ): string; - export function id( el?:Ext.IElement, prefix?:string ): string; - /** [Method] A reusable identity function - * @param o Object - */ - export function identityFn( o?:any ): void; - /** [Method] Returns true if the passed value is a JavaScript Array false otherwise - * @param target Object The target to test - */ - export function isArray( target?:any ): boolean; - /** [Method] Returns true if the passed value is a boolean - * @param value Object The value to test - */ - export function isBoolean( value?:any ): boolean; - /** [Method] Returns true if the passed value is a JavaScript Date object false otherwise - * @param object Object The object to test - */ - export function isDate( object?:any ): boolean; - /** [Method] Returns true if the passed value is defined - * @param value Object The value to test - */ - export function isDefined( value?:any ): boolean; - /** [Method] Returns true if the passed value is an HTMLElement - * @param value Object The value to test - */ - export function isElement( value?:any ): boolean; - /** [Method] Returns true if the passed value is empty false otherwise - * @param value Object The value to test - * @param allowEmptyString Boolean true to allow empty strings (defaults to false) - */ - export function isEmpty( value?:any, allowEmptyString?:boolean ): boolean; - /** [Method] Returns true if the passed value is a JavaScript Function false otherwise - * @param value Object The value to test - */ - export function isFunction( value?:any ): boolean; - /** [Method] Returns true if the passed value is iterable false otherwise - * @param value Object The value to test - */ - export function isIterable( value?:any ): boolean; - /** [Method] Returns true if the passed value is a number - * @param value Object The value to test - */ - export function isNumber( value?:any ): boolean; - /** [Method] Validates that a value is numeric - * @param value Object Examples: 1, '1', '2.34' - */ - export function isNumeric( value?:any ): boolean; - /** [Method] Returns true if the passed value is a JavaScript Object false otherwise - * @param value Object The value to test - */ - export function isObject( value?:any ): boolean; - /** [Method] Returns true if the passed value is a JavaScript primitive a string number or boolean - * @param value Object The value to test - */ - export function isPrimitive( value?:any ): boolean; - /** [Method] Returns true if the passed value is a string - * @param value Object The value to test - */ - export function isString( value?:any ): boolean; - /** [Method] Returns true if the passed value is a TextNode - * @param value Object The value to test - */ - export function isTextNode( value?:any ): boolean; - /** [Method] Iterates either an array or an object - * @param object any The object or array to be iterated. - * @param fn Function The function to be called for each iteration. See and Ext.Array.each and Ext.Object.each for detailed lists of arguments passed to this function depending on the given object type that is being iterated. - * @param scope Object The scope (this reference) in which the specified function is executed. Defaults to the object being iterated itself. - */ - export function iterate( object?:any, fn?:any, scope?:any ): void; - /** [Method] Logs a message - * @param options any The message to log or an options object with any of the following properties: msg: The message to log (required). level: One of: "error", "warn", "info" or "log" (the default is "log"). dump: An object to dump to the log as part of the message. stack: True to include a stack trace in the log. indent: Cause subsequent log statements to be indented one step. outdent: Cause this and following statements to be one step less indented. - * @param message String... The message to log (required unless specified in options object). - */ - export function log( options:any, ...message:any[] ): void; - /** [Method] A convenient alias method for Ext Object merge - * @param destination Object The object into which all subsequent objects are merged. - * @param object Object... Any number of objects to merge into the destination. - */ - export function merge( destination:any, ...object:any[] ): any; - /** [Method] Creates namespaces to be used for scoping variables and classes so that they are not global - * @param namespaces String... - */ - export function namespace( ...namespaces:any[] ): any; - /** [Method] Convenient alias for Ext namespace - * @param namespaces String... - */ - export function ns( ...namespaces:any[] ): any; - /** [Method] Shorthand for the Ext util Observable addListener method of the globalEvents Observable instance - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - export function on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds a listener to be notified when the document is ready before onload and before images are loaded - * @param fn Function The method the event invokes. - * @param scope Object The scope (this reference) in which the handler function executes. Defaults to the browser window. - * @param options Object Options object as passed to Ext.Element.addListener. - */ - export function onDocumentReady( fn?:any, scope?:any, options?:any ): void; - /** [Method] Adds a function to be called when the DOM is ready and all required classes have been loaded - * @param fn Function The function callback to be executed - * @param scope Object The execution scope (this reference) of the callback function - * @param options Object The options to modify the listener as passed to addListener. - */ - export function onReady( fn?:any, scope?:any, options?:any ): void; - /** [Method] Overrides members of the specified target with the given values - * @param target Object The target to override. - * @param overrides Object The properties to add or replace on target. - */ - export function override( target?:any, overrides?:any ): void; - /** [Method] Create a new function from the provided fn the arguments of which are pre set to args - * @param fn Function The original function - * @param args Array The arguments to pass to new callback - * @param scope Object The scope (this reference) in which the function is executed. - */ - export function pass( fn?:any, args?:any[], scope?:any ): any; - /** [Method] Shorthand for Ext PluginManager registerType - * @param ptype String The ptype mnemonic string by which the Plugin class may be looked up. - * @param cls Function The new Plugin class. - */ - export function preg( ptype?:string, cls?:any ): void; - /** [Method] Shorthand of Ext dom Query select Selects an array of DOM nodes by CSS XPath selector - * @param path String The selector/xpath query - * @param root HTMLElement The start of the query. - * @param type String Either "select" or "simple" for a simple selector match (only valid when used when the call is deferred to the jsSelect method) - * @param single Boolean Pass true to select only the first matching node using document.querySelector (where available) - */ - export function query( path?:string, root?:HTMLElement, type?:string, single?:boolean ): HTMLElement[]; - /** [Method] Creates a new store for the given id and config then registers it with the Store Manager - * @param id String The id to set on the new store - * @param config Object The store config - */ - export function regStore( id?:string, config?:any ): void; - /** [Method] Removes a DOM node from the document - * @param node HTMLElement The node to remove - */ - export function removeNode( node?:HTMLElement ): void; - /** [Method] Loads all classes by the given names and all their direct dependencies optionally executes the given callback functi - * @param expressions String Can either be a string or an array of string - * @param fn Function The callback function - * @param scope Object The execution scope (this) of the callback function - * @param excludes String Classes to be excluded, useful when being used with expressions - */ - export function require( expressions?:string, fn?:any, scope?:any, excludes?:string ): void; - export function require( expressions?:any[], fn?:any, scope?:any, excludes?:string ): void; - export function require( expressions?:string, fn?:any, scope?:any, excludes?:any[] ): void; - export function require( expressions?:any[], fn?:any, scope?:any, excludes?:any[] ): void; - /** [Method] - * @param flush Object - */ - export function resumeLayouts( flush?:any ): void; - /** [Method] Shorthand of Ext Element select - * @param selector String The CSS selector - * @param unique Boolean True to create a unique Ext.Element for each element. Defaults to a shared flyweight object. - */ - export function select( selector?:string, unique?:boolean ): Ext.ICompositeElement; - /** [Method] Sets the default font family to use for components that support a glyph config - * @param fontFamily String The name of the font-family - */ - export function setGlyphFontFamily( fontFamily?:string ): void; - /** [Method] Set version number for the given package name - * @param packageName any The package name, for example: 'core', 'touch', 'extjs' - * @param version any The version, for example: '1.2.3alpha', '2.4.0-dev' - */ - export function setVersion( packageName?:any, version?:any ): any; - export function setVersion( packageName?:string, version?:string ): any; - export function setVersion( packageName?:string, version?:Ext.IVersion ): any; - /** [Method] */ - export function suspendLayouts(): void; - /** [Method] Synchronously loads all classes by the given names and all their direct dependencies optionally executes the given c - * @param expressions String Can either be a string or an array of string - * @param fn Function The callback function - * @param scope Object The execution scope (this) of the callback function - * @param excludes String Classes to be excluded, useful when being used with expressions - */ - export function syncRequire( expressions?:string, fn?:any, scope?:any, excludes?:string ): void; - export function syncRequire( expressions?:any[], fn?:any, scope?:any, excludes?:string ): void; - export function syncRequire( expressions?:string, fn?:any, scope?:any, excludes?:any[] ): void; - export function syncRequire( expressions?:any[], fn?:any, scope?:any, excludes?:any[] ): void; - /** [Method] Converts any iterable numeric indices and a length property into a true array - * @param iterable Object the iterable object to be turned into a true Array. - * @param start Number a zero-based index that specifies the start of extraction. Defaults to 0 - * @param end Number a 1-based index that specifies the end of extraction. Defaults to the last index of the iterable value - */ - export function toArray( iterable?:any, start?:number, end?:number ): any[]; - /** [Method] Returns the type of the given variable in string format - * @param value Object - */ - export function typeOf( value?:any ): string; - /** [Method] Shorthand for the Ext util Observable removeListener method of the globalEvents Observable instance - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - export function un( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Returns the given value itself if it s not empty as described in isEmpty returns the default value second argument - * @param value Object The value to test - * @param defaultValue Object The value to return if the original value is empty - * @param allowBlank Boolean true to allow zero length strings to qualify as non-empty (defaults to false) - */ - export function valueFrom( value?:any, defaultValue?:any, allowBlank?:boolean ): any; - /** [Method] Convenient shorthand to create a widget by its xtype or a config object - * @param name String The xtype of the widget to create. - * @param config Object The configuration object for the widget constructor. - */ - export function widget( name?:string, config?:any ): any; -} -declare module Ext { - export interface IJSON { - } - export class JSON { - /** [Method] Decodes parses a JSON string to an object - * @param json String The JSON string - * @param safe Boolean True to return null, false to throw an exception if the JSON is invalid. - */ - static decode( json?:string, safe?:boolean ): any; - /** [Method] Encodes an Object Array or other value - * @param o Object The variable to encode - */ - static encode( o?:any ): string; - /** [Method] Encodes a Date - * @param d Date The Date to encode - */ - static encodeDate( d?:any ): string; - /** [Method] Encodes a String - * @param s String The String to encode - */ - static encodeString( s?:string ): string; - /** [Method] The function which encode uses to encode all javascript values to their JSON representations when Ext USE_NATIVE_JSON - * @param o Object Any javascript value to be converted to its JSON representation - */ - static encodeValue( o?:any ): string; - } -} -declare module Ext.layout { - export interface IClassList extends Ext.IBase { - /** [Method] Adds a single class to the class list - * @param cls Object - */ - add?( cls?:any ): void; - /** [Method] Adds one or more classes in an array or space delimited string to the class list - * @param classes Object - */ - addMany?( classes?:any ): void; - /** [Method] Removes a single class from the class list - * @param cls Object - */ - remove?( cls?:any ): void; - /** [Method] Removes one or more classes in an array or space delimited string from the class list - * @param classes Object - */ - removeMany?( classes?:any ): void; - } -} -declare module Ext.layout.component { - export interface IAuto extends Ext.layout.component.IComponent { - /** [Config Option] (Boolean) When publishing height of an auto Component, it is usually not written to the DOM. ... */ - setHeightInDom?: boolean; - /** [Config Option] (Boolean) When publishing width of an auto Component, it is usually not written to the DOM. ... */ - setWidthInDom?: boolean; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component { - export interface IBody extends Ext.layout.component.IAuto { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component { - export interface IBoundList extends Ext.layout.component.IAuto { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns the set of items to layout empty by default */ - getLayoutItems?(): void; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - } -} -declare module Ext.layout.component { - export interface IButton extends Ext.layout.component.IAuto { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component { - export interface IComponent extends Ext.layout.ILayout { - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns the element into which rendering must take place */ - getRenderTarget?(): Ext.IElement; - /** [Method] Returns the owner component s resize element */ - getTarget?(): Ext.IElement; - /** [Method] This method if implemented is called after all layouts are finished and all have a lastComponentSize cached - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - notifyOwner?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component { - export interface IDock extends Ext.layout.component.IComponent { - /** [Method] Removes layout s itemCls and owning Container s itemCls - * @param item Object - */ - afterRemove?( item?:any ): void; - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] We are overriding the Ext layout Layout configureItem method to also add a class that indicates the position of the d - * @param item Ext.IComponent The item we are configuring - */ - configureItem?( item?:Ext.IComponent ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Retrieve an ordered and or filtered array of all docked Components - * @param order String The desired ordering of the items ('render' or 'visual'). - * @param beforeBody Boolean An optional flag to limit the set of items to only those before the body (true) or after the body (false). All components are returned by default. - */ - getDockedItems?( order?:string, beforeBody?:boolean ): Ext.IComponent[]; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Returns an array containing all the visible docked items inside this layout s owner Panel */ - getLayoutItems?(): any[]; - /** [Method] The default weighting of docked items produces this arrangement - * @param ownerContext Object - * @param horz Object - * @param vert Object - */ - invalidateAxes?( ownerContext?:any, horz?:any, vert?:any ): void; - /** [Method] Render the top and left docked items before any existing DOM nodes in our render target and then render the right an - * @param items Object - * @param target Object - */ - renderItems?( items?:any, target?:any ): void; - } -} -declare module Ext.layout.component { - export interface IAbstractDock extends Ext.layout.component.IComponent { - /** [Method] Removes layout s itemCls and owning Container s itemCls - * @param item Object - */ - afterRemove?( item?:any ): void; - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] We are overriding the Ext layout Layout configureItem method to also add a class that indicates the position of the d - * @param item Ext.IComponent The item we are configuring - */ - configureItem?( item?:Ext.IComponent ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Retrieve an ordered and or filtered array of all docked Components - * @param order String The desired ordering of the items ('render' or 'visual'). - * @param beforeBody Boolean An optional flag to limit the set of items to only those before the body (true) or after the body (false). All components are returned by default. - */ - getDockedItems?( order?:string, beforeBody?:boolean ): Ext.IComponent[]; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Returns an array containing all the visible docked items inside this layout s owner Panel */ - getLayoutItems?(): any[]; - /** [Method] The default weighting of docked items produces this arrangement - * @param ownerContext Object - * @param horz Object - * @param vert Object - */ - invalidateAxes?( ownerContext?:any, horz?:any, vert?:any ): void; - /** [Method] Render the top and left docked items before any existing DOM nodes in our render target and then render the right an - * @param items Object - * @param target Object - */ - renderItems?( items?:any, target?:any ): void; - } -} -declare module Ext.layout.component { - export interface IDraw extends Ext.layout.component.IAuto { - /** [Config Option] (Boolean) When publishing height of an auto Component, it is usually not written to the DOM. ... */ - setHeightInDom?: boolean; - /** [Config Option] (Boolean) When publishing width of an auto Component, it is usually not written to the DOM. ... */ - setWidthInDom?: boolean; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface IComboBox extends Ext.layout.component.field.ITrigger { - } -} -declare module Ext.layout.component.field { - export interface IField extends Ext.layout.component.IAuto { - /** [Property] (Object) */ - elementId?: any; - /** [Property] (Object) Collection of named strategies for laying out and adjusting insets to accommodate error messages. ... */ - errorStrategies?: any; - /** [Property] (Object) Collection of named strategies for laying out and adjusting labels to accommodate error messages. ... */ - labelStrategies?: any; - /** [Property] (Object) */ - left?: any; - /** [Property] (Object) */ - qtip?: any; - /** [Property] (Object) */ - right?: any; - /** [Property] (Object) */ - side?: any; - /** [Property] (Object) */ - title?: any; - /** [Property] (Object) */ - top?: any; - /** [Property] (Object) */ - under?: any; - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Return the set of strategy functions from the errorStrategies collection that is appropriate for the field s msgTarge */ - getErrorStrategy?(): void; - /** [Method] Return the set of strategy functions from the labelStrategies collection that is appropriate for the field s labelAli */ - getLabelStrategy?(): void; - } -} -declare module Ext.layout.component.field { - export interface IFieldContainer extends Ext.layout.component.field.IField { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface IHtmlEditor extends Ext.layout.component.field.IFieldContainer { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface ISlider extends Ext.layout.component.field.IField { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface IText extends Ext.layout.component.field.IField { - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface ITextArea extends Ext.layout.component.field.IText { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component.field { - export interface ITrigger extends Ext.layout.component.field.IField { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.component { - export interface IFieldSet extends Ext.layout.component.IBody { - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns the set of items to layout empty by default */ - getLayoutItems?(): void; - } -} -declare module Ext.layout.component { - export interface IProgressBar extends Ext.layout.component.IAuto { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.layout.container { - export interface IAbsolute extends Ext.layout.container.IAnchor { - /** [Config Option] (Boolean) True indicates that changes to one item in this layout do not effect the layout in general. ... */ - ignoreOnContentChange?: boolean; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] This method is called when a child item changes in some way - * @param child Ext.IComponent The child item that has changed. - */ - onContentChange?( child?:Ext.IComponent ): boolean; - } -} -declare module Ext.layout { - export interface IAbsoluteLayout extends Ext.layout.container.IAnchor { - /** [Config Option] (Boolean) True indicates that changes to one item in this layout do not effect the layout in general. ... */ - ignoreOnContentChange?: boolean; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] This method is called when a child item changes in some way - * @param child Ext.IComponent The child item that has changed. - */ - onContentChange?( child?:Ext.IComponent ): boolean; - } -} -declare module Ext.layout.container { - export interface IAccordion extends Ext.layout.container.IVBox { - /** [Config Option] (Boolean) Only valid when multi is false and animate is false. ... */ - activeOnTop?: boolean; - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] (Boolean) True to slide the contained panels open and closed during expand/collapse using animation, false to open and close di... */ - animate?: boolean; - /** [Config Option] (Boolean) */ - autoWidth?: boolean; - /** [Config Option] (Boolean) True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the cont... */ - collapseFirst?: boolean; - /** [Config Option] (Boolean) True to adjust the active item's height to fill the available space in the container, false to use the item's current... */ - fill?: boolean; - /** [Config Option] (Boolean) True to hide the contained Panels' collapse/expand toggle buttons, false to display them. ... */ - hideCollapseTool?: boolean; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (Boolean) Set to true to enable multiple accordion items to be open at once. ... */ - multi?: boolean; - /** [Config Option] (Boolean) True to allow expand/collapse of each contained panel by clicking anywhere on the title bar, false to allow expand/co... */ - titleCollapse?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Iterates over all passed items ensuring they are rendered - * @param items Object - * @param target Object - */ - renderItems?( items?:any, target?:any ): void; - } -} -declare module Ext.layout { - export interface IAccordionLayout extends Ext.layout.container.IVBox { - /** [Config Option] (Boolean) Only valid when multi is false and animate is false. ... */ - activeOnTop?: boolean; - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] (Boolean) True to slide the contained panels open and closed during expand/collapse using animation, false to open and close di... */ - animate?: boolean; - /** [Config Option] (Boolean) */ - autoWidth?: boolean; - /** [Config Option] (Boolean) True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the cont... */ - collapseFirst?: boolean; - /** [Config Option] (Boolean) True to adjust the active item's height to fill the available space in the container, false to use the item's current... */ - fill?: boolean; - /** [Config Option] (Boolean) True to hide the contained Panels' collapse/expand toggle buttons, false to display them. ... */ - hideCollapseTool?: boolean; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (Boolean) Set to true to enable multiple accordion items to be open at once. ... */ - multi?: boolean; - /** [Config Option] (Boolean) True to allow expand/collapse of each contained panel by clicking anywhere on the title bar, false to allow expand/co... */ - titleCollapse?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Iterates over all passed items ensuring they are rendered - * @param items Object - * @param target Object - */ - renderItems?( items?:any, target?:any ): void; - } -} -declare module Ext.layout.container { - export interface IAnchor extends Ext.layout.container.IAuto { - /** [Config Option] (String) This configuation option is to be applied to child items of a container managed by this layout (ie. ... */ - anchor?: string; - /** [Config Option] (String) Default anchor for all child container items applied if no anchor or specific width is set on the child item. ... */ - defaultAnchor?: string; - /** [Property] (Boolean) true to rerun the layout if scrollbars are needed. ... */ - manageOverflow?: boolean; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - } -} -declare module Ext.layout { - export interface IAnchorLayout extends Ext.layout.container.IAuto { - /** [Config Option] (String) This configuation option is to be applied to child items of a container managed by this layout (ie. ... */ - anchor?: string; - /** [Config Option] (String) Default anchor for all child container items applied if no anchor or specific width is set on the child item. ... */ - defaultAnchor?: string; - /** [Property] (Boolean) true to rerun the layout if scrollbars are needed. ... */ - manageOverflow?: boolean; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - } -} -declare module Ext.layout.container { - export interface IAuto extends Ext.layout.container.IContainer { - /** [Config Option] (Boolean) Set to true to leave space for a vertical scrollbar (if the OS shows space-consuming scrollbars) regardless of whethe... */ - reserveScrollbar?: boolean; - /** [Property] (Boolean) true to rerun the layout if scrollbars are needed. ... */ - manageOverflow?: boolean; - /** [Property] (Boolean) indicates that this layout will correct cross browser padding differences when the container has overflow. ... */ - managePadding?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Handles overflow processing for a container - * @param ownerContext Ext.layout.IContextItem - */ - calculateOverflow?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns the container size that of the target - * @param ownerContext Ext.layout.IContextItem The owner's context item. - * @param inDom Boolean True if the container size must be in the DOM. - */ - getContainerSize?( ownerContext?:Ext.layout.IContextItem, inDom?:boolean ): any; - /** [Method] Overridden method from Ext layout container Container */ - getElementTarget?(): Ext.IElement; - /** [Method] Returns the overflow x style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowXStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] Returns the overflow y style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowYStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] Overridden method from Ext layout container Container */ - getRenderTarget?(): Ext.IElement; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - /** [Method] This method sets the height and or width of the outerCt innerCt to adjust for the following browser specific issues - * @param ownerContext Ext.layout.IContextItem - * @param containerSize Object - */ - setCtSizeIfNeeded?( ownerContext?:Ext.layout.IContextItem, containerSize?:any ): void; - } -} -declare module Ext.layout.container { - export interface IBorder extends Ext.layout.container.IContainer { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (Number/String/Object) Sets the padding to be applied to all child items managed by this layout. ... */ - padding?: any; - /** [Config Option] (Object) The default weights to assign to regions in the border layout. ... */ - regionWeights?: any; - /** [Config Option] (Boolean) This configuration option is to be applied to the child items managed by this layout. ... */ - split?: boolean; - /** [Config Option] (Boolean) This configuration option is to be applied to the child items managed by this layout and is used in conjunction with ... */ - splitterResize?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - } -} -declare module Ext.layout { - export interface IBorderLayout extends Ext.layout.container.IContainer { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (Number/String/Object) Sets the padding to be applied to all child items managed by this layout. ... */ - padding?: any; - /** [Config Option] (Object) The default weights to assign to regions in the border layout. ... */ - regionWeights?: any; - /** [Config Option] (Boolean) This configuration option is to be applied to the child items managed by this layout. ... */ - split?: boolean; - /** [Config Option] (Boolean) This configuration option is to be applied to the child items managed by this layout and is used in conjunction with ... */ - splitterResize?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - } -} -declare module Ext.layout.container { - export interface IBox extends Ext.layout.container.IContainer { - /** [Config Option] (Object) If the individual contained items do not have a margins property specified or margin specified via CSS, the default m... */ - defaultMargins?: any; - /** [Config Option] (Number) This configuration option is to be applied to child items of the container managed by this layout. ... */ - flex?: number; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (String) Controls how the child items of the container are packed together. ... */ - pack?: string; - /** [Config Option] (String) Sets the padding to be applied to all child items managed by this layout. ... */ - padding?: string; - /** [Config Option] (String/Ext.Component) Allows stretchMax calculation to take into account the max perpendicular size (height for HBox layout and width for V... */ - stretchMaxPartner?: any; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called to re cache our understanding of flexes - * @param ownerContext Object - */ - cacheFlexes?( ownerContext?:any ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Overridden method from Ext layout container Container */ - getElementTarget?(): Ext.IElement; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Overridden method from Ext layout container Container */ - getRenderTarget?(): Ext.IElement; - } -} -declare module Ext.layout { - export interface IBoxLayout extends Ext.layout.container.IContainer { - /** [Config Option] (Object) If the individual contained items do not have a margins property specified or margin specified via CSS, the default m... */ - defaultMargins?: any; - /** [Config Option] (Number) This configuration option is to be applied to child items of the container managed by this layout. ... */ - flex?: number; - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Config Option] (String) Controls how the child items of the container are packed together. ... */ - pack?: string; - /** [Config Option] (String) Sets the padding to be applied to all child items managed by this layout. ... */ - padding?: string; - /** [Config Option] (String/Ext.Component) Allows stretchMax calculation to take into account the max perpendicular size (height for HBox layout and width for V... */ - stretchMaxPartner?: any; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called to re cache our understanding of flexes - * @param ownerContext Object - */ - cacheFlexes?( ownerContext?:any ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Overridden method from Ext layout container Container */ - getElementTarget?(): Ext.IElement; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Overridden method from Ext layout container Container */ - getRenderTarget?(): Ext.IElement; - } -} -declare module Ext.layout.container.boxoverflow { - export interface IMenu extends Ext.layout.container.boxoverflow.INone { - /** [Config Option] (String) */ - triggerButtonCls?: string; - /** [Property] (Array) */ - menuItems?: any[]; - /** [Property] (String) HTML fragment to render into the toolbar overflow menu if there are no items to display ... */ - noItemsMenuText?: string; - } -} -declare module Ext.layout.boxoverflow { - export interface IMenu extends Ext.layout.container.boxoverflow.INone { - /** [Config Option] (String) */ - triggerButtonCls?: string; - /** [Property] (Array) */ - menuItems?: any[]; - /** [Property] (String) HTML fragment to render into the toolbar overflow menu if there are no items to display ... */ - noItemsMenuText?: string; - } -} -declare module Ext.layout.container.boxoverflow { - export interface INone extends Ext.IBase { - } -} -declare module Ext.layout.boxoverflow { - export interface INone extends Ext.IBase { - } -} -declare module Ext.layout.container.boxoverflow { - export interface IScroller extends Ext.layout.container.boxoverflow.INone,Ext.util.IObservable { - /** [Config Option] (String) CSS class added to the afterCt element. ... */ - afterCtCls?: string; - /** [Config Option] (String) */ - afterScrollerCls?: string; - /** [Config Option] (Boolean) True to animate the scrolling of items within the layout (ignored if enableScroll is false) ... */ - animateScroll?: boolean; - /** [Config Option] (String) CSS class added to the beforeCt element. ... */ - beforeCtCls?: string; - /** [Config Option] (String) */ - beforeScrollerCls?: string; - /** [Config Option] (Number) Number of milliseconds that each scroll animation lasts ... */ - scrollDuration?: number; - /** [Config Option] (Number) The number of pixels to scroll by on scroller click ... */ - scrollIncrement?: number; - /** [Config Option] (Number) Number of milliseconds between each scroll while a scroller button is held down ... */ - scrollRepeatInterval?: number; - /** [Config Option] (String) CSS class added to both scroller elements if enableScroll is used ... */ - scrollerCls?: string; - /** [Config Option] (Number) The number of pixels to increment on mouse wheel scrolling. ... */ - wheelIncrement?: number; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the current scroll position of the innerCt element */ - getScrollPosition?(): number; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Scrolls to the given component - * @param item String The item to scroll to. Can be a numerical index, component id or a reference to the component itself. - * @param animate Boolean True to animate the scrolling - */ - scrollToItem?( item?:string, animate?:boolean ): void; - scrollToItem?( item?:number, animate?:boolean ): void; - scrollToItem?( item?:Ext.IComponent, animate?:boolean ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.layout.boxoverflow { - export interface IScroller extends Ext.layout.container.boxoverflow.INone,Ext.util.IObservable { - /** [Config Option] (String) CSS class added to the afterCt element. ... */ - afterCtCls?: string; - /** [Config Option] (String) */ - afterScrollerCls?: string; - /** [Config Option] (Boolean) True to animate the scrolling of items within the layout (ignored if enableScroll is false) ... */ - animateScroll?: boolean; - /** [Config Option] (String) CSS class added to the beforeCt element. ... */ - beforeCtCls?: string; - /** [Config Option] (String) */ - beforeScrollerCls?: string; - /** [Config Option] (Number) Number of milliseconds that each scroll animation lasts ... */ - scrollDuration?: number; - /** [Config Option] (Number) The number of pixels to scroll by on scroller click ... */ - scrollIncrement?: number; - /** [Config Option] (Number) Number of milliseconds between each scroll while a scroller button is held down ... */ - scrollRepeatInterval?: number; - /** [Config Option] (String) CSS class added to both scroller elements if enableScroll is used ... */ - scrollerCls?: string; - /** [Config Option] (Number) The number of pixels to increment on mouse wheel scrolling. ... */ - wheelIncrement?: number; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the current scroll position of the innerCt element */ - getScrollPosition?(): number; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Scrolls to the given component - * @param item String The item to scroll to. Can be a numerical index, component id or a reference to the component itself. - * @param animate Boolean True to animate the scrolling - */ - scrollToItem?( item?:string, animate?:boolean ): void; - scrollToItem?( item?:number, animate?:boolean ): void; - scrollToItem?( item?:Ext.IComponent, animate?:boolean ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.layout.container { - export interface ICard extends Ext.layout.container.IFit { - /** [Config Option] (Boolean) True to render each contained item at the time it becomes active, false to render all contained items as soon as the ... */ - deferredRender?: boolean; - /** [Method] Called before both dynamic render and bulk render - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Return the active visible component in the layout */ - getActiveItem?(): Ext.IComponent; - /** [Method] Return the active visible component in the layout to the next card */ - getNext?(): Ext.IComponent; - /** [Method] Return the active visible component in the layout to the previous card */ - getPrev?(): Ext.IComponent; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - /** [Method] Sets the active visible component in the layout to the next card */ - next?(): Ext.IComponent; - /** [Method] Sets the active visible component in the layout to the previous card */ - prev?(): Ext.IComponent; - /** [Method] Makes the given card active - * @param newCard any The component, component id, itemId, or index of component. - */ - setActiveItem?( newCard?:any ): any; - setActiveItem?( newCard?:Ext.IComponent ): Ext.IComponent; - setActiveItem?( newCard?:number ): Ext.IComponent; - setActiveItem?( newCard?:string ): Ext.IComponent; - } -} -declare module Ext.layout { - export interface ICardLayout extends Ext.layout.container.IFit { - /** [Config Option] (Boolean) True to render each contained item at the time it becomes active, false to render all contained items as soon as the ... */ - deferredRender?: boolean; - /** [Method] Called before both dynamic render and bulk render - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Return the active visible component in the layout */ - getActiveItem?(): Ext.IComponent; - /** [Method] Return the active visible component in the layout to the next card */ - getNext?(): Ext.IComponent; - /** [Method] Return the active visible component in the layout to the previous card */ - getPrev?(): Ext.IComponent; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - /** [Method] Sets the active visible component in the layout to the next card */ - next?(): Ext.IComponent; - /** [Method] Sets the active visible component in the layout to the previous card */ - prev?(): Ext.IComponent; - /** [Method] Makes the given card active - * @param newCard any The component, component id, itemId, or index of component. - */ - setActiveItem?( newCard?:any ): any; - setActiveItem?( newCard?:Ext.IComponent ): Ext.IComponent; - setActiveItem?( newCard?:number ): Ext.IComponent; - setActiveItem?( newCard?:string ): Ext.IComponent; - } -} -declare module Ext.layout.container { - export interface ICheckboxGroup extends Ext.layout.container.IContainer { - /** [Config Option] (Boolean) By default, CheckboxGroup allocates all available space to the configured columns meaning that column are evenly spa... */ - autoFlex?: boolean; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Just wait for the child items to all lay themselves out in the width we are configured to make available to them - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - /** [Method] Always valid - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - /** [Method] Iterates over all passed items ensuring they are rendered - * @param items Object - */ - renderItems?( items?:any ): void; - } -} -declare module Ext.layout.container { - export interface IColumn extends Ext.layout.container.IAuto { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Property] (Boolean) true to rerun the layout if scrollbars are needed. ... */ - manageOverflow?: boolean; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] This method sets the height and or width of the outerCt innerCt to adjust for the following browser specific issues - * @param ownerContext Ext.layout.IContextItem - * @param containerSize Object - */ - setCtSizeIfNeeded?( ownerContext?:Ext.layout.IContextItem, containerSize?:any ): void; - } -} -declare module Ext.layout { - export interface IColumnLayout extends Ext.layout.container.IAuto { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Property] (Boolean) true to rerun the layout if scrollbars are needed. ... */ - manageOverflow?: boolean; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] This method sets the height and or width of the outerCt innerCt to adjust for the following browser specific issues - * @param ownerContext Ext.layout.IContextItem - * @param containerSize Object - */ - setCtSizeIfNeeded?( ownerContext?:Ext.layout.IContextItem, containerSize?:any ): void; - } -} -declare module Ext.layout.container { - export interface IContainer extends Ext.layout.ILayout,Ext.util.IElementContainer { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Property] (Ext.Element) */ - overflowPadderEl?: Ext.IElement; - /** [Method] Adds each argument passed to this method to the childEls array */ - addChildEls?(): void; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Returns the container size that of the target - * @param ownerContext Ext.layout.IContextItem The owner's context item. - * @param inDom Boolean True if the container size must be in the DOM. - */ - getContainerSize?( ownerContext?:Ext.layout.IContextItem, inDom?:boolean ): any; - /** [Method] Returns the element into which extra functional DOM elements can be inserted */ - getElementTarget?(): Ext.IElement; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - /** [Method] Returns the element into which rendering must take place */ - getRenderTarget?(): Ext.IElement; - /** [Method] Returns all items that are rendered */ - getRenderedItems?(): any[]; - /** [Method] Returns the owner component s resize element */ - getTarget?(): Ext.IElement; - /** [Method] Returns all items that are both rendered and visible */ - getVisibleItems?(): any[]; - /** [Method] Removes items in the childEls array based on the return value of a supplied test function - * @param testFn Function The test function. - */ - removeChildEls?( testFn?:any ): void; - } -} -declare module Ext.layout { - export interface IContainerLayout extends Ext.layout.ILayout,Ext.util.IElementContainer { - /** [Config Option] (String) An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Property] (Ext.Element) */ - overflowPadderEl?: Ext.IElement; - /** [Method] Adds each argument passed to this method to the childEls array */ - addChildEls?(): void; - /** [Method] In addition to work done by our base classes containers benefit from some extra cached data - * @param ownerContext Object - */ - beginLayout?( ownerContext?:any ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Adds layout s itemCls and owning Container s itemCls - * @param item Object - */ - configureItem?( item?:any ): void; - /** [Method] Returns the container size that of the target - * @param ownerContext Ext.layout.IContextItem The owner's context item. - * @param inDom Boolean True if the container size must be in the DOM. - */ - getContainerSize?( ownerContext?:Ext.layout.IContextItem, inDom?:boolean ): any; - /** [Method] Returns the element into which extra functional DOM elements can be inserted */ - getElementTarget?(): Ext.IElement; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - /** [Method] Returns the element into which rendering must take place */ - getRenderTarget?(): Ext.IElement; - /** [Method] Returns all items that are rendered */ - getRenderedItems?(): any[]; - /** [Method] Returns the owner component s resize element */ - getTarget?(): Ext.IElement; - /** [Method] Returns all items that are both rendered and visible */ - getVisibleItems?(): any[]; - /** [Method] Removes items in the childEls array based on the return value of a supplied test function - * @param testFn Function The test function. - */ - removeChildEls?( testFn?:any ): void; - } -} -declare module Ext.layout.container { - export interface IEditor extends Ext.layout.container.IContainer { - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - } -} -declare module Ext.layout.container { - export interface IFit extends Ext.layout.container.IContainer { - /** [Config Option] (Object) If the individual contained items do not have a margins property specified or margin specified via CSS, the default m... */ - defaultMargins?: any; - /** [Config Option] (String) End Definitions An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - } -} -declare module Ext.layout { - export interface IFitLayout extends Ext.layout.container.IContainer { - /** [Config Option] (Object) If the individual contained items do not have a margins property specified or margin specified via CSS, the default m... */ - defaultMargins?: any; - /** [Config Option] (String) End Definitions An optional extra CSS class that will be added to the container. ... */ - itemCls?: string; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - } -} -declare module Ext.layout.container { - export interface IForm extends Ext.layout.container.IContainer { - /** [Property] (Object) Returns flags indicating cross-browser handling of scrollHeight/Width. ... */ - getScrollRangeFlags?: any; - /** [Method] All of the below methods are old methods moved here from Container layout TODO remove these methods once Form layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Handles overflow processing for a container - * @param ownerContext Ext.layout.IContextItem - * @param containerSize Object - * @param dimensions Number A bit mask for the overflow managed dimensions. The 0-bit is for width and the 1-bit is for height. In other words, a value of 1 would be only width, 2 would be only height and 3 would be both. - */ - calculateOverflow?( ownerContext?:Ext.layout.IContextItem, containerSize?:any, dimensions?:number ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Creates an element that makes bottom right body padding consistent across browsers - * @param out Object - * @param renderData Object - */ - doRenderPadder?( out?:any, renderData?:any ): void; - /** [Method] Returns the container size that of the target - * @param ownerContext Ext.layout.IContextItem The owner's context item. - * @param inDom Boolean True if the container size must be in the DOM. - * @param ignoreOverflow Boolean if true scrollbar size will not be subtracted from container size. - */ - getContainerSize?( ownerContext?:Ext.layout.IContextItem, inDom?:boolean, ignoreOverflow?:boolean ): any; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] returns the overflow x style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowXStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] returns the overflow y style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowYStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] Returns the element into which rendering must take place */ - getRenderTarget?(): Ext.IElement; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - } -} -declare module Ext.layout { - export interface IFormLayout extends Ext.layout.container.IContainer { - /** [Property] (Object) Returns flags indicating cross-browser handling of scrollHeight/Width. ... */ - getScrollRangeFlags?: any; - /** [Method] All of the below methods are old methods moved here from Container layout TODO remove these methods once Form layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Handles overflow processing for a container - * @param ownerContext Ext.layout.IContextItem - * @param containerSize Object - * @param dimensions Number A bit mask for the overflow managed dimensions. The 0-bit is for width and the 1-bit is for height. In other words, a value of 1 would be only width, 2 would be only height and 3 would be both. - */ - calculateOverflow?( ownerContext?:Ext.layout.IContextItem, containerSize?:any, dimensions?:number ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Creates an element that makes bottom right body padding consistent across browsers - * @param out Object - * @param renderData Object - */ - doRenderPadder?( out?:any, renderData?:any ): void; - /** [Method] Returns the container size that of the target - * @param ownerContext Ext.layout.IContextItem The owner's context item. - * @param inDom Boolean True if the container size must be in the DOM. - * @param ignoreOverflow Boolean if true scrollbar size will not be subtracted from container size. - */ - getContainerSize?( ownerContext?:Ext.layout.IContextItem, inDom?:boolean, ignoreOverflow?:boolean ): any; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] returns the overflow x style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowXStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] returns the overflow y style of the render target - * @param ownerContext Ext.layout.IContextItem - */ - getOverflowYStyle?( ownerContext?:Ext.layout.IContextItem ): string; - /** [Method] Returns the element into which rendering must take place */ - getRenderTarget?(): Ext.IElement; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - } -} -declare module Ext.layout.container { - export interface IHBox extends Ext.layout.container.IBox { - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] ("round"/"floor"/"ceil") The Math method to use for rounding fractional pixels when align:middle is used. ... */ - alignRoundingMethod?: any; - /** [Config Option] (Boolean) Limits the size of aligned components to the size of the container under certain circumstances. ... */ - constrainAlign?: boolean; - } -} -declare module Ext.layout { - export interface IHBoxLayout extends Ext.layout.container.IBox { - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] ("round"/"floor"/"ceil") The Math method to use for rounding fractional pixels when align:middle is used. ... */ - alignRoundingMethod?: any; - /** [Config Option] (Boolean) Limits the size of aligned components to the size of the container under certain circumstances. ... */ - constrainAlign?: boolean; - } -} -declare module Ext.layout.container { - export interface ITable extends Ext.layout.container.IContainer { - /** [Config Option] (Number) The total number of columns to create in the table for this layout. ... */ - columns?: number; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <table&... */ - tableAttrs?: any; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <td>... */ - tdAttrs?: any; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <tr>... */ - trAttrs?: any; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called after all layouts have completed - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finalizeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - } -} -declare module Ext.layout { - export interface ITableLayout extends Ext.layout.container.IContainer { - /** [Config Option] (Number) The total number of columns to create in the table for this layout. ... */ - columns?: number; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <table&... */ - tableAttrs?: any; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <td>... */ - tdAttrs?: any; - /** [Config Option] (Object) An object containing properties which are added to the DomHelper specification used to create the layout's <tr>... */ - trAttrs?: any; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called after all layouts have completed - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finalizeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an array of child components either for a render phase Performed in the beforeLayout method of the layout s */ - getLayoutItems?(): Ext.IComponent[]; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - } -} -declare module Ext.layout.container { - export interface IVBox extends Ext.layout.container.IBox { - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] ("round"/"floor"/"ceil") The Math method to use for rounding fractional pixels when align:center is used. ... */ - alignRoundingMethod?: any; - /** [Config Option] (Boolean) Limits the size of aligned components to the size of the container under certain circumstances. ... */ - constrainAlign?: boolean; - } -} -declare module Ext.layout { - export interface IVBoxLayout extends Ext.layout.container.IBox { - /** [Config Option] (String) Controls how the child items of the container are aligned. ... */ - align?: string; - /** [Config Option] ("round"/"floor"/"ceil") The Math method to use for rounding fractional pixels when align:center is used. ... */ - alignRoundingMethod?: any; - /** [Config Option] (Boolean) Limits the size of aligned components to the size of the container under certain circumstances. ... */ - constrainAlign?: boolean; - } -} -declare module Ext.layout { - export interface IContext extends Ext.IBase { - /** [Property] (Ext.util.Queue) */ - layoutQueue?: Ext.util.IQueue; - /** [Property] (Number) One of these values: 0 - Before run 1 - Running 2 - Run complete ... */ - state?: number; - /** [Method] Flushes any pending writes to the DOM by calling each ContextItem in the flushQueue */ - flush?(): void; - /** [Method] Returns the ContextItem for a component - * @param cmp Ext.IComponent - */ - getCmp?( cmp?:Ext.IComponent ): void; - /** [Method] Returns the ContextItem for an element - * @param parent Ext.layout.IContextItem - * @param el Ext.dom.IElement - */ - getEl?( parent?:Ext.layout.IContextItem, el?:Ext.dom.IElement ): void; - /** [Method] Invalidates one or more components layouts component and container - * @param components Ext.IComponent An array of Components or a single Component. - * @param full Boolean True if all properties should be invalidated, otherwise only those calculated by the component should be invalidated. - */ - invalidate?( components?:Ext.IComponent, full?:boolean ): void; - invalidate?( components?:any[], full?:boolean ): void; - /** [Method] Removes the ContextItem for an element from the cache and from the parent s children array - * @param parent Ext.layout.IContextItem - * @param el Ext.dom.IElement - */ - removeEl?( parent?:Ext.layout.IContextItem, el?:Ext.dom.IElement ): void; - /** [Method] Resets the given layout object - * @param layout Object - * @param ownerContext Object - * @param firstTime Object - */ - resetLayout?( layout?:any, ownerContext?:any, firstTime?:any ): void; - /** [Method] Runs the layout calculations */ - run?(): boolean; - /** [Method] Performs one layout cycle by calling each layout in the layout queue */ - runCycle?(): boolean; - /** [Method] Set the size of a component element or composite or an array of components or elements - * @param item Ext.IComponent The item(s) to size. - * @param width Number The new width to set (ignored if undefined or NaN). - * @param height Number The new height to set (ignored if undefined or NaN). - */ - setItemSize?( item?:Ext.IComponent, width?:number, height?:number ): void; - setItemSize?( item?:Ext.IComponent[], width?:number, height?:number ): void; - setItemSize?( item?:Ext.dom.IElement, width?:number, height?:number ): void; - setItemSize?( item?:Ext.dom.IElement[], width?:number, height?:number ): void; - setItemSize?( item?:Ext.dom.ICompositeElement, width?:number, height?:number ): void; - } -} -declare module Ext.layout { - export interface IContextItem extends Ext.IBase { - /** [Property] (Object) State variables that are cleared when invalidated. ... */ - state?: any; - /** [Property] (Boolean) True if this item wraps a Component (rather than an Element). ... */ - wrapsComponent?: boolean; - /** [Method] Queue the addition of a class name or array of class names to this ContextItem s target when next flushed - * @param newCls Object - */ - addCls?( newCls?:any ): void; - /** [Method] Registers a layout in the block list for the given property - * @param layout Ext.layout.ILayout - * @param propName String The property name that blocked the layout (e.g., 'width'). - */ - block?( layout?:Ext.layout.ILayout, propName?:string ): void; - /** [Method] clears the margin cache so that marginInfo get re read from the dom on the next call to getMarginInfo This is neede */ - clearMarginCache?(): void; - /** [Method] Registers a layout in the DOM block list for the given property - * @param layout Ext.layout.ILayout - * @param propName String The property name that blocked the layout (e.g., 'width'). - */ - domBlock?( layout?:Ext.layout.ILayout, propName?:string ): void; - /** [Method] Flushes any updates in the dirty collection to the DOM */ - flush?(): void; - /** [Method] Gets the border information for the element as an object with left top right and bottom properties holding border s */ - getBorderInfo?(): any; - /** [Method] Returns a ClassList like object to buffer access to this item s element s classes */ - getClassList?(): void; - /** [Method] Gets a property of this object if it is correct in the DOM - * @param propName String The property name (e.g., 'width'). - */ - getDomProp?( propName?:string ): any; - /** [Method] Returns the context item for an owned element - * @param nameOrEl any The element or the name of an owned element - * @param owner any The owner of the named element if the passed "nameOrEl" parameter is a String. Defaults to this ContextItem's "target" property. For more details on owned elements see childEls and renderSelectors - */ - getEl?( nameOrEl?:any, owner?:any ): any; - getEl?( nameOrEl?:string, owner?:Ext.layout.container.IContainer ): Ext.layout.IContextItem; - getEl?( nameOrEl?:Ext.dom.IElement, owner?:Ext.layout.container.IContainer ): Ext.layout.IContextItem; - getEl?( nameOrEl?:string, owner?:Ext.IComponent ): Ext.layout.IContextItem; - getEl?( nameOrEl?:Ext.dom.IElement, owner?:Ext.IComponent ): Ext.layout.IContextItem; - /** [Method] Gets the frame information for the element as an object with left top right and bottom properties holding border */ - getFrameInfo?(): any; - /** [Method] Gets the margin information for the element as an object with left top right and bottom properties holding margin s */ - getMarginInfo?(): any; - /** [Method] Gets the padding information for the element as an object with left top right and bottom properties holding padding */ - getPaddingInfo?(): any; - /** [Method] Gets a property of this object - * @param propName String The property name that blocked the layout (e.g., 'width'). - */ - getProp?( propName?:string ): any; - /** [Method] Returns a style for this item - * @param styleName String The CSS style name. - */ - getStyle?( styleName?:string ): any; - /** [Method] Returns styles for this item - * @param styleNames String[] The CSS style names. - * @param altNames String[] The alternate names for the returned styles. If given, these names must correspond one-for-one to the styleNames. - */ - getStyles?( styleNames?:string[], altNames?:string[] ): any; - /** [Method] Returns true if the given property is correct in the DOM - * @param propName String The property name (e.g., 'width'). - */ - hasDomProp?( propName?:string ): boolean; - /** [Method] Returns true if the given property has been set - * @param propName String The property name (e.g., 'width'). - */ - hasProp?( propName?:string ): boolean; - /** [Method] Invalidates the component associated with this item - * @param options Object An object describing how to handle the invalidation. - */ - invalidate?( options?:any ): void; - /** [Method] Recovers a property value from the last computation and restores its value and dirty state - * @param propName String The name of the property to recover. - * @param oldProps Object The old "props" object from which to recover values. - * @param oldDirty Object The old "dirty" object from which to recover state. - */ - recoverProp?( propName?:string, oldProps?:any, oldDirty?:any ): void; - /** [Method] Queue the removal of a class name or array of class names from this ContextItem s target when next flushed - * @param removeCls Object - */ - removeCls?( removeCls?:any ): void; - /** [Method] Removes a cached ContextItem that was created using getEl - * @param nameOrEl String The element or the name of an owned element - * @param owner Ext.layout.container.IContainer The owner of the named element if the passed "nameOrEl" parameter is a String. Defaults to this ContextItem's "target" property. - */ - removeEl?( nameOrEl?:string, owner?:Ext.layout.container.IContainer ): void; - removeEl?( nameOrEl?:Ext.dom.IElement, owner?:Ext.layout.container.IContainer ): void; - removeEl?( nameOrEl?:string, owner?:Ext.IComponent ): void; - removeEl?( nameOrEl?:Ext.dom.IElement, owner?:Ext.IComponent ): void; - /** [Method] Queue the setting of a DOM attribute on this ContextItem s target when next flushed - * @param name Object - * @param value Object - */ - setAttribute?( name?:any, value?:any ): void; - /** [Method] Sets the contentHeight property - * @param height Object - * @param measured Object - */ - setContentHeight?( height?:any, measured?:any ): void; - /** [Method] Sets the contentWidth and contentHeight properties - * @param width Object - * @param height Object - * @param measured Object - */ - setContentSize?( width?:any, height?:any, measured?:any ): void; - /** [Method] Sets the contentWidth property - * @param width Object - * @param measured Object - */ - setContentWidth?( width?:any, measured?:any ): void; - /** [Method] Sets the height and constrains the height to min maxHeight range - * @param height Number The height. - * @param dirty Boolean Specifies if the value is currently in the DOM. A value of false indicates that the value is already in the DOM. - */ - setHeight?( height?:number, dirty?:boolean ): number; - /** [Method] Sets a property value - * @param propName String The property name (e.g., 'width'). - * @param value Object The new value of the property. - * @param dirty Boolean Optionally specifies if the value is currently in the DOM (default is true which indicates the value is not in the DOM and must be flushed at some point). - */ - setProp?( propName?:string, value?:any, dirty?:boolean ): number; - /** [Method] Sets the height and constrains the width to min maxWidth range - * @param width Number The width. - * @param dirty Boolean Specifies if the value is currently in the DOM. A value of false indicates that the value is already in the DOM. - */ - setWidth?( width?:number, dirty?:boolean ): number; - } -} -declare module Ext.layout { - export interface ILayout extends Ext.IBase { - /** [Property] (Boolean) Used only during a layout run, this value indicates that a layout has finished its calculations. ... */ - done?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Layout, or subclass thereof. ... */ - isLayout?: boolean; - /** [Method] Removes layout s itemCls and owning Container s itemCls - * @param item Object - */ - afterRemove?( item?:any ): void; - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before any calculation cycles to reset DOM values and prepare for calculation - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayoutCycle?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method if implemented is called at the end of the cycle in which this layout completes by not setting done to - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - completeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called before an item is rendered to allow the layout to configure the item - * @param item Ext.IComponent The item to be configured - */ - configureItem?( item?:Ext.IComponent ): void; - /** [Method] Destroys this layout */ - destroy?(): void; - /** [Method] This method if implemented is called after all layouts have completed - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finalizeLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Returns an object describing how this layout manages the size of the given component - * @param item Ext.IComponent - */ - getItemSizePolicy?( item?:Ext.IComponent ): Ext.layout.ISizePolicy; - /** [Method] Returns the set of items to layout empty by default */ - getLayoutItems?(): void; - /** [Method] A one time initialization method called just before rendering */ - initLayout?(): void; - /** [Method] Validates item is in the proper place in the dom - * @param item Object - * @param target Object - * @param position Object - */ - isValidParent?( item?:any, target?:any, position?:any ): void; - /** [Method] This method if implemented is called after all layouts are finished and all have a lastComponentSize cached - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - notifyOwner?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called when a child item changes in some way - * @param child Ext.IComponent The child item that has changed. - */ - onContentChange?( child?:Ext.IComponent ): boolean; - /** [Method] Iterates over all passed items ensuring they are rendered - * @param items Object - * @param target Object - */ - renderItems?( items?:any, target?:any ): void; - } -} -declare module Ext.layout { - export interface ISizeModel extends Ext.IBase { - /** [Property] (Boolean) */ - auto?: boolean; - /** [Property] (Boolean) True if the size is calculated by the ownerLayout. ... */ - calculated?: boolean; - /** [Property] (Boolean) True if the size is calculated by the ownerLayout based on a configured size. ... */ - calculatedFromConfigured?: boolean; - /** [Property] (Boolean) True if the size is calculated by the ownerLayout based on natural size model results. ... */ - calculatedFromNatural?: boolean; - /** [Property] (Boolean) True if the size is calculated by the ownerLayout based on shrinkWrap size model results. ... */ - calculatedFromShrinkWrap?: boolean; - /** [Property] (Boolean) True if the size is configured (e.g., by a width or minWidth). ... */ - configured?: boolean; - /** [Property] (Boolean) True if the size is constrained by a maxWidth or maxHeight configuration. ... */ - constrainedMax?: boolean; - /** [Property] (Boolean) True if the size is constrained by a minWidth or minHeight configuration. ... */ - constrainedMin?: boolean; - /** [Property] (Boolean) */ - fixed?: boolean; - /** [Property] (String) */ - name?: string; - /** [Property] (Object) An object with the config property names that determine the size. ... */ - names?: any; - /** [Property] (Boolean) True if the size is determined by CSS and not by content. ... */ - natural?: boolean; - /** [Property] (Number) */ - ordinal?: number; - /** [Property] (Object[]) An array of objects indexed by the ordinal of a height SizeModel on a width SizeModel to yield an object describing b... */ - pairsByHeightOrdinal?: Object[]; - /** [Property] (Boolean) True if the size is determined by content irrespective of the container box. ... */ - shrinkWrap?: boolean; - } -} -declare module Ext.layout { - export interface ISizePolicy { - /** [Property] (Boolean) */ - readsHeight?: boolean; - /** [Property] (Boolean) */ - readsWidth?: boolean; - /** [Property] (Boolean) */ - setsHeight?: boolean; - /** [Property] (Boolean) */ - setsWidth?: boolean; - } -} -declare module Ext { - export interface ILoader { - } - export class Loader { - /** [Method] Sets a batch of path entries - * @param paths Object a set of className: path mappings - */ - static addClassPathMappings( paths?:Object ): Ext.ILoader; - /** [Method] Explicitly exclude files from being loaded - * @param excludes Array - */ - static exclude( excludes?:any[] ): any; - /** [Method] Get the config value corresponding to the specified name - * @param name String The config property name - */ - static getConfig( name?:string ): any; - /** [Method] Translates a className to a file path by adding the the proper prefix and converting the s to s - * @param className String - */ - static getPath( className?:string ): string; - /** [Method] Loads the specified script URL and calls the supplied callbacks - * @param options any The options object or simply the URL to load. - */ - static loadScript( options?:any ): void; - /** [Method] Add a new listener to be executed when all required scripts are fully loaded - * @param fn Function The function callback to be executed - * @param scope Object The execution scope (this) of the callback function - * @param withDomReady Boolean Whether or not to wait for document dom ready as well - */ - static onReady( fn?:any, scope?:any, withDomReady?:boolean ): void; - /** [Method] Loads all classes by the given names and all their direct dependencies optionally executes the given callback functi - * @param expressions String Can either be a string or an array of string - * @param fn Function The callback function - * @param scope Object The execution scope (this) of the callback function - * @param excludes String Classes to be excluded, useful when being used with expressions - */ - static require( expressions?:string, fn?:any, scope?:any, excludes?:string ): void; - static require( expressions?:any[], fn?:any, scope?:any, excludes?:string ): void; - static require( expressions?:string, fn?:any, scope?:any, excludes?:any[] ): void; - static require( expressions?:any[], fn?:any, scope?:any, excludes?:any[] ): void; - /** [Method] Set the configuration for the loader - * @param config Object The config object to override the default values - */ - static setConfig( config?:any ): Ext.ILoader; - /** [Method] Sets the path of a namespace - * @param name any See flexSetter - * @param path String See flexSetter - */ - static setPath( name?:any, path?:string ): Ext.ILoader; - /** [Method] Synchronously loads all classes by the given names and all their direct dependencies optionally executes the given c - * @param expressions String Can either be a string or an array of string - * @param fn Function The callback function - * @param scope Object The execution scope (this) of the callback function - * @param excludes String Classes to be excluded, useful when being used with expressions - */ - static syncRequire( expressions?:string, fn?:any, scope?:any, excludes?:string ): void; - static syncRequire( expressions?:any[], fn?:any, scope?:any, excludes?:string ): void; - static syncRequire( expressions?:string, fn?:any, scope?:any, excludes?:any[] ): void; - static syncRequire( expressions?:any[], fn?:any, scope?:any, excludes?:any[] ): void; - } -} -declare module Ext { - export interface ILoadMask extends Ext.IComponent,Ext.util.IBindable,Ext.util.IFloating { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String) The CSS class to apply to the mask element ... */ - maskCls?: string; - /** [Config Option] (String) The text to display in a centered loading message box. ... */ - msg?: string; - /** [Config Option] (String) The CSS class to apply to the loading message element. ... */ - msgCls?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Ext.data.Store) Optional Store to which the mask is bound. ... */ - store?: Ext.data.IStore; - /** [Config Option] (Ext.Component) The Component you wish to mask. ... */ - target?: Ext.IComponent; - /** [Config Option] (Boolean) Whether or not to use a loading message class or simply mask the bound element. ... */ - useMsg?: boolean; - /** [Config Option] (Boolean) True to mask the targetEl of the bound Component. ... */ - useTargetEl?: boolean; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked after the Component is shown after onShow is called - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - afterShow?( animateTarget?:string, callback?:any, scope?:any ): void; - afterShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Changes the data store bound to this LoadMask - * @param store Ext.data.IStore The store to bind to this LoadMask - */ - bindStore?( store?:Ext.data.IStore ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Center this Component in its container */ - center?(): Ext.IComponent; - /** [Method] Moves this floating Component into a constrain region - * @param constrainTo String The Element or Region into which this Component is to be constrained. Defaults to the element into which this floating Component was rendered. - */ - doConstrain?( constrainTo?:string ): void; - doConstrain?( constrainTo?:HTMLElement ): void; - doConstrain?( constrainTo?:Ext.IElement ): void; - doConstrain?( constrainTo?:Ext.util.IRegion ): void; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] This method is called internally by Ext ZIndexManager to signal that a floating Component has either been moved to th - * @param active Boolean True to activate the Component, false to deactivate it. - * @param newActive Ext.IComponent The newly active Component which is taking over topmost zIndex position. - */ - setActive?( active?:boolean, newActive?:Ext.IComponent ): void; - /** [Method] Shows this Component rendering it first if autoRender or floating are true - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening. - * @param callback any A callback function to call after the Component is displayed. Only necessary if animation was specified. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - show?( animateTarget?:any, callback?:any, scope?:any ): any; - show?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - show?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] Sends this Component to the back of lower z index than any other visible windows */ - toBack?(): Ext.IComponent; - /** [Method] Brings this floating Component to the front of any other visible floating Components managed by the same ZIndexManag - * @param preventFocus Boolean Specify true to prevent the Component from being focused. - */ - toFront?( preventFocus?:boolean ): Ext.IComponent; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.menu { - export interface ICheckItem extends Ext.menu.IItem { - /** [Config Option] (Boolean) True to prevent the checked item from being toggled. ... */ - checkChangeDisabled?: boolean; - /** [Config Option] (Function) Alternative for the checkchange event. ... */ - checkHandler?: any; - /** [Config Option] (Boolean) True to render the menuitem initially checked. ... */ - checked?: boolean; - /** [Config Option] (String) The CSS class used by cls to show the checked state. ... */ - checkedCls?: string; - /** [Config Option] (String) Name of a radio group that the item belongs. ... */ - group?: string; - /** [Config Option] (String) The CSS class applied to this item's icon image to denote being a part of a radio group. ... */ - groupCls?: string; - /** [Config Option] (Boolean) Whether to not to hide the owning menu when this item is clicked. ... */ - hideOnClick?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) */ - scope?: any; - /** [Config Option] (String) The CSS class used by cls to show the unchecked state. ... */ - uncheckedCls?: string; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Disables just the checkbox functionality of this menu Item */ - disableCheckChange?(): void; - /** [Method] Reenables the checkbox functionality of this menu item after having been disabled by disableCheckChange */ - enableCheckChange?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Sets the checked state of the item - * @param checked Boolean True to check, false to uncheck - * @param suppressEvents Boolean True to prevent firing the checkchange events. - */ - setChecked?( checked?:boolean, suppressEvents?:boolean ): void; - } -} -declare module Ext.menu { - export interface IColorPicker extends Ext.menu.IMenu { - /** [Config Option] (Boolean) False to continue showing the menu after a color is selected. ... */ - hideOnClick?: boolean; - /** [Config Option] (String) */ - pickerId?: string; - /** [Property] (Ext.picker.Color) */ - picker?: Ext.picker.IColor; - } -} -declare module Ext.menu { - export interface IDatePicker extends Ext.menu.IMenu { - /** [Config Option] (Boolean) False to continue showing the menu after a date is selected. ... */ - hideOnClick?: boolean; - /** [Config Option] (String) */ - pickerId?: string; - /** [Property] (Ext.picker.Date) */ - picker?: Ext.picker.IDate; - } -} -declare module Ext.menu { - export interface IItem extends Ext.IComponent { - /** [Config Option] (String) The CSS class added to the menu item when the item is activated (focused/mouseover). ... */ - activeCls?: string; - /** [Config Option] (Boolean) Whether or not this menu item can be activated when focused/mouseovered. ... */ - canActivate?: boolean; - /** [Config Option] (Number) The delay in milliseconds to wait before hiding the menu after clicking the menu item. ... */ - clickHideDelay?: number; - /** [Config Option] (Boolean) Whether or not to destroy any associated sub-menu when this item is destroyed. ... */ - destroyMenu?: boolean; - /** [Config Option] (String) The CSS class added to the menu item when the item is disabled. ... */ - disabledCls?: string; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for this item. ... */ - glyph?: any; - /** [Config Option] (Function) A function called when the menu item is clicked (can be used instead of click event). ... */ - handler?: any; - /** [Config Option] (Boolean) Whether to not to hide the owning menu when this item is clicked. ... */ - hideOnClick?: boolean; - /** [Config Option] (String) The href attribute to use for the underlying anchor link. ... */ - href?: string; - /** [Config Option] (String) */ - hrefTarget?: string; - /** [Config Option] (String) The path to an icon to display in this item. ... */ - icon?: string; - /** [Config Option] (String) */ - iconCls?: string; - /** [Config Option] (Ext.menu.Menu/Object) */ - menu?: any; - /** [Config Option] (String) The default Ext.util.Positionable.getAlignToXY anchor position value for this item's sub-menu relative to this item's... */ - menuAlign?: string; - /** [Config Option] (Number) The delay in milliseconds before this item's sub-menu expands after this item is moused over. ... */ - menuExpandDelay?: number; - /** [Config Option] (Number) The delay in milliseconds before this item's sub-menu hides after this item is moused out. ... */ - menuHideDelay?: number; - /** [Config Option] (Boolean) */ - plain?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) */ - text?: string; - /** [Config Option] (String/Object) The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config obj... */ - tooltip?: any; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Property] (Boolean) */ - activated?: boolean; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Property] (Ext.menu.Menu) */ - parentMenu?: Ext.menu.IMenu; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Sets the click handler of this item - * @param fn Function The handler function - * @param scope Object The scope of the handler function - */ - setHandler?( fn?:any, scope?:any ): void; - /** [Method] Sets the icon on this item - * @param icon String The new icon - */ - setIcon?( icon?:string ): void; - /** [Method] Sets the iconCls of this item - * @param iconCls String The CSS class to set to iconCls - */ - setIconCls?( iconCls?:string ): void; - /** [Method] Set a child menu for this item - * @param menu any A menu, or menu configuration. null may be passed to remove the menu. - * @param destroyMenu Boolean True to destroy any existing menu. False to prevent destruction. If not specified, the destroyMenu configuration will be used. - */ - setMenu?( menu?:any, destroyMenu?:boolean ): void; - /** [Method] Sets the text of this item - * @param text String The text - */ - setText?( text?:string ): void; - /** [Method] Sets the tooltip for this menu item - * @param tooltip any This may be: String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip Object : A configuration object for Ext.tip.QuickTipManager.register. - */ - setTooltip?( tooltip?:any ): Ext.menu.IItem; - } -} -declare module Ext.menu { - export interface ITextItem extends Ext.IComponent { - /** [Config Option] (String) The CSS class added to the menu item when the item is activated (focused/mouseover). ... */ - activeCls?: string; - /** [Config Option] (Boolean) Whether or not this menu item can be activated when focused/mouseovered. ... */ - canActivate?: boolean; - /** [Config Option] (Number) The delay in milliseconds to wait before hiding the menu after clicking the menu item. ... */ - clickHideDelay?: number; - /** [Config Option] (Boolean) Whether or not to destroy any associated sub-menu when this item is destroyed. ... */ - destroyMenu?: boolean; - /** [Config Option] (String) The CSS class added to the menu item when the item is disabled. ... */ - disabledCls?: string; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for this item. ... */ - glyph?: any; - /** [Config Option] (Function) A function called when the menu item is clicked (can be used instead of click event). ... */ - handler?: any; - /** [Config Option] (Boolean) Whether to not to hide the owning menu when this item is clicked. ... */ - hideOnClick?: boolean; - /** [Config Option] (String) The href attribute to use for the underlying anchor link. ... */ - href?: string; - /** [Config Option] (String) */ - hrefTarget?: string; - /** [Config Option] (String) The path to an icon to display in this item. ... */ - icon?: string; - /** [Config Option] (String) */ - iconCls?: string; - /** [Config Option] (Ext.menu.Menu/Object) */ - menu?: any; - /** [Config Option] (String) The default Ext.util.Positionable.getAlignToXY anchor position value for this item's sub-menu relative to this item's... */ - menuAlign?: string; - /** [Config Option] (Number) The delay in milliseconds before this item's sub-menu expands after this item is moused over. ... */ - menuExpandDelay?: number; - /** [Config Option] (Number) The delay in milliseconds before this item's sub-menu hides after this item is moused out. ... */ - menuHideDelay?: number; - /** [Config Option] (Boolean) */ - plain?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) */ - text?: string; - /** [Config Option] (String/Object) The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config obj... */ - tooltip?: any; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Property] (Boolean) */ - activated?: boolean; - /** [Property] (Boolean) This is an internal flag that you use when creating custom components. ... */ - maskOnDisable?: boolean; - /** [Property] (Ext.menu.Menu) */ - parentMenu?: Ext.menu.IMenu; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Sets the click handler of this item - * @param fn Function The handler function - * @param scope Object The scope of the handler function - */ - setHandler?( fn?:any, scope?:any ): void; - /** [Method] Sets the icon on this item - * @param icon String The new icon - */ - setIcon?( icon?:string ): void; - /** [Method] Sets the iconCls of this item - * @param iconCls String The CSS class to set to iconCls - */ - setIconCls?( iconCls?:string ): void; - /** [Method] Set a child menu for this item - * @param menu any A menu, or menu configuration. null may be passed to remove the menu. - * @param destroyMenu Boolean True to destroy any existing menu. False to prevent destruction. If not specified, the destroyMenu configuration will be used. - */ - setMenu?( menu?:any, destroyMenu?:boolean ): void; - /** [Method] Sets the text of this item - * @param text String The text - */ - setText?( text?:string ): void; - /** [Method] Sets the tooltip for this menu item - * @param tooltip any This may be: String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip Object : A configuration object for Ext.tip.QuickTipManager.register. - */ - setTooltip?( tooltip?:any ): Ext.menu.IItem; - } -} -declare module Ext.menu { - export interface IKeyNav extends Ext.util.IKeyNav { - } -} -declare module Ext.menu { - export interface IManager extends Ext.IBase { - } - export class Manager { - /** [Method] Returns a Ext menu Menu object - * @param menu any The string menu id, an existing menu object reference, or a Menu config that will be used to generate and return a new Menu this. - */ - static get( menu?:any ): Ext.menu.IMenu; - /** [Method] Hides all menus that are currently visible */ - static hideAll(): boolean; - } -} -declare module Ext.menu { - export interface IMenuMgr extends Ext.IBase { - } - export class MenuMgr { - /** [Method] Returns a Ext menu Menu object - * @param menu any The string menu id, an existing menu object reference, or a Menu config that will be used to generate and return a new Menu this. - */ - static get( menu?:any ): Ext.menu.IMenu; - /** [Method] Hides all menus that are currently visible */ - static hideAll(): boolean; - } -} -declare module Ext.menu { - export interface IMenu extends Ext.panel.IPanel { - /** [Config Option] (Boolean) True to allow multiple menus to be displayed at the same time. ... */ - allowOtherMenus?: boolean; - /** [Config Option] (Boolean) True to enable keyboard navigation for controlling the menu. ... */ - enableKeyNav?: boolean; - /** [Config Option] (Boolean) A Menu configured as floating: true (the default) will be rendered as an absolutely positioned, floating Component. ... */ - floating?: boolean; - /** [Config Option] (Boolean) True to initially render the Menu as hidden, requiring to be shown manually. ... */ - hidden?: boolean; - /** [Config Option] (String) A String which specifies how this Component's encapsulating DOM element will be hidden. ... */ - hideMode?: string; - /** [Config Option] (Boolean) True to ignore clicks on any item in this menu that is a parent item (displays a submenu) so that the submenu is not ... */ - ignoreParentClicks?: boolean; - /** [Config Option] (Number) The minimum width of the Menu. ... */ - minWidth?: number; - /** [Config Option] (Boolean) True to remove the incised line down the left side of the menu and to not indent general Component items. ... */ - plain?: boolean; - /** [Config Option] (Boolean) True to show the icon separator. ... */ - showSeparator?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Menu, or subclass thereof. ... */ - isMenu?: boolean; - /** [Property] (Ext.menu.Menu) */ - parentMenu?: Ext.menu.IMenu; - /** [Method] Returns whether a menu item can be activated or not - * @param item Object - */ - canActivateItem?( item?:any ): boolean; - /** [Method] Deactivates the current active item on the menu if one exists - * @param andBlurFocusedItem Object - */ - deactivateActiveItem?( andBlurFocusedItem?:any ): void; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] Menus are never contained and must not ascertain their visibility from the ancestor hierarchy Returns true if this - * @param deep Boolean Pass true to interrogate the visibility status of all parent Containers to determine whether this Component is truly visible to the user. Generally, to determine whether a Component is hidden, the no argument form is needed. For example when creating dynamically laid out UIs in a hidden Container before showing them. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Shows this Component rendering it first if autoRender or floating are true - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true. The target from which the Component should animate from while opening. - * @param callback any A callback function to call after the Component is displayed. Only necessary if animation was specified. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - show?( animateTarget?:any, callback?:any, scope?:any ): any; - show?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - show?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] Shows this component by the specified Component or Element - * @param component any The Ext.Component or Ext.Element to show the component by. - * @param position any Alignment position as used by Ext.util.Positionable.getAlignToXY. Defaults to defaultAlign. - * @param offsets any Alignment offsets as used by Ext.util.Positionable.getAlignToXY. - */ - showBy?( component?:any, position?:any, offsets?:any ): any; - showBy?( component?:Ext.IComponent, position?:string, offsets?:number[] ): Ext.IComponent; - showBy?( component?:Ext.IElement, position?:string, offsets?:number[] ): Ext.IComponent; - } -} -declare module Ext.menu { - export interface ISeparator extends Ext.menu.IItem { - /** [Config Option] (String) The CSS class used by the separator item to show the incised line. ... */ - separatorCls?: string; - } -} -declare module Ext { - export interface IMessageBox extends Ext.window.IMessageBox { - } - export class MessageBox { - } -} -declare module Ext { - export interface IMsg extends Ext.window.IMessageBox { - } - export class Msg { - } -} -declare module Ext { - export interface IModelManager extends Ext.IAbstractManager { - } - export class ModelManager { - /** [Method] Returns the Ext data Model class for a given model name - * @param id any The classname of the model or the model class itself. - */ - static getModel( id?:any ): Ext.data.IModel; - } -} -declare module Ext { - export interface IModelMgr extends Ext.IAbstractManager { - } - export class ModelMgr { - /** [Method] Returns the Ext data Model class for a given model name - * @param id any The classname of the model or the model class itself. - */ - static getModel( id?:any ): Ext.data.IModel; - } -} -declare module Ext { - export interface INumber { - } - export class Number { - /** [Method] Checks whether or not the passed number is within a desired range - * @param number Number The number to check - * @param min Number The minimum number in the range - * @param max Number The maximum number in the range - */ - static constrain( number?:number, min?:number, max?:number ): number; - /** [Method] Corrects floating point numbers that overflow to a non precise value because of their floating nature for example 0 - * @param The Number number - */ - static correctFloat( The?:number ): number; - /** [Method] Validate that a value is numeric and convert it to a number if necessary - * @param value Object - * @param defaultValue Number The value to return if the original value is non-numeric - */ - static from( value?:any, defaultValue?:number ): number; - /** [Method] Returns a random integer between the specified range inclusive - * @param from Number Lowest value to return. - * @param to Number Highst value to return. - */ - static randomInt( from?:number, to?:number ): number; - /** [Method] Snaps the passed number between stopping points based upon a passed increment value - * @param value Number The unsnapped value. - * @param increment Number The increment by which the value must move. - * @param minValue Number The minimum value to which the returned value must be constrained. Overrides the increment. - * @param maxValue Number The maximum value to which the returned value must be constrained. Overrides the increment. - */ - static snap( value?:number, increment?:number, minValue?:number, maxValue?:number ): number; - /** [Method] Snaps the passed number between stopping points based upon a passed increment value - * @param value Number The unsnapped value. - * @param increment Number The increment by which the value must move. - * @param minValue Number The minimum value to which the returned value must be constrained. - * @param maxValue Number The maximum value to which the returned value must be constrained. - */ - static snapInRange( value?:number, increment?:number, minValue?:number, maxValue?:number ): number; - /** [Method] Formats a number using fixed point notation - * @param value Number The number to format - * @param precision Number The number of digits to show after the decimal point - */ - static toFixed( value?:number, precision?:number ): void; - } -} -declare module Ext { - export interface IObject { - } - export class Object { - /** [Method] Returns a new object with the given object as the prototype chain - * @param object Object The prototype chain for the new object. - */ - static chain( object?:any ): void; - /** [Method] Iterates through an object and invokes the given callback function for each iteration - * @param object Object The object to iterate - * @param fn Function The callback function. - * @param scope Object The execution scope (this) of the callback function - */ - static each( object?:any, fn?:any, scope?:any ): void; - /** [Method] Shallow compares the contents of 2 objects using strict equality - * @param object1 Object - * @param object2 Object - */ - static equals( object1?:any, object2?:any ): boolean; - /** [Method] Converts a query string back into an object - * @param queryString String The query string to decode - * @param recursive Boolean Whether or not to recursively decode the string. This format is supported by PHP / Ruby on Rails servers and similar. - */ - static fromQueryString( queryString?:string, recursive?:boolean ): any; - /** [Method] Returns the first matching key corresponding to the given value - * @param object Object - * @param value Object The value to find - */ - static getKey( object?:any, value?:any ): void; - /** [Method] Gets all keys of the given object as an array - * @param object Object - */ - static getKeys( object?:any ): string[]; - /** [Method] Gets the total number of this object s own properties var size Ext Object getSize name Jacky loves - * @param object Object - */ - static getSize( object?:any ): number; - /** [Method] Gets all values of the given object as an array - * @param object Object - */ - static getValues( object?:any ): any[]; - /** [Method] Checks if there are any properties on this object - * @param object Object - */ - static isEmpty( object?:any ): boolean; - /** [Method] Merges any number of objects recursively without referencing them or their children - * @param destination Object The object into which all subsequent objects are merged. - * @param object Object... Any number of objects to merge into the destination. - */ - static merge( destination:any, ...object:any[] ): any; - /** [Method] Converts a name value pair to an array of objects with support for nested structures - * @param name String - * @param value any - * @param recursive Boolean True to traverse object recursively - */ - static toQueryObjects( name?:string, value?:any, recursive?:boolean ): any[]; - /** [Method] Takes an object and converts it to an encoded query string - * @param object Object The object to encode - * @param recursive Boolean Whether or not to interpret the object in recursive format. (PHP / Ruby on Rails servers and similar). - */ - static toQueryString( object?:any, recursive?:boolean ): string; - } -} -declare module Ext.panel { - export interface IAbstractPanel extends Ext.container.IContainer,Ext.container.IDockingContainer { - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) A shortcut to add or remove the border on the body of a panel. ... */ - bodyBorder?: boolean; - /** [Config Option] (String/String[]) A CSS class, space-delimited string of classes, or array of classes to be applied to the panel's body element. ... */ - bodyCls?: any; - /** [Config Option] (Number/String) A shortcut for setting a padding style on the body element. ... */ - bodyPadding?: any; - /** [Config Option] (String/Object/Function) Custom CSS styles to be applied to the panel's body element, which can be supplied as a valid CSS style string, an ob... */ - bodyStyle?: any; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Object/Object[]) A component or series of components to be added as docked items to this panel. ... */ - dockedItems?: any; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Boolean/Number) Allows for this panel to include the dockedItems when trying to determine the overall size of the panel. ... */ - shrinkWrapDock?: any; - /** [Property] (Ext.dom.Element) The Panel's body Element which may be used to contain HTML content. ... */ - body?: Ext.dom.IElement; - /** [Property] (String) The name of the padding property that is used by the layout to manage padding. ... */ - contentPaddingProperty?: string; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Panel, or subclass thereof. ... */ - isPanel?: boolean; - /** [Method] Adds a CSS class to the body element - * @param cls String The class to add - */ - addBodyCls?( cls?:string ): Ext.panel.IPanel; - /** [Method] Adds docked item s to the container - * @param component any The Component or array of components to add. The components must include a 'dock' parameter on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left'). - * @param pos Number The index at which the Component will be added - */ - addDocked?( component?:any, pos?:number ): Ext.IComponent[]; - /** [Method] inherit docs Method which adds a specified UI uiCls to the components element - * @param ui String The UI to remove from the element. - */ - addUIClsToElement?( ui?:string ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Attempts a default component lookup see Ext container Container getComponent - * @param comp any The component id, itemId or position to find - */ - getComponent?( comp?:any ): any; - getComponent?( comp?:string ): Ext.IComponent; - getComponent?( comp?:number ): Ext.IComponent; - /** [Method] Finds a docked component by id itemId or position - * @param comp any The id, itemId or position of the docked component (see getComponent for details) - */ - getDockedComponent?( comp?:any ): any; - getDockedComponent?( comp?:string ): Ext.IComponent; - getDockedComponent?( comp?:number ): Ext.IComponent; - /** [Method] Retrieves an array of all currently docked Components - * @param selector String A ComponentQuery selector string to filter the returned items. - * @param beforeBody Boolean An optional flag to limit the set of items to only those before the body (true) or after the body (false). All components are returned by default. - */ - getDockedItems?( selector?:string, beforeBody?:boolean ): Ext.IComponent[]; - /** [Method] Used by ComponentQuery child and down to retrieve all of the items which can potentially be considered a child of th - * @param deep Object - */ - getRefItems?( deep?:any ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Inserts docked item s to the panel at the indicated position - * @param pos Number The index at which the Component will be inserted - * @param component any The Component or array of components to add. The components must include a 'dock' paramater on each component to indicate where it should be docked ('top', 'right', 'bottom', 'left'). - */ - insertDocked?( pos?:number, component?:any ): void; - /** [Method] Invoked after a docked item is added to the Panel - * @param component Ext.IComponent - */ - onDockedAdd?( component?:Ext.IComponent ): void; - /** [Method] Invoked after a docked item is removed from the Panel - * @param component Ext.IComponent - */ - onDockedRemove?( component?:Ext.IComponent ): void; - /** [Method] Removes a CSS class from the body element - * @param cls String The class to remove - */ - removeBodyCls?( cls?:string ): Ext.panel.IPanel; - /** [Method] Removes the docked item from the panel - * @param item Ext.IComponent The Component to remove. - * @param autoDestroy Boolean Destroy the component after removal. - */ - removeDocked?( item?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] inherit docs Method which removes a specified UI uiCls from the components element - * @param ui String The UI to add to the element. - */ - removeUIClsFromElement?( ui?:string ): void; - /** [Method] Sets the body style according to the passed parameters - * @param style Mixed A full style specification string, or object, or the name of a style property to set. - * @param value String If the first param was a style property name, the style property value. - */ - setBodyStyle?( style?:any, value?:string ): Ext.panel.IPanel; - } -} -declare module Ext.panel { - export interface IDD extends Ext.dd.IDragSource { - /** [Method] An empty function by default but provided so that you can perform a custom action after an invalid drop has occurred - * @param e Event The event object - * @param id String The id of the dropped element - */ - afterInvalidDrop?( e?:Event, id?:string ): void; - /** [Method] Sets the pointer offset to the distance between the linked element s top left corner and the location the element was - * @param iPageX Number the X coordinate of the click - * @param iPageY Number the Y coordinate of the click - */ - autoOffset?( iPageX?:number, iPageY?:number ): void; - /** [Method] Event that fires prior to the onMouseDown event - * @param e Object - */ - b4MouseDown?( e?:any ): void; - /** [Method] Creates the proxy element if it does not yet exist */ - createFrame?(): void; - /** [Method] Called when we are done dragging the object - * @param e Event the mouseup event - */ - endDrag?( e?:Event ): void; - /** [Method] Returns a reference to the actual element to drag */ - getDragEl?(): HTMLElement; - /** [Method] Override this we don t want to repair on an invalid drop the panel should main it s position Abstract method cal - * @param e Event the mouseup event - */ - onInvalidDrop?( e?:Event ): void; - /** [Method] Abstract method called after a drag drop object is clicked and the drag or mousedown time thresholds have beeen met - * @param x Number X click location - * @param y Number Y click location - */ - startDrag?( x?:number, y?:number ): void; - } -} -declare module Ext.panel { - export interface IHeader extends Ext.container.IContainer { - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for the panel header. ... */ - glyph?: any; - /** [Config Option] (String) Path to image for an icon in the header. ... */ - icon?: string; - /** [Config Option] (String) CSS class for an icon in the header. ... */ - iconCls?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Boolean/Number) If this property is a number, it is interpreted as follows: 0: Neither width nor height depend on content. ... */ - shrinkWrap?: any; - /** [Config Option] (String) */ - title?: string; - /** [Config Option] (String) The alignment of the title text within the available space between the icon and the tools. ... */ - titleAlign?: string; - /** [Config Option] (Number) The ordinal position among the header items (tools and other components specified using the items config) at which th... */ - titlePosition?: number; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Header, or subclass thereof. ... */ - isHeader?: boolean; - /** [Method] Add a tool to the header - * @param tool Object - */ - addTool?( tool?:any ): void; - /** [Method] inherit docs Method which adds a specified UI uiCls to the components element - * @param ui String The UI to remove from the element. - */ - addUIClsToElement?( ui?:string ): void; - /** [Method] Invoked after the Container has laid out and rendered if necessary its child Components - * @param layout Ext.layout.container.IContainer - */ - afterLayout?( layout?:Ext.layout.container.IContainer ): void; - /** [Method] Occurs before componentLayout is run */ - beforeLayout?(): void; - /** [Method] Gets the tools for this header */ - getTools?(): Ext.panel.ITool[]; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Set up the tools lt tool type gt link in the owning Panel - * @param component Object - * @param index Object - */ - onAdd?( component?:any, index?:any ): void; - /** [Method] inherit docs Method which removes a specified UI uiCls from the components element - * @param ui String The UI to add to the element. - */ - removeUIClsFromElement?( ui?:string ): void; - /** [Method] Sets glyph that provides the icon image for this header - * @param glyph Number the numeric charCode or string charCode/font-family. This parameter expects a format consistent with that of glyph - */ - setGlyph?( glyph?:number ): void; - setGlyph?( glyph?:string ): void; - /** [Method] Sets the image path that provides the icon image for this header - * @param icon String The new icon path - */ - setIcon?( icon?:string ): void; - /** [Method] Sets the CSS class that provides the icon image for this header - * @param cls String The new CSS class name - */ - setIconCls?( cls?:string ): void; - /** [Method] Sets the title of the header - * @param title String The title to be set - */ - setTitle?( title?:string ): void; - } -} -declare module Ext.panel { - export interface IPanel extends Ext.panel.IAbstractPanel { - /** [Config Option] (Boolean) true to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the Ext.... */ - animCollapse?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - bbar?: any; - /** [Config Option] (String) The alignment of any buttons added to this panel. ... */ - buttonAlign?: string; - /** [Config Option] (Object/Object[]) Convenience config used for adding buttons docked to the bottom of the panel. ... */ - buttons?: any; - /** [Config Option] (Boolean) True to display the 'close' tool button and allow the user to close the window, false to hide the button and disallow... */ - closable?: boolean; - /** [Config Option] (String) The action to take when the close header tool is clicked: 'destroy' : remove the window from the DOM and destroy i... */ - closeAction?: string; - /** [Config Option] (String) The direction to collapse the Panel when the toggle button is clicked. ... */ - collapseDirection?: string; - /** [Config Option] (Boolean) true to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the pane... */ - collapseFirst?: boolean; - /** [Config Option] (String) Important: this config is only effective for collapsible Panels which are direct child items of a border layout. ... */ - collapseMode?: string; - /** [Config Option] (Boolean) true to render the panel collapsed, false to render it expanded. ... */ - collapsed?: boolean; - /** [Config Option] (String) A CSS class to add to the panel's element after it has been collapsed. ... */ - collapsedCls?: string; - /** [Config Option] (Boolean) True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. ... */ - collapsible?: boolean; - /** [Config Option] (Boolean) True to constrain the panel within its containing element, false to allow it to fall outside of its containing element. ... */ - constrain?: boolean; - /** [Config Option] (Boolean) True to constrain the panel header within its containing element (allowing the panel body to fall outside of its cont... */ - constrainHeader?: boolean; - /** [Config Option] (Object/Object[]) A component or series of components to be added as docked items to this panel. ... */ - dockedItems?: any; - /** [Config Option] (Object/Object[]) Convenience config used for adding items to the bottom of the panel. ... */ - fbar?: any; - /** [Config Option] (Boolean) Important: This config is only effective for collapsible Panels which are direct child items of a border layout. ... */ - floatable?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel. ... */ - frame?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel panels header (if 'frame' is true). ... */ - frameHeader?: boolean; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for the panel header. ... */ - glyph?: any; - /** [Config Option] (Boolean/Object) Pass as false to prevent a Header from being created and shown. ... */ - header?: any; - /** [Config Option] (String) */ - headerOverCls?: string; - /** [Config Option] (String) Specify as 'top', 'bottom', 'left' or 'right'. ... */ - headerPosition?: string; - /** [Config Option] (Boolean) true to hide the expand/collapse toggle button when collapsible == true, false to display it. ... */ - hideCollapseTool?: boolean; - /** [Config Option] (String) Path to image for an icon in the header. ... */ - icon?: string; - /** [Config Option] (String) CSS class for an icon in the header. ... */ - iconCls?: string; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - lbar?: any; - /** [Config Option] (Boolean) When true, the dock component layout writes height information to the panel's DOM elements based on its shrink wrap h... */ - manageHeight?: boolean; - /** [Config Option] (Number) Minimum width of all footer toolbar buttons in pixels. ... */ - minButtonWidth?: number; - /** [Config Option] (Boolean) True to overlap the header in a panel over the framing of the panel itself. ... */ - overlapHeader?: boolean; - /** [Config Option] (Ext.Component/Object) Important: This config is only effective for collapsible Panels which are direct child items of a border layout when ... */ - placeholder?: any; - /** [Config Option] (Number) */ - placeholderCollapseHideMode?: number; - /** [Config Option] (Boolean) ... */ - preventHeader?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - rbar?: any; - /** [Config Option] (Boolean) When draggable is true, Specify this as true to cause the draggable config to work the same as it does in Window. ... */ - simpleDrag?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - tbar?: any; - /** [Config Option] (String) The title text to be used to display in the panel header. ... */ - title?: string; - /** [Config Option] (String) The alignment of the title text within the available space between the icon and the tools. ... */ - titleAlign?: string; - /** [Config Option] (Boolean) true to allow expanding and collapsing the panel (when collapsible = true) by clicking anywhere in the header bar, fa... */ - titleCollapse?: boolean; - /** [Config Option] (Object[]/Ext.panel.Tool[]) An array of Ext.panel.Tool configs/instances to be added to the header tool area. ... */ - tools?: any; - /** [Property] (Ext.dd.DragSource/Ext.util.ComponentDragger) Only present if this Panel has been configured with draggable true. ... */ - dd?: any; - /** [Method] Add tools to this panel - * @param tools any The tools to add - */ - addTool?( tools?:any ): void; - /** [Method] Template method to be implemented in subclasses to add their tools after the collapsible tool */ - addTools?(): void; - /** [Method] Invoked after the Panel is Collapsed - * @param animated Boolean - */ - afterCollapse?( animated?:boolean ): void; - /** [Method] Invoked after the Panel is Expanded - * @param animated Boolean - */ - afterExpand?( animated?:boolean ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Closes the Panel */ - close?(): void; - /** [Method] Collapses the panel body so that the body becomes hidden - * @param direction String The direction to collapse towards. Must be one of Ext.Component.DIRECTION_TOP Ext.Component.DIRECTION_RIGHT Ext.Component.DIRECTION_BOTTOM Ext.Component.DIRECTION_LEFT Defaults to collapseDirection. - * @param animate Boolean True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds. - */ - collapse?( direction?:string, animate?:boolean ): Ext.panel.IPanel; - /** [Method] converts a collapsdDir into an anchor argument for Element slideIn overridden in rtl mode to switch l and r - * @param collapseDir Object - */ - convertCollapseDir?( collapseDir?:any ): void; - /** [Method] Expands the panel body so that it becomes visible - * @param animate Boolean True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds. - */ - expand?( animate?:boolean ): Ext.panel.IPanel; - /** [Method] Returns the current collapsed state of the panel */ - getCollapsed?(): any; - /** [Method] Gets the Header for this panel */ - getHeader?(): void; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Determines whether this Component is the root of a layout */ - isLayoutRoot?(): void; - /** [Method] Returns true if this component is visible - * @param deep Boolean Pass true to interrogate the visibility status of all parent Containers to determine whether this Component is truly visible to the user. Generally, to determine whether a Component is hidden, the no argument form is needed. For example when creating dynamically laid out UIs in a hidden Container before showing them. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] - * @param border String The border, see border. If a falsey value is passed the border will be removed. - */ - setBorder?( border?:string ): void; - setBorder?( border?:number ): void; - /** [Method] Set the glyph for the panel s header - * @param newGlyph Number The new glyph This parameter expects a format consistent with that of glyph - */ - setGlyph?( newGlyph?:number ): void; - setGlyph?( newGlyph?:string ): void; - /** [Method] Set the icon for the panel s header - * @param newIcon String The new icon path - */ - setIcon?( newIcon?:string ): void; - /** [Method] Set the iconCls for the panel s header - * @param newIconCls String The new CSS class name - */ - setIconCls?( newIconCls?:string ): void; - /** [Method] Set a title for the panel s header - * @param newTitle String - */ - setTitle?( newTitle?:string ): void; - /** [Method] Sets the UI for the component - * @param ui String The new UI for the component. - */ - setUI?( ui?:string ): void; - /** [Method] Shortcut for performing an expand or collapse based on the current state of the panel */ - toggleCollapse?(): Ext.panel.IPanel; - } -} -declare module Ext { - export interface IPanel extends Ext.panel.IAbstractPanel { - /** [Config Option] (Boolean) true to animate the transition when the panel is collapsed, false to skip the animation (defaults to true if the Ext.... */ - animCollapse?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - bbar?: any; - /** [Config Option] (String) The alignment of any buttons added to this panel. ... */ - buttonAlign?: string; - /** [Config Option] (Object/Object[]) Convenience config used for adding buttons docked to the bottom of the panel. ... */ - buttons?: any; - /** [Config Option] (Boolean) True to display the 'close' tool button and allow the user to close the window, false to hide the button and disallow... */ - closable?: boolean; - /** [Config Option] (String) The action to take when the close header tool is clicked: 'destroy' : remove the window from the DOM and destroy i... */ - closeAction?: string; - /** [Config Option] (String) The direction to collapse the Panel when the toggle button is clicked. ... */ - collapseDirection?: string; - /** [Config Option] (Boolean) true to make sure the collapse/expand toggle button always renders first (to the left of) any other tools in the pane... */ - collapseFirst?: boolean; - /** [Config Option] (String) Important: this config is only effective for collapsible Panels which are direct child items of a border layout. ... */ - collapseMode?: string; - /** [Config Option] (Boolean) true to render the panel collapsed, false to render it expanded. ... */ - collapsed?: boolean; - /** [Config Option] (String) A CSS class to add to the panel's element after it has been collapsed. ... */ - collapsedCls?: string; - /** [Config Option] (Boolean) True to make the panel collapsible and have an expand/collapse toggle Tool added into the header tool button area. ... */ - collapsible?: boolean; - /** [Config Option] (Boolean) True to constrain the panel within its containing element, false to allow it to fall outside of its containing element. ... */ - constrain?: boolean; - /** [Config Option] (Boolean) True to constrain the panel header within its containing element (allowing the panel body to fall outside of its cont... */ - constrainHeader?: boolean; - /** [Config Option] (Object/Object[]) A component or series of components to be added as docked items to this panel. ... */ - dockedItems?: any; - /** [Config Option] (Object/Object[]) Convenience config used for adding items to the bottom of the panel. ... */ - fbar?: any; - /** [Config Option] (Boolean) Important: This config is only effective for collapsible Panels which are direct child items of a border layout. ... */ - floatable?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel. ... */ - frame?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel panels header (if 'frame' is true). ... */ - frameHeader?: boolean; - /** [Config Option] (Number/String) A numeric unicode character code to use as the icon for the panel header. ... */ - glyph?: any; - /** [Config Option] (Boolean/Object) Pass as false to prevent a Header from being created and shown. ... */ - header?: any; - /** [Config Option] (String) */ - headerOverCls?: string; - /** [Config Option] (String) Specify as 'top', 'bottom', 'left' or 'right'. ... */ - headerPosition?: string; - /** [Config Option] (Boolean) true to hide the expand/collapse toggle button when collapsible == true, false to display it. ... */ - hideCollapseTool?: boolean; - /** [Config Option] (String) Path to image for an icon in the header. ... */ - icon?: string; - /** [Config Option] (String) CSS class for an icon in the header. ... */ - iconCls?: string; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - lbar?: any; - /** [Config Option] (Boolean) When true, the dock component layout writes height information to the panel's DOM elements based on its shrink wrap h... */ - manageHeight?: boolean; - /** [Config Option] (Number) Minimum width of all footer toolbar buttons in pixels. ... */ - minButtonWidth?: number; - /** [Config Option] (Boolean) True to overlap the header in a panel over the framing of the panel itself. ... */ - overlapHeader?: boolean; - /** [Config Option] (Ext.Component/Object) Important: This config is only effective for collapsible Panels which are direct child items of a border layout when ... */ - placeholder?: any; - /** [Config Option] (Number) */ - placeholderCollapseHideMode?: number; - /** [Config Option] (Boolean) ... */ - preventHeader?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - rbar?: any; - /** [Config Option] (Boolean) When draggable is true, Specify this as true to cause the draggable config to work the same as it does in Window. ... */ - simpleDrag?: boolean; - /** [Config Option] (Object/Object[]) Convenience config. ... */ - tbar?: any; - /** [Config Option] (String) The title text to be used to display in the panel header. ... */ - title?: string; - /** [Config Option] (String) The alignment of the title text within the available space between the icon and the tools. ... */ - titleAlign?: string; - /** [Config Option] (Boolean) true to allow expanding and collapsing the panel (when collapsible = true) by clicking anywhere in the header bar, fa... */ - titleCollapse?: boolean; - /** [Config Option] (Object[]/Ext.panel.Tool[]) An array of Ext.panel.Tool configs/instances to be added to the header tool area. ... */ - tools?: any; - /** [Property] (Ext.dd.DragSource/Ext.util.ComponentDragger) Only present if this Panel has been configured with draggable true. ... */ - dd?: any; - /** [Method] Add tools to this panel - * @param tools any The tools to add - */ - addTool?( tools?:any ): void; - /** [Method] Template method to be implemented in subclasses to add their tools after the collapsible tool */ - addTools?(): void; - /** [Method] Invoked after the Panel is Collapsed - * @param animated Boolean - */ - afterCollapse?( animated?:boolean ): void; - /** [Method] Invoked after the Panel is Expanded - * @param animated Boolean - */ - afterExpand?( animated?:boolean ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Closes the Panel */ - close?(): void; - /** [Method] Collapses the panel body so that the body becomes hidden - * @param direction String The direction to collapse towards. Must be one of Ext.Component.DIRECTION_TOP Ext.Component.DIRECTION_RIGHT Ext.Component.DIRECTION_BOTTOM Ext.Component.DIRECTION_LEFT Defaults to collapseDirection. - * @param animate Boolean True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds. - */ - collapse?( direction?:string, animate?:boolean ): Ext.panel.IPanel; - /** [Method] converts a collapsdDir into an anchor argument for Element slideIn overridden in rtl mode to switch l and r - * @param collapseDir Object - */ - convertCollapseDir?( collapseDir?:any ): void; - /** [Method] Expands the panel body so that it becomes visible - * @param animate Boolean True to animate the transition, else false (defaults to the value of the animCollapse panel config). May also be specified as the animation duration in milliseconds. - */ - expand?( animate?:boolean ): Ext.panel.IPanel; - /** [Method] Returns the current collapsed state of the panel */ - getCollapsed?(): any; - /** [Method] Gets the Header for this panel */ - getHeader?(): void; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Determines whether this Component is the root of a layout */ - isLayoutRoot?(): void; - /** [Method] Returns true if this component is visible - * @param deep Boolean Pass true to interrogate the visibility status of all parent Containers to determine whether this Component is truly visible to the user. Generally, to determine whether a Component is hidden, the no argument form is needed. For example when creating dynamically laid out UIs in a hidden Container before showing them. - */ - isVisible?( deep?:boolean ): boolean; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Method to manage awareness of when components are removed from their respective Container firing a removed event - * @param destroying Boolean Will be passed as true if the Container performing the remove operation will delete this Component upon remove. - */ - onRemoved?( destroying?:boolean ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] - * @param border String The border, see border. If a falsey value is passed the border will be removed. - */ - setBorder?( border?:string ): void; - setBorder?( border?:number ): void; - /** [Method] Set the glyph for the panel s header - * @param newGlyph Number The new glyph This parameter expects a format consistent with that of glyph - */ - setGlyph?( newGlyph?:number ): void; - setGlyph?( newGlyph?:string ): void; - /** [Method] Set the icon for the panel s header - * @param newIcon String The new icon path - */ - setIcon?( newIcon?:string ): void; - /** [Method] Set the iconCls for the panel s header - * @param newIconCls String The new CSS class name - */ - setIconCls?( newIconCls?:string ): void; - /** [Method] Set a title for the panel s header - * @param newTitle String - */ - setTitle?( newTitle?:string ): void; - /** [Method] Sets the UI for the component - * @param ui String The new UI for the component. - */ - setUI?( ui?:string ): void; - /** [Method] Shortcut for performing an expand or collapse based on the current state of the panel */ - toggleCollapse?(): Ext.panel.IPanel; - } -} -declare module Ext.panel { - export interface IProxy extends Ext.IBase { - /** [Config Option] (Boolean) True to insert a placeholder proxy element while dragging the panel, false to drag with no proxy. ... */ - insertProxy?: boolean; - /** [Config Option] (Boolean) True to move the panel to the dragged position when dropped ... */ - moveOnDrag?: boolean; - /** [Property] (Ext.panel.Panel) */ - panel?: Ext.panel.IPanel; - /** [Method] Gets the proxy s element */ - getEl?(): Ext.IElement; - /** [Method] Gets the proxy s ghost Panel */ - getGhost?(): Ext.panel.IPanel; - /** [Method] Gets the proxy element */ - getProxy?(): Ext.IElement; - /** [Method] Hides the proxy */ - hide?(): void; - /** [Method] Moves the proxy to a different position in the DOM - * @param parentNode HTMLElement The proxy's parent DOM node - * @param before HTMLElement The sibling node before which the proxy should be inserted. Defaults to the parent's last child if not specified. - */ - moveProxy?( parentNode?:HTMLElement, before?:HTMLElement ): void; - /** [Method] Shows the proxy */ - show?(): void; - } -} -declare module Ext.dd { - export interface IPanelProxy extends Ext.IBase { - /** [Config Option] (Boolean) True to insert a placeholder proxy element while dragging the panel, false to drag with no proxy. ... */ - insertProxy?: boolean; - /** [Config Option] (Boolean) True to move the panel to the dragged position when dropped ... */ - moveOnDrag?: boolean; - /** [Property] (Ext.panel.Panel) */ - panel?: Ext.panel.IPanel; - /** [Method] Gets the proxy s element */ - getEl?(): Ext.IElement; - /** [Method] Gets the proxy s ghost Panel */ - getGhost?(): Ext.panel.IPanel; - /** [Method] Gets the proxy element */ - getProxy?(): Ext.IElement; - /** [Method] Hides the proxy */ - hide?(): void; - /** [Method] Moves the proxy to a different position in the DOM - * @param parentNode HTMLElement The proxy's parent DOM node - * @param before HTMLElement The sibling node before which the proxy should be inserted. Defaults to the parent's last child if not specified. - */ - moveProxy?( parentNode?:HTMLElement, before?:HTMLElement ): void; - /** [Method] Shows the proxy */ - show?(): void; - } -} -declare module Ext.panel { - export interface ITable extends Ext.panel.IPanel { - /** [Config Option] (Boolean) True to allow deselecting a record. ... */ - allowDeselect?: boolean; - /** [Config Option] (Boolean) */ - columnLines?: boolean; - /** [Config Option] (Ext.grid.column.Column[]/Object) An array of column definition objects which define all columns that appear in this grid. ... */ - columns?: any; - /** [Config Option] (Boolean) Defaults to true to enable deferred row rendering. ... */ - deferRowRender?: boolean; - /** [Config Option] (Boolean) True to disable selection model. ... */ - disableSelection?: boolean; - /** [Config Option] (String) Default text (html tags are accepted) to display in the Panel body when the Store is empty. ... */ - emptyText?: string; - /** [Config Option] (Boolean) False to disable column hiding within this grid. ... */ - enableColumnHide?: boolean; - /** [Config Option] (Boolean) False to disable column dragging within this grid. ... */ - enableColumnMove?: boolean; - /** [Config Option] (Boolean) False to disable column resizing within this grid. ... */ - enableColumnResize?: boolean; - /** [Config Option] (Boolean) Configure as true to enable locking support for this grid. ... */ - enableLocking?: boolean; - /** [Config Option] (Ext.grid.feature.Feature[]/Object[]/Ext.enums.Feature[]) An array of grid Features to be added to this grid. ... */ - features?: any; - /** [Config Option] (Boolean) True to force the columns to fit into the available width. ... */ - forceFit?: boolean; - /** [Config Option] (Boolean) True to hide column headers. ... */ - hideHeaders?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specifie... */ - layout?: any; - /** [Config Option] (Boolean) True to enable 'MULTI' selection mode on selection model. ... */ - multiSelect?: boolean; - /** [Config Option] (Boolean) Adds row line styling ... */ - rowLines?: boolean; - /** [Config Option] (String/Boolean) Scrollers configuration. ... */ - scroll?: any; - /** [Config Option] (Boolean) True to constrain column dragging so that a column cannot be dragged in or out of it's current group. ... */ - sealedColumns?: boolean; - /** [Config Option] (Ext.selection.Model/Object) A selection model instance or config object. ... */ - selModel?: any; - /** [Config Option] (String) An xtype of selection model to use. ... */ - selType?: string; - /** [Config Option] (Boolean) True to enable 'SIMPLE' selection mode on selection model. ... */ - simpleSelect?: boolean; - /** [Config Option] (Boolean) False to disable column sorting via clicking the header and via the Sorting menu items. ... */ - sortableColumns?: boolean; - /** [Config Option] (Ext.data.Store) */ - store?: Ext.data.IStore; - /** [Config Option] (Object) A config object to be used when configuring the scroll monitor to control refreshing of data in an "infinite grid". ... */ - verticalScroller?: any; - /** [Config Option] (Ext.view.Table) The Ext.view.Table used by the grid. ... */ - view?: Ext.view.ITable; - /** [Config Option] (Object) A config object that will be applied to the grid's UI view. ... */ - viewConfig?: any; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Property] (Boolean) True to indicate that a view has been injected into the panel. ... */ - hasView?: boolean; - /** [Property] (Boolean) If you are writing a grid plugin or a {Ext.grid.feature.Feature Feature} which creates a column-based structure which... */ - optimizedColumnMove?: boolean; - /** [Method] Invoked after the Panel is Collapsed - * @param animated Boolean - */ - afterCollapse?( animated?:boolean ): void; - /** [Method] Invoked after the Panel is Expanded - * @param animated Boolean - */ - afterExpand?( animated?:boolean ): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Returns the selection model being used and creates it via the configuration if it has not been created already */ - getSelectionModel?(): Ext.selection.IModel; - /** [Method] The supplied default state gathering method for the AbstractComponent class */ - getState?(): any; - /** [Method] Returns the store associated with this Panel */ - getStore?(): Ext.data.IStore; - /** [Method] Gets the view for this panel */ - getView?(): Ext.view.ITable; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - } -} -declare module Ext.panel { - export interface ITool extends Ext.IComponent { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String) CSS class to add when the Component is disabled. ... */ - disabledCls?: string; - /** [Config Option] (Function) A function to execute when the tool is clicked. ... */ - handler?: any; - /** [Config Option] (Number) Tool size is fixed so that Box layout can avoid measurements. ... */ - height?: number; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) The scope to execute the handler function. ... */ - scope?: any; - /** [Config Option] (Boolean) Specify as false to allow click event to propagate. ... */ - stopEvent?: boolean; - /** [Config Option] (String/Object) */ - tooltip?: any; - /** [Config Option] (String) The type of tooltip to use. ... */ - tooltipType?: string; - /** [Config Option] (String) The type of tool to render. ... */ - type?: string; - /** [Config Option] (Number) The width of this component in pixels. ... */ - width?: number; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Tool, or subclass thereof. ... */ - isTool?: boolean; - /** [Method] inherit docs Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] inherit docs Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Sets the type of the tool - * @param type String The new type. See the type config. - */ - setType?( type?:string ): Ext.panel.ITool; - } -} -declare module Ext.perf { - export interface IAccumulator extends Ext.IBase { - } -} -declare module Ext.perf { - export interface IMonitor extends Ext.IBase { - } - export class Monitor { - /** [Method] */ - constructor(); - } -} -declare module Ext { - export interface IPerf extends Ext.IBase { - } - export class Perf { - /** [Method] */ - constructor(); - } -} -declare module Ext.picker { - export interface IColor extends Ext.IComponent { - /** [Config Option] (Boolean) If set to true then reselecting a color that is already selected fires the select event ... */ - allowReselect?: boolean; - /** [Config Option] (String) The DOM event that will cause a color to be selected. ... */ - clickEvent?: string; - /** [Config Option] (String) The CSS class to apply to the containing element. ... */ - componentCls?: string; - /** [Config Option] (Function) A function that will handle the select event of this picker. ... */ - handler?: any; - /** [Config Option] (String) The CSS class to apply to the color picker's items ... */ - itemCls?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler function will be called. ... */ - scope?: any; - /** [Config Option] (String) The CSS class to apply to the selected element ... */ - selectedCls?: string; - /** [Config Option] (String) The initial color to highlight (should be a valid 6-digit color hex code without the # symbol). ... */ - value?: string; - /** [Property] (String[]) An array of 6-digit color hex code strings (without the # symbol). ... */ - colors?: string[]; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Get the currently selected color value */ - getValue?(): string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Selects the specified color in the picker fires the select event - * @param color String A valid 6-digit color hex code (# will be stripped if included) - * @param suppressEvent Boolean True to stop the select event from firing. - */ - select?( color?:string, suppressEvent?:boolean ): void; - } -} -declare module Ext { - export interface IColorPalette extends Ext.IComponent { - /** [Config Option] (Boolean) If set to true then reselecting a color that is already selected fires the select event ... */ - allowReselect?: boolean; - /** [Config Option] (String) The DOM event that will cause a color to be selected. ... */ - clickEvent?: string; - /** [Config Option] (String) The CSS class to apply to the containing element. ... */ - componentCls?: string; - /** [Config Option] (Function) A function that will handle the select event of this picker. ... */ - handler?: any; - /** [Config Option] (String) The CSS class to apply to the color picker's items ... */ - itemCls?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler function will be called. ... */ - scope?: any; - /** [Config Option] (String) The CSS class to apply to the selected element ... */ - selectedCls?: string; - /** [Config Option] (String) The initial color to highlight (should be a valid 6-digit color hex code without the # symbol). ... */ - value?: string; - /** [Property] (String[]) An array of 6-digit color hex code strings (without the # symbol). ... */ - colors?: string[]; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Get the currently selected color value */ - getValue?(): string; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Selects the specified color in the picker fires the select event - * @param color String A valid 6-digit color hex code (# will be stripped if included) - * @param suppressEvent Boolean True to stop the select event from firing. - */ - select?( color?:string, suppressEvent?:boolean ): void; - } -} -declare module Ext.picker { - export interface IDate extends Ext.IComponent { - /** [Config Option] (String) The text to display for the aria title ... */ - ariaTitle?: string; - /** [Config Option] (String) The date format to display for the current value in the ariaTitle ... */ - ariaTitleDateFormat?: string; - /** [Config Option] (String) The base CSS class to apply to this components element. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String[]) */ - dayNames?: string[]; - /** [Config Option] (Boolean) True to disable animations when showing the month picker. ... */ - disableAnim?: boolean; - /** [Config Option] (String) The class to apply to disabled cells. ... */ - disabledCellCls?: string; - /** [Config Option] (String[]) An array of 'dates' to disable, as strings. ... */ - disabledDates?: string[]; - /** [Config Option] (RegExp) JavaScript regular expression used to disable a pattern of dates. ... */ - disabledDatesRE?: RegExp; - /** [Config Option] (String) The tooltip text to display when the date falls on a disabled date. ... */ - disabledDatesText?: string; - /** [Config Option] (Number[]) An array of days to disable, 0-based. ... */ - disabledDays?: number[]; - /** [Config Option] (String) The tooltip to display when the date falls on a disabled day. ... */ - disabledDaysText?: string; - /** [Config Option] (Boolean) True to automatically focus the picker on show. ... */ - focusOnShow?: boolean; - /** [Config Option] (String) The default date format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Function) Optional. ... */ - handler?: any; - /** [Config Option] (Object) Specifies optional custom key event handlers for the Ext.util.KeyNav attached to this date picker. ... */ - keyNavConfig?: any; - /** [Config Option] (String) The format for displaying a date in a longer format. ... */ - longDayFormat?: string; - /** [Config Option] (Date) Maximum allowable date (JavaScript date object) ... */ - maxDate?: any; - /** [Config Option] (String) The error text to display if the maxDate validation fails. ... */ - maxText?: string; - /** [Config Option] (Date) Minimum allowable date (JavaScript date object) ... */ - minDate?: any; - /** [Config Option] (String) The error text to display if the minDate validation fails. ... */ - minText?: string; - /** [Config Option] (String[]) */ - monthNames?: string[]; - /** [Config Option] (String) The date format for the header month ... */ - monthYearFormat?: string; - /** [Config Option] (String) The header month selector tooltip ... */ - monthYearText?: string; - /** [Config Option] (String) The next month navigation button tooltip ... */ - nextText?: string; - /** [Config Option] (String) The previous month navigation button tooltip ... */ - prevText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler function will be called. ... */ - scope?: any; - /** [Config Option] (String) The class to apply to the selected cell. ... */ - selectedCls?: string; - /** [Config Option] (Boolean) False to hide the footer area containing the Today button and disable the keyboard handler for spacebar that selects ... */ - showToday?: boolean; - /** [Config Option] (Number) Day index at which the week should begin, 0-based. ... */ - startDay?: number; - /** [Config Option] (String) The text to display on the button that selects the current date ... */ - todayText?: string; - /** [Config Option] (String) A string used to format the message for displaying in a tooltip over the button that selects the current date. ... */ - todayTip?: string; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets a single character to represent the day of the week - * @param value Object - */ - getDayInitial?( value?:any ): string; - /** [Method] Gets the current selected value of the date field */ - getValue?(): any; - /** [Method] Hides the month picker if it s visible - * @param animate Boolean Indicates whether to animate this action. If the animate parameter is not specified, the behavior will use disableAnim to determine whether to animate or not. - */ - hideMonthPicker?( animate?:boolean ): Ext.picker.IDate; - /** [Method] private inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Sets the current value to today */ - selectToday?(): Ext.picker.IDate; - /** [Method] Replaces any existing disabled dates with new values and refreshes the DatePicker - * @param disabledDates any An array of date strings (see the disabledDates config for details on supported values), or a JavaScript regular expression used to disable a pattern of dates. - */ - setDisabledDates?( disabledDates?:any ): any; - setDisabledDates?( disabledDates?:string[] ): Ext.picker.IDate; - setDisabledDates?( disabledDates?:RegExp ): Ext.picker.IDate; - /** [Method] Replaces any existing disabled days by index 0 6 with new values and refreshes the DatePicker - * @param disabledDays Number[] An array of disabled day indexes. See the disabledDays config for details on supported values. - */ - setDisabledDays?( disabledDays?:number[] ): Ext.picker.IDate; - /** [Method] Replaces any existing maxDate with the new value and refreshes the DatePicker - * @param value Date The maximum date that can be selected - */ - setMaxDate?( value?:any ): Ext.picker.IDate; - /** [Method] Replaces any existing minDate with the new value and refreshes the DatePicker - * @param value Date The minimum date that can be selected - */ - setMinDate?( value?:any ): Ext.picker.IDate; - /** [Method] Sets the value of the date field - * @param value Date The date to set - */ - setValue?( value?:any ): Ext.picker.IDate; - /** [Method] Show the month picker - * @param animate Boolean Indicates whether to animate this action. If the animate parameter is not specified, the behavior will use disableAnim to determine whether to animate or not. - */ - showMonthPicker?( animate?:boolean ): Ext.picker.IDate; - /** [Method] Show the next month - * @param e Object - */ - showNextMonth?( e?:any ): Ext.picker.IDate; - /** [Method] Show the next year */ - showNextYear?(): Ext.picker.IDate; - /** [Method] Show the previous month - * @param e Object - */ - showPrevMonth?( e?:any ): Ext.picker.IDate; - /** [Method] Show the previous year */ - showPrevYear?(): Ext.picker.IDate; - } -} -declare module Ext { - export interface IDatePicker extends Ext.IComponent { - /** [Config Option] (String) The text to display for the aria title ... */ - ariaTitle?: string; - /** [Config Option] (String) The date format to display for the current value in the ariaTitle ... */ - ariaTitleDateFormat?: string; - /** [Config Option] (String) The base CSS class to apply to this components element. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Specifies the border size for this component. ... */ - border?: any; - /** [Config Option] (String[]) */ - dayNames?: string[]; - /** [Config Option] (Boolean) True to disable animations when showing the month picker. ... */ - disableAnim?: boolean; - /** [Config Option] (String) The class to apply to disabled cells. ... */ - disabledCellCls?: string; - /** [Config Option] (String[]) An array of 'dates' to disable, as strings. ... */ - disabledDates?: string[]; - /** [Config Option] (RegExp) JavaScript regular expression used to disable a pattern of dates. ... */ - disabledDatesRE?: RegExp; - /** [Config Option] (String) The tooltip text to display when the date falls on a disabled date. ... */ - disabledDatesText?: string; - /** [Config Option] (Number[]) An array of days to disable, 0-based. ... */ - disabledDays?: number[]; - /** [Config Option] (String) The tooltip to display when the date falls on a disabled day. ... */ - disabledDaysText?: string; - /** [Config Option] (Boolean) True to automatically focus the picker on show. ... */ - focusOnShow?: boolean; - /** [Config Option] (String) The default date format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Function) Optional. ... */ - handler?: any; - /** [Config Option] (Object) Specifies optional custom key event handlers for the Ext.util.KeyNav attached to this date picker. ... */ - keyNavConfig?: any; - /** [Config Option] (String) The format for displaying a date in a longer format. ... */ - longDayFormat?: string; - /** [Config Option] (Date) Maximum allowable date (JavaScript date object) ... */ - maxDate?: any; - /** [Config Option] (String) The error text to display if the maxDate validation fails. ... */ - maxText?: string; - /** [Config Option] (Date) Minimum allowable date (JavaScript date object) ... */ - minDate?: any; - /** [Config Option] (String) The error text to display if the minDate validation fails. ... */ - minText?: string; - /** [Config Option] (String[]) */ - monthNames?: string[]; - /** [Config Option] (String) The date format for the header month ... */ - monthYearFormat?: string; - /** [Config Option] (String) The header month selector tooltip ... */ - monthYearText?: string; - /** [Config Option] (String) The next month navigation button tooltip ... */ - nextText?: string; - /** [Config Option] (String) The previous month navigation button tooltip ... */ - prevText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Object) The scope (this reference) in which the handler function will be called. ... */ - scope?: any; - /** [Config Option] (String) The class to apply to the selected cell. ... */ - selectedCls?: string; - /** [Config Option] (Boolean) False to hide the footer area containing the Today button and disable the keyboard handler for spacebar that selects ... */ - showToday?: boolean; - /** [Config Option] (Number) Day index at which the week should begin, 0-based. ... */ - startDay?: number; - /** [Config Option] (String) The text to display on the button that selects the current date ... */ - todayText?: string; - /** [Config Option] (String) A string used to format the message for displaying in a tooltip over the button that selects the current date. ... */ - todayTip?: string; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets a single character to represent the day of the week - * @param value Object - */ - getDayInitial?( value?:any ): string; - /** [Method] Gets the current selected value of the date field */ - getValue?(): any; - /** [Method] Hides the month picker if it s visible - * @param animate Boolean Indicates whether to animate this action. If the animate parameter is not specified, the behavior will use disableAnim to determine whether to animate or not. - */ - hideMonthPicker?( animate?:boolean ): Ext.picker.IDate; - /** [Method] private inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialize any events on this component */ - initEvents?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Allows addition of behavior to the enable operation */ - onEnable?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Sets the current value to today */ - selectToday?(): Ext.picker.IDate; - /** [Method] Replaces any existing disabled dates with new values and refreshes the DatePicker - * @param disabledDates any An array of date strings (see the disabledDates config for details on supported values), or a JavaScript regular expression used to disable a pattern of dates. - */ - setDisabledDates?( disabledDates?:any ): any; - setDisabledDates?( disabledDates?:string[] ): Ext.picker.IDate; - setDisabledDates?( disabledDates?:RegExp ): Ext.picker.IDate; - /** [Method] Replaces any existing disabled days by index 0 6 with new values and refreshes the DatePicker - * @param disabledDays Number[] An array of disabled day indexes. See the disabledDays config for details on supported values. - */ - setDisabledDays?( disabledDays?:number[] ): Ext.picker.IDate; - /** [Method] Replaces any existing maxDate with the new value and refreshes the DatePicker - * @param value Date The maximum date that can be selected - */ - setMaxDate?( value?:any ): Ext.picker.IDate; - /** [Method] Replaces any existing minDate with the new value and refreshes the DatePicker - * @param value Date The minimum date that can be selected - */ - setMinDate?( value?:any ): Ext.picker.IDate; - /** [Method] Sets the value of the date field - * @param value Date The date to set - */ - setValue?( value?:any ): Ext.picker.IDate; - /** [Method] Show the month picker - * @param animate Boolean Indicates whether to animate this action. If the animate parameter is not specified, the behavior will use disableAnim to determine whether to animate or not. - */ - showMonthPicker?( animate?:boolean ): Ext.picker.IDate; - /** [Method] Show the next month - * @param e Object - */ - showNextMonth?( e?:any ): Ext.picker.IDate; - /** [Method] Show the next year */ - showNextYear?(): Ext.picker.IDate; - /** [Method] Show the previous month - * @param e Object - */ - showPrevMonth?( e?:any ): Ext.picker.IDate; - /** [Method] Show the previous year */ - showPrevYear?(): Ext.picker.IDate; - } -} -declare module Ext.picker { - export interface IMonth extends Ext.IComponent { - /** [Config Option] (String) The base CSS class to apply to the picker element. ... */ - baseCls?: string; - /** [Config Option] (String) The text to display on the cancel button. ... */ - cancelText?: string; - /** [Config Option] (String) The text to display on the ok button. ... */ - okText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) The class to be added to selected items in the picker. ... */ - selectedCls?: string; - /** [Config Option] (Boolean) True to show ok and cancel buttons below the picker. ... */ - showButtons?: boolean; - /** [Config Option] (Date/Number[]) The default value to set. ... */ - value?: any; - /** [Method] Modify the year display by passing an offset - * @param offset Number The offset to move by. - */ - adjustYear?( offset?:number ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets the selected value */ - getValue?(): number[]; - /** [Method] Checks whether the picker has a selection */ - hasSelection?(): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Set the value for the picker - * @param value any The value to set. It can be a Date object, where the month/year will be extracted, or it can be an array, with the month as the first index and the year as the second. - */ - setValue?( value?:any ): any; - setValue?( value?:number[] ): Ext.picker.IMonth; - } -} -declare module Ext { - export interface IMonthPicker extends Ext.IComponent { - /** [Config Option] (String) The base CSS class to apply to the picker element. ... */ - baseCls?: string; - /** [Config Option] (String) The text to display on the cancel button. ... */ - cancelText?: string; - /** [Config Option] (String) The text to display on the ok button. ... */ - okText?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) The class to be added to selected items in the picker. ... */ - selectedCls?: string; - /** [Config Option] (Boolean) True to show ok and cancel buttons below the picker. ... */ - showButtons?: boolean; - /** [Config Option] (Date/Number[]) The default value to set. ... */ - value?: any; - /** [Method] Modify the year display by passing an offset - * @param offset Number The offset to move by. - */ - adjustYear?( offset?:number ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Gets the selected value */ - getValue?(): number[]; - /** [Method] Checks whether the picker has a selection */ - hasSelection?(): boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Set the value for the picker - * @param value any The value to set. It can be a Date object, where the month/year will be extracted, or it can be an array, with the month as the first index and the year as the second. - */ - setValue?( value?:any ): any; - setValue?( value?:number[] ): Ext.picker.IMonth; - } -} -declare module Ext.picker { - export interface ITime extends Ext.view.IBoundList { - /** [Config Option] (String) CSS Class to be added to a components root level element to give distinction to it via styling. ... */ - componentCls?: string; - /** [Config Option] (String) The default time format string which can be overriden for localization support. ... */ - format?: string; - /** [Config Option] (Number) The number of minutes between each time value in the list. ... */ - increment?: number; - /** [Config Option] (Date) The maximum time to be shown in the list of times. ... */ - maxValue?: any; - /** [Config Option] (Date) The minimum time to be shown in the list of times. ... */ - minValue?: any; - /** [Method] Focuses a node in the view - * @param rec Ext.data.IModel The record associated to the node that is to be focused. - */ - focusNode?( rec?:Ext.data.IModel ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Set the maxValue and update the list of available times - * @param value Date - */ - setMaxValue?( value?:any ): void; - /** [Method] Set the minValue and update the list of available times - * @param value Date - */ - setMinValue?( value?:any ): void; - /** [Method] Update the list of available times in the list to be constrained within the minValue and maxValue */ - updateList?(): void; - } -} -declare module Ext { - export interface IPluginManager extends Ext.IAbstractManager { - } - export class PluginManager { - /** [Method] Creates a new Plugin from the specified config object using the config object s ptype to determine the class to insta - * @param config Object A configuration object for the Plugin you wish to create. - * @param defaultType Function The constructor to provide the default Plugin type if the config object does not contain a ptype. (Optional if the config contains a ptype). - */ - static create( config?:any, defaultType?:any ): Ext.IComponent; - /** [Method] Returns all plugins registered with the given type - * @param type String The type to search for - * @param defaultsOnly Boolean True to only return plugins of this type where the plugin's isDefault property is truthy - */ - static findByType( type?:string, defaultsOnly?:boolean ): Ext.IAbstractPlugin[]; - } -} -declare module Ext { - export interface IPluginMgr extends Ext.IAbstractManager { - } - export class PluginMgr { - /** [Method] Creates a new Plugin from the specified config object using the config object s ptype to determine the class to insta - * @param config Object A configuration object for the Plugin you wish to create. - * @param defaultType Function The constructor to provide the default Plugin type if the config object does not contain a ptype. (Optional if the config contains a ptype). - */ - static create( config?:any, defaultType?:any ): Ext.IComponent; - /** [Method] Returns all plugins registered with the given type - * @param type String The type to search for - * @param defaultsOnly Boolean True to only return plugins of this type where the plugin's isDefault property is truthy - */ - static findByType( type?:string, defaultsOnly?:boolean ): Ext.IAbstractPlugin[]; - } -} -declare module Ext { - export interface IProgressBar extends Ext.IComponent { - /** [Config Option] (Boolean/Object) True to animate the progress bar during transitions, or an animation configuration (see the animate method for details). ... */ - animate?: any; - /** [Config Option] (String) The base CSS class to apply to the progress bar's wrapper element. ... */ - baseCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (String) */ - id?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) The text shown in the progress bar. ... */ - text?: string; - /** [Config Option] (String/HTMLElement/Ext.Element) */ - textEl?: any; - /** [Config Option] (Number) A floating point value between 0 and 1 (e.g., .5) ... */ - value?: number; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Returns true if the progress bar is currently in a wait operation */ - isWaiting?(): boolean; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Resets the progress bar value to 0 and text to empty string - * @param hide Boolean True to hide the progress bar. - */ - reset?( hide?:boolean ): Ext.IProgressBar; - /** [Method] Updates the progress bar value and optionally its text - * @param value Number A floating point value between 0 and 1 (e.g., .5) - * @param text String The string to display in the progress text element - * @param animate Boolean Whether to animate the transition of the progress bar. If this value is not specified, the default for the class is used - */ - updateProgress?( value?:number, text?:string, animate?:boolean ): Ext.IProgressBar; - /** [Method] Updates the progress bar text - * @param text String The string to display in the progress text element - */ - updateText?( text?:string ): Ext.IProgressBar; - /** [Method] Initiates an auto updating progress bar - * @param config Object Configuration options - */ - wait?( config?:any ): Ext.IProgressBar; - } -} -declare module Ext.resizer { - export interface IBorderSplitter extends Ext.resizer.ISplitter { - /** [Config Option] (String/Ext.panel.Panel) must be configured in by the border layout: A string describing the relative position of the immediate sibling Panel... */ - collapseTarget?: any; - /** [Method] Returns the config object with an xclass property for the splitter tracker */ - getTrackerConfig?(): void; - } -} -declare module Ext.resizer { - export interface IBorderSplitterTracker extends Ext.resizer.ISplitterTracker { - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onBeforeStart?( e?:Ext.IEventObject ): void; - } -} -declare module Ext.resizer { - export interface IHandle extends Ext.IComponent { - /** [Config Option] ("north"/"south"/"east"/"west"/"center") Ext.resizer.Resizer.prototype.possiblePositions define the regions which will be passed in as a region configuration. ... */ - region?: any; - } -} -declare module Ext.resizer { - export interface IResizer extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Ext.Element/Ext.util.Region) */ - constrainTo?: any; - /** [Config Option] (Boolean) Specify as true to update the target (Element or Component) dynamically during dragging. ... */ - dynamic?: boolean; - /** [Config Option] (String) String consisting of the resize handles to display. ... */ - handles?: string; - /** [Config Option] (Number) Optional. ... */ - height?: number; - /** [Config Option] (Number) The increment to snap the height resize in pixels. ... */ - heightIncrement?: number; - /** [Config Option] (Number) The maximum height for the element ... */ - maxHeight?: number; - /** [Config Option] (Number) The maximum width for the element ... */ - maxWidth?: number; - /** [Config Option] (Number) The minimum height for the element ... */ - minHeight?: number; - /** [Config Option] (Number) The minimum width for the element ... */ - minWidth?: number; - /** [Config Option] (Boolean) True to ensure that the resize handles are always visible, false indicates resizing by cursor changes only ... */ - pinned?: boolean; - /** [Config Option] (Boolean) True to preserve the original ratio between height and width during resize ... */ - preserveRatio?: boolean; - /** [Config Option] (Ext.Element/Ext.Component) */ - target?: any; - /** [Config Option] (Boolean) True for transparent handles. ... */ - transparent?: boolean; - /** [Config Option] (Number) Optional. ... */ - width?: number; - /** [Config Option] (Number) The increment to snap the width resize in pixels. ... */ - widthIncrement?: number; - /** [Property] (Ext.Element) */ - el?: Ext.IElement; - /** [Property] (Ext.Element/Ext.Component) Reference to the original resize target if the element of the original resize target was a Field, or an IMG or a TEXT... */ - originalTarget?: any; - /** [Property] (Ext.resizer.ResizeTracker) */ - resizeTracker?: Ext.resizer.IResizeTracker; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the element that was configured with the el or target config property */ - getEl?(): Ext.IElement; - /** [Method] Returns the element or component that was configured with the target config property */ - getTarget?(): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Perform a manual resize and fires the resize event - * @param width Number - * @param height Number - */ - resizeTo?( width?:number, height?:number ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IResizable extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Ext.Element/Ext.util.Region) */ - constrainTo?: any; - /** [Config Option] (Boolean) Specify as true to update the target (Element or Component) dynamically during dragging. ... */ - dynamic?: boolean; - /** [Config Option] (String) String consisting of the resize handles to display. ... */ - handles?: string; - /** [Config Option] (Number) Optional. ... */ - height?: number; - /** [Config Option] (Number) The increment to snap the height resize in pixels. ... */ - heightIncrement?: number; - /** [Config Option] (Number) The maximum height for the element ... */ - maxHeight?: number; - /** [Config Option] (Number) The maximum width for the element ... */ - maxWidth?: number; - /** [Config Option] (Number) The minimum height for the element ... */ - minHeight?: number; - /** [Config Option] (Number) The minimum width for the element ... */ - minWidth?: number; - /** [Config Option] (Boolean) True to ensure that the resize handles are always visible, false indicates resizing by cursor changes only ... */ - pinned?: boolean; - /** [Config Option] (Boolean) True to preserve the original ratio between height and width during resize ... */ - preserveRatio?: boolean; - /** [Config Option] (Ext.Element/Ext.Component) */ - target?: any; - /** [Config Option] (Boolean) True for transparent handles. ... */ - transparent?: boolean; - /** [Config Option] (Number) Optional. ... */ - width?: number; - /** [Config Option] (Number) The increment to snap the width resize in pixels. ... */ - widthIncrement?: number; - /** [Property] (Ext.Element) */ - el?: Ext.IElement; - /** [Property] (Ext.Element/Ext.Component) Reference to the original resize target if the element of the original resize target was a Field, or an IMG or a TEXT... */ - originalTarget?: any; - /** [Property] (Ext.resizer.ResizeTracker) */ - resizeTracker?: Ext.resizer.IResizeTracker; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the element that was configured with the el or target config property */ - getEl?(): Ext.IElement; - /** [Method] Returns the element or component that was configured with the target config property */ - getTarget?(): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Perform a manual resize and fires the resize event - * @param width Number - * @param height Number - */ - resizeTo?( width?:number, height?:number ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.resizer { - export interface IResizeTracker extends Ext.dd.IDragTracker { - /** [Config Option] (Ext.util.Region/Ext.Element) Default to no constraint A Region (Or an element from which a Region measurement will be read) which is used to cons... */ - constrainTo?: any; - /** [Method] Create a proxy for this resizer - * @param target any The target - */ - createProxy?( target?:any ): any; - createProxy?( target?:Ext.IComponent ): Ext.IElement; - createProxy?( target?:Ext.IElement ): Ext.IElement; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onBeforeStart?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onDrag?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onEnd?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onStart?( e?:Ext.IEventObject ): void; - } -} -declare module Ext.resizer { - export interface ISplitter extends Ext.IComponent { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to enable dblclick to toggle expand and collapse on the collapseTarget Panel. ... */ - collapseOnDblClick?: boolean; - /** [Config Option] (String/Ext.panel.Panel) A string describing the relative position of the immediate sibling Panel to collapse. ... */ - collapseTarget?: any; - /** [Config Option] (String) A class to add to the splitter when it is collapsed. ... */ - collapsedCls?: string; - /** [Config Option] (Boolean) True to show a mini-collapse tool in the Splitter to toggle expand and collapse on the collapseTarget Panel. ... */ - collapsible?: boolean; - /** [Config Option] (Number) Provides a default maximum width or height for the two components that the splitter is between. ... */ - defaultSplitMax?: number; - /** [Config Option] (Number) Provides a default minimum width or height for the two components that the splitter is between. ... */ - defaultSplitMin?: number; - /** [Config Option] (Boolean) */ - performCollapse?: boolean; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (Number) The size of the splitter. ... */ - size?: number; - /** [Property] (String) Orientation of this Splitter. ... */ - orientation?: string; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Returns the config object with an xclass property for the splitter tracker */ - getTrackerConfig?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Work around IE bug - * @param width any The new width to set. This may be one of: A Number specifying the new width in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS width style. A size object in the format {width: widthValue, height: heightValue}. undefined to leave the width unchanged. - * @param height any The new height to set (not required if a size object is passed as the first arg). This may be one of: A Number specifying the new height in the Element's Ext.Element.defaultUnits (by default, pixels). A String used to set the CSS height style. Animation may not be used. undefined to leave the height unchanged. - */ - setSize?( width?:any, height?:any ): any; - setSize?( width?:any, height?:number ): Ext.IComponent; - setSize?( width?:any, height?:string ): Ext.IComponent; - } -} -declare module Ext.resizer { - export interface ISplitterTracker extends Ext.dd.IDragTracker { - /** [Method] ensure the tracker is enabled store boxes of previous and next components and calculate the constrain region Templa - * @param e Ext.IEventObject The event object - */ - onBeforeStart?( e?:Ext.IEventObject ): void; - /** [Method] Track the proxy and set the proper XY coordinates while constraining the drag Template method which should be overri - * @param e Ext.IEventObject The event object - */ - onDrag?( e?:Ext.IEventObject ): void; - /** [Method] perform the resize and remove the proxy class from the splitter el Template method which should be overridden by eac - * @param e Ext.IEventObject The event object - */ - onEnd?( e?:Ext.IEventObject ): void; - /** [Method] We move the splitter el - * @param e Ext.IEventObject The event object - */ - onStart?( e?:Ext.IEventObject ): void; - } -} -declare module Ext.selection { - export interface ICellModel extends Ext.selection.IModel { - /** [Config Option] (Boolean) Turns on/off keyboard navigation within the grid. ... */ - enableKeyNav?: boolean; - /** [Config Option] ("SINGLE") Mode of selection. ... */ - mode?: string; - /** [Config Option] (Boolean) Set this configuration to true to prevent wrapping around of selection as a user navigates to the first or last column. ... */ - preventWrap?: boolean; - /** [Method] Returns the current position in the format row row column column */ - getCurrentPosition?(): void; - /** [Method] Sets the current position - * @param position Object The position to set. - */ - setCurrentPosition?( position?:any ): void; - } -} -declare module Ext.selection { - export interface ICheckboxModel extends Ext.selection.IRowModel { - /** [Config Option] (Boolean) True if rows can only be selected by clicking on the checkbox column. ... */ - checkOnly?: boolean; - /** [Config Option] (String) The selector for determining whether the checkbox element is clicked. ... */ - checkSelector?: string; - /** [Config Option] (Number/String) The index at which to insert the checkbox column. ... */ - injectCheckbox?: any; - /** [Config Option] ("SINGLE"/"SIMPLE"/"MULTI") Modes of selection. ... */ - mode?: any; - /** [Config Option] (Boolean) Configure as false to not display the header checkbox at the top of the column. ... */ - showHeaderCheckbox?: boolean; - /** [Method] Retrieve a configuration to be used in a HeaderContainer */ - getHeaderConfig?(): void; - /** [Method] Toggle between selecting all and deselecting all when clicking on a checkbox header - * @param headerCt Object - * @param header Object - * @param e Object - */ - onHeaderClick?( headerCt?:any, header?:any, e?:any ): void; - /** [Method] Generates the HTML to be rendered in the injected checkbox column for each row - * @param value Object - * @param metaData Object - * @param record Object - * @param rowIndex Object - * @param colIndex Object - * @param store Object - * @param view Object - */ - renderer?( value?:any, metaData?:any, record?:any, rowIndex?:any, colIndex?:any, store?:any, view?:any ): void; - } -} -declare module Ext.selection { - export interface IDataViewModel extends Ext.selection.IModel { - /** [Config Option] (Boolean) Turns on/off keyboard navigation within the DataView. ... */ - enableKeyNav?: boolean; - } -} -declare module Ext.selection { - export interface IModel extends Ext.util.IObservable,Ext.util.IBindable { - /** [Config Option] (Boolean) Allow users to deselect a record in a DataView, List or Grid. ... */ - allowDeselect?: boolean; - /** [Config Option] ("SINGLE"/"SIMPLE"/"MULTI") Mode of selection. ... */ - mode?: any; - /** [Config Option] (Boolean) Remove records from the selection when they are removed from the store. ... */ - pruneRemoved?: boolean; - /** [Property] (Ext.util.MixedCollection) A MixedCollection that maintains all of the currently selected records. ... */ - selected?: Ext.util.IMixedCollection; - /** [Method] binds the store to the selModel - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Deselects a record instance by record instance or index - * @param records Ext.data.IModel[] An array of records or an index - * @param suppressEvent Boolean True to not fire a deselect event - */ - deselect?( records?:Ext.data.IModel[], suppressEvent?:boolean ): void; - deselect?( records?:number, suppressEvent?:boolean ): void; - /** [Method] Deselects all records in the view - * @param suppressEvent Boolean True to suppress any deselect events - */ - deselectAll?( suppressEvent?:boolean ): void; - /** [Method] Deselects a range of rows if the selection model is not locked - * @param startRow Ext.data.IModel The record or index of the first row in the range - * @param endRow Ext.data.IModel The record or index of the last row in the range - */ - deselectRange?( startRow?:Ext.data.IModel, endRow?:Ext.data.IModel ): void; - deselectRange?( startRow?:number, endRow?:Ext.data.IModel ): void; - deselectRange?( startRow?:Ext.data.IModel, endRow?:number ): void; - deselectRange?( startRow?:number, endRow?:number ): void; - /** [Method] Returns the count of selected records */ - getCount?(): number; - /** [Method] */ - getLastSelected?(): Ext.data.IModel; - /** [Method] Returns an array of the currently selected records */ - getSelection?(): Ext.data.IModel[]; - /** [Method] Returns the current selectionMode */ - getSelectionMode?(): string; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Returns true if there are any a selected records */ - hasSelection?(): boolean; - /** [Method] Determines if this record is currently focused - * @param record Ext.data.IModel - */ - isFocused?( record?:Ext.data.IModel ): void; - /** [Method] Returns true if the selections are locked */ - isLocked?(): boolean; - /** [Method] Returns true if the specified row is selected - * @param from any The start of the range to check. - * @param to any The end of the range to check. - */ - isRangeSelected?( from?:any, to?:any ): any; - isRangeSelected?( from?:Ext.data.IModel, to?:Ext.data.IModel ): boolean; - isRangeSelected?( from?:number, to?:Ext.data.IModel ): boolean; - isRangeSelected?( from?:Ext.data.IModel, to?:number ): boolean; - isRangeSelected?( from?:number, to?:number ): boolean; - /** [Method] Returns true if the specified row is selected - * @param record any The record or index of the record to check - */ - isSelected?( record?:any ): any; - isSelected?( record?:Ext.data.IModel ): boolean; - isSelected?( record?:number ): boolean; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Selects a record instance by record instance or index - * @param records Ext.data.IModel[] An array of records or an index - * @param keepExisting Boolean True to retain existing selections - * @param suppressEvent Boolean True to not fire a select event - */ - select?( records?:Ext.data.IModel[], keepExisting?:boolean, suppressEvent?:boolean ): void; - select?( records?:number, keepExisting?:boolean, suppressEvent?:boolean ): void; - /** [Method] Selects all records in the view - * @param suppressEvent Boolean True to suppress any select events - */ - selectAll?( suppressEvent?:boolean ): void; - /** [Method] Selects a range of rows if the selection model is not locked - * @param startRow Ext.data.IModel The record or index of the first row in the range - * @param endRow Ext.data.IModel The record or index of the last row in the range - * @param keepExisting Boolean True to retain existing selections - */ - selectRange?( startRow?:Ext.data.IModel, endRow?:Ext.data.IModel, keepExisting?:boolean ): void; - selectRange?( startRow?:number, endRow?:Ext.data.IModel, keepExisting?:boolean ): void; - selectRange?( startRow?:Ext.data.IModel, endRow?:number, keepExisting?:boolean ): void; - selectRange?( startRow?:number, endRow?:number, keepExisting?:boolean ): void; - /** [Method] Sets a record as the last focused record - * @param record Ext.data.IModel - */ - setLastFocused?( record?:Ext.data.IModel ): void; - /** [Method] Locks the current selection and disables any changes from happening to the selection - * @param locked Boolean True to lock, false to unlock. - */ - setLocked?( locked?:boolean ): void; - /** [Method] Sets the current selectionMode - * @param selMode String 'SINGLE', 'MULTI' or 'SIMPLE'. - */ - setSelectionMode?( selMode?:string ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext { - export interface IAbstractSelectionModel extends Ext.util.IObservable,Ext.util.IBindable { - /** [Config Option] (Boolean) Allow users to deselect a record in a DataView, List or Grid. ... */ - allowDeselect?: boolean; - /** [Config Option] ("SINGLE"/"SIMPLE"/"MULTI") Mode of selection. ... */ - mode?: any; - /** [Config Option] (Boolean) Remove records from the selection when they are removed from the store. ... */ - pruneRemoved?: boolean; - /** [Property] (Ext.util.MixedCollection) A MixedCollection that maintains all of the currently selected records. ... */ - selected?: Ext.util.IMixedCollection; - /** [Method] binds the store to the selModel - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Deselects a record instance by record instance or index - * @param records Ext.data.IModel[] An array of records or an index - * @param suppressEvent Boolean True to not fire a deselect event - */ - deselect?( records?:Ext.data.IModel[], suppressEvent?:boolean ): void; - deselect?( records?:number, suppressEvent?:boolean ): void; - /** [Method] Deselects all records in the view - * @param suppressEvent Boolean True to suppress any deselect events - */ - deselectAll?( suppressEvent?:boolean ): void; - /** [Method] Deselects a range of rows if the selection model is not locked - * @param startRow Ext.data.IModel The record or index of the first row in the range - * @param endRow Ext.data.IModel The record or index of the last row in the range - */ - deselectRange?( startRow?:Ext.data.IModel, endRow?:Ext.data.IModel ): void; - deselectRange?( startRow?:number, endRow?:Ext.data.IModel ): void; - deselectRange?( startRow?:Ext.data.IModel, endRow?:number ): void; - deselectRange?( startRow?:number, endRow?:number ): void; - /** [Method] Returns the count of selected records */ - getCount?(): number; - /** [Method] */ - getLastSelected?(): Ext.data.IModel; - /** [Method] Returns an array of the currently selected records */ - getSelection?(): Ext.data.IModel[]; - /** [Method] Returns the current selectionMode */ - getSelectionMode?(): string; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Returns true if there are any a selected records */ - hasSelection?(): boolean; - /** [Method] Determines if this record is currently focused - * @param record Ext.data.IModel - */ - isFocused?( record?:Ext.data.IModel ): void; - /** [Method] Returns true if the selections are locked */ - isLocked?(): boolean; - /** [Method] Returns true if the specified row is selected - * @param from any The start of the range to check. - * @param to any The end of the range to check. - */ - isRangeSelected?( from?:any, to?:any ): any; - isRangeSelected?( from?:Ext.data.IModel, to?:Ext.data.IModel ): boolean; - isRangeSelected?( from?:number, to?:Ext.data.IModel ): boolean; - isRangeSelected?( from?:Ext.data.IModel, to?:number ): boolean; - isRangeSelected?( from?:number, to?:number ): boolean; - /** [Method] Returns true if the specified row is selected - * @param record any The record or index of the record to check - */ - isSelected?( record?:any ): any; - isSelected?( record?:Ext.data.IModel ): boolean; - isSelected?( record?:number ): boolean; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Selects a record instance by record instance or index - * @param records Ext.data.IModel[] An array of records or an index - * @param keepExisting Boolean True to retain existing selections - * @param suppressEvent Boolean True to not fire a select event - */ - select?( records?:Ext.data.IModel[], keepExisting?:boolean, suppressEvent?:boolean ): void; - select?( records?:number, keepExisting?:boolean, suppressEvent?:boolean ): void; - /** [Method] Selects all records in the view - * @param suppressEvent Boolean True to suppress any select events - */ - selectAll?( suppressEvent?:boolean ): void; - /** [Method] Selects a range of rows if the selection model is not locked - * @param startRow Ext.data.IModel The record or index of the first row in the range - * @param endRow Ext.data.IModel The record or index of the last row in the range - * @param keepExisting Boolean True to retain existing selections - */ - selectRange?( startRow?:Ext.data.IModel, endRow?:Ext.data.IModel, keepExisting?:boolean ): void; - selectRange?( startRow?:number, endRow?:Ext.data.IModel, keepExisting?:boolean ): void; - selectRange?( startRow?:Ext.data.IModel, endRow?:number, keepExisting?:boolean ): void; - selectRange?( startRow?:number, endRow?:number, keepExisting?:boolean ): void; - /** [Method] Sets a record as the last focused record - * @param record Ext.data.IModel - */ - setLastFocused?( record?:Ext.data.IModel ): void; - /** [Method] Locks the current selection and disables any changes from happening to the selection - * @param locked Boolean True to lock, false to unlock. - */ - setLocked?( locked?:boolean ): void; - /** [Method] Sets the current selectionMode - * @param selMode String 'SINGLE', 'MULTI' or 'SIMPLE'. - */ - setSelectionMode?( selMode?:string ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.selection { - export interface IRowModel extends Ext.selection.IModel { - /** [Config Option] (Boolean) Turns on/off keyboard navigation within the grid. ... */ - enableKeyNav?: boolean; - /** [Config Option] (Boolean) True to ignore selections that are made when using the right mouse button if there are records that are already selec... */ - ignoreRightMouseSelection?: boolean; - /** [Method] Returns position of the first selected cell in the selection in the format row row column column */ - getCurrentPosition?(): void; - /** [Method] Selects the record immediately following the currently selected record - * @param keepExisting Boolean True to retain existing selections - * @param suppressEvent Boolean Set to false to not fire a select event - */ - selectNext?( keepExisting?:boolean, suppressEvent?:boolean ): boolean; - /** [Method] Selects the record that precedes the currently selected record - * @param keepExisting Boolean True to retain existing selections - * @param suppressEvent Boolean Set to false to not fire a select event - */ - selectPrevious?( keepExisting?:boolean, suppressEvent?:boolean ): boolean; - } -} -declare module Ext.selection { - export interface ITreeModel extends Ext.selection.IRowModel { - /** [Method] binds the store to the selModel - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - } -} -declare module Ext { - export interface IShadow extends Ext.IBase { - /** [Config Option] (String) The shadow display mode. ... */ - mode?: string; - /** [Config Option] (Number) The number of pixels to offset the shadow from the element ... */ - offset?: number; - /** [Method] Hides this shadow */ - hide?(): void; - /** [Method] Returns true if the shadow is visible else false */ - isVisible?(): void; - /** [Method] Direct alignment when values are already available - * @param left Number The target element left position - * @param top Number The target element top position - * @param width Number The target element width - * @param height Number The target element height - */ - realign?( left?:number, top?:number, width?:number, height?:number ): void; - /** [Method] Sets the opacity of the shadow - * @param opacity Number The opacity - */ - setOpacity?( opacity?:number ): void; - /** [Method] Adjust the z index of this shadow - * @param zindex Number The new z-index - */ - setZIndex?( zindex?:number ): void; - /** [Method] Displays the shadow under the target element - * @param targetEl String The id or element under which the shadow should display - */ - show?( targetEl?:string ): void; - show?( targetEl?:HTMLElement ): void; - show?( targetEl?:Ext.IElement ): void; - } -} -declare module Ext { - export interface IShadowPool extends Ext.IBase { - } - export class ShadowPool { - } -} -declare module Ext.slider { - export interface IMulti extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Turn on or off animation. ... */ - animate?: boolean; - /** [Config Option] (Boolean) Determines whether or not clicking on the Slider axis will change the slider. ... */ - clickToChange?: boolean; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) True to disallow thumbs from overlapping one another. ... */ - constrainThumbs?: boolean; - /** [Config Option] (Number/Boolean) The number of decimal places to which to round the Slider's value. ... */ - decimalPrecision?: any; - /** [Config Option] (Number) How many units to change the slider when adjusting by drag and drop. ... */ - increment?: number; - /** [Config Option] (Number) How many units to change the Slider when adjusting with keyboard navigation. ... */ - keyIncrement?: number; - /** [Config Option] (Number) The maximum value for the Slider. ... */ - maxValue?: number; - /** [Config Option] (Number) The minimum value for the Slider. ... */ - minValue?: number; - /** [Config Option] (Function) A function used to display custom text for the slider tip. ... */ - tipText?: any; - /** [Config Option] (Object/Boolean) True to use an Ext.slider.Tip to display tips for the value. ... */ - useTips?: any; - /** [Config Option] (Number) A value with which to initialize the slider. ... */ - value?: number; - /** [Config Option] (Number[]) Array of Number values with which to initalize the slider. ... */ - values?: number[]; - /** [Config Option] (Boolean) Orient the Slider vertically rather than horizontally. ... */ - vertical?: boolean; - /** [Config Option] (Boolean) Set to true to calculate snap points based on increments from zero as opposed to from this Slider's minValue. ... */ - zeroBasedSnapping?: boolean; - /** [Property] (Boolean) True while the thumb is in a drag operation ... */ - dragging?: boolean; - /** [Property] (Array) */ - thumbs?: any[]; - /** [Method] Creates a new thumb and adds it to the slider - * @param value Number The initial value to set on the thumb. - */ - addThumb?( value?:number ): any; - /** [Method] private Invoked before the Component is destroyed */ - beforeDestroy?(): any; - /** [Method] private override Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current value of the slider - * @param index Number The index of the thumb to return a value for - */ - getValue?( index?:number ): any; - /** [Method] Returns an array of values one for the location of each thumb */ - getValues?(): any; - /** [Method] private override The initComponent template method is an important initialization step for a Component */ - initComponent?(): any; - /** [Method] private override Initializes the field s value based on the initial config */ - initValue?(): any; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): any; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): any; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): any; - /** [Method] Sets the maximum value for the slider instance - * @param val Number The new maximum value - */ - setMaxValue?( val?:number ): any; - /** [Method] Sets the minimum value for the slider instance - * @param val Number The new minimum value - */ - setMinValue?( val?:number ): any; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): any; - /** [Method] Programmatically sets the value of the Slider - * @param index any Index of the thumb to move. Alternatively, it can be an array of values to set for each thumb in the slider. - * @param value any The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate any Turn on or off animation - */ - setValue?( index?:any, value?:any, animate?:any ): any; - setValue?( index?:number, value?:number, animate?:boolean ): any; - setValue?( index?:number[], value?:number, animate?:boolean ): any; - /** [Method] Synchronizes thumbs position to the proper proportion of the total component width based on the current slider value */ - syncThumbs?(): any; - } -} -declare module Ext.slider { - export interface IMultiSlider extends Ext.form.field.IBase { - /** [Config Option] (Boolean) Turn on or off animation. ... */ - animate?: boolean; - /** [Config Option] (Boolean) Determines whether or not clicking on the Slider axis will change the slider. ... */ - clickToChange?: boolean; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) True to disallow thumbs from overlapping one another. ... */ - constrainThumbs?: boolean; - /** [Config Option] (Number/Boolean) The number of decimal places to which to round the Slider's value. ... */ - decimalPrecision?: any; - /** [Config Option] (Number) How many units to change the slider when adjusting by drag and drop. ... */ - increment?: number; - /** [Config Option] (Number) How many units to change the Slider when adjusting with keyboard navigation. ... */ - keyIncrement?: number; - /** [Config Option] (Number) The maximum value for the Slider. ... */ - maxValue?: number; - /** [Config Option] (Number) The minimum value for the Slider. ... */ - minValue?: number; - /** [Config Option] (Function) A function used to display custom text for the slider tip. ... */ - tipText?: any; - /** [Config Option] (Object/Boolean) True to use an Ext.slider.Tip to display tips for the value. ... */ - useTips?: any; - /** [Config Option] (Number) A value with which to initialize the slider. ... */ - value?: number; - /** [Config Option] (Number[]) Array of Number values with which to initalize the slider. ... */ - values?: number[]; - /** [Config Option] (Boolean) Orient the Slider vertically rather than horizontally. ... */ - vertical?: boolean; - /** [Config Option] (Boolean) Set to true to calculate snap points based on increments from zero as opposed to from this Slider's minValue. ... */ - zeroBasedSnapping?: boolean; - /** [Property] (Boolean) True while the thumb is in a drag operation ... */ - dragging?: boolean; - /** [Property] (Array) */ - thumbs?: any[]; - /** [Method] Creates a new thumb and adds it to the slider - * @param value Number The initial value to set on the thumb. - */ - addThumb?( value?:number ): any; - /** [Method] private Invoked before the Component is destroyed */ - beforeDestroy?(): any; - /** [Method] private override Creates and returns the data object to be used when rendering the fieldSubTpl */ - getSubTplData?(): any; - /** [Method] Returns the value that would be included in a standard form submit for this field */ - getSubmitValue?(): string; - /** [Method] Returns the current value of the slider - * @param index Number The index of the thumb to return a value for - */ - getValue?( index?:number ): any; - /** [Method] Returns an array of values one for the location of each thumb */ - getValues?(): any; - /** [Method] private override The initComponent template method is an important initialization step for a Component */ - initComponent?(): any; - /** [Method] private override Initializes the field s value based on the initial config */ - initValue?(): any; - /** [Method] private Allows addition of behavior to the disable operation */ - onDisable?(): any; - /** [Method] private Allows addition of behavior to the enable operation */ - onEnable?(): any; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): any; - /** [Method] Resets the current field value to the originally loaded value and clears any validation messages */ - reset?(): any; - /** [Method] Sets the maximum value for the slider instance - * @param val Number The new maximum value - */ - setMaxValue?( val?:number ): any; - /** [Method] Sets the minimum value for the slider instance - * @param val Number The new minimum value - */ - setMinValue?( val?:number ): any; - /** [Method] Sets the read only state of this field - * @param readOnly Boolean Whether the field should be read only. - */ - setReadOnly?( readOnly?:boolean ): any; - /** [Method] Programmatically sets the value of the Slider - * @param index any Index of the thumb to move. Alternatively, it can be an array of values to set for each thumb in the slider. - * @param value any The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate any Turn on or off animation - */ - setValue?( index?:any, value?:any, animate?:any ): any; - setValue?( index?:number, value?:number, animate?:boolean ): any; - setValue?( index?:number[], value?:number, animate?:boolean ): any; - /** [Method] Synchronizes thumbs position to the proper proportion of the total component width based on the current slider value */ - syncThumbs?(): any; - } -} -declare module Ext.slider { - export interface ISingle extends Ext.slider.IMulti { - /** [Method] Returns the current value of the slider */ - getValue?(): any; - /** [Method] Programmatically sets the value of the Slider - * @param value Number The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate Boolean Turn on or off animation - */ - setValue?( value?:number, animate?:boolean ): any; - } -} -declare module Ext { - export interface ISlider extends Ext.slider.IMulti { - /** [Method] Returns the current value of the slider */ - getValue?(): any; - /** [Method] Programmatically sets the value of the Slider - * @param value Number The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate Boolean Turn on or off animation - */ - setValue?( value?:number, animate?:boolean ): any; - } -} -declare module Ext.form { - export interface ISliderField extends Ext.slider.IMulti { - /** [Method] Returns the current value of the slider */ - getValue?(): any; - /** [Method] Programmatically sets the value of the Slider - * @param value Number The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate Boolean Turn on or off animation - */ - setValue?( value?:number, animate?:boolean ): any; - } -} -declare module Ext.slider { - export interface ISingleSlider extends Ext.slider.IMulti { - /** [Method] Returns the current value of the slider */ - getValue?(): any; - /** [Method] Programmatically sets the value of the Slider - * @param value Number The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate Boolean Turn on or off animation - */ - setValue?( value?:number, animate?:boolean ): any; - } -} -declare module Ext.slider { - export interface ISlider extends Ext.slider.IMulti { - /** [Method] Returns the current value of the slider */ - getValue?(): any; - /** [Method] Programmatically sets the value of the Slider - * @param value Number The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param animate Boolean Turn on or off animation - */ - setValue?( value?:number, animate?:boolean ): any; - } -} -declare module Ext.slider { - export interface IThumb extends Ext.IBase { - /** [Config Option] (Boolean) True to constrain the thumb so that it cannot overlap its siblings ... */ - constrain?: boolean; - /** [Config Option] (Ext.slider.MultiSlider) */ - slider?: Ext.slider.IMultiSlider; - /** [Method] Disables the thumb if it is currently enabled */ - disable?(): void; - /** [Method] Enables the thumb if it is currently disabled */ - enable?(): void; - /** [Method] Sets up an Ext dd DragTracker for this thumb */ - initEvents?(): void; - /** [Method] Renders the thumb into a slider */ - render?(): void; - } -} -declare module Ext.slider { - export interface ITip extends Ext.tip.ITip { - /** [Config Option] (String) Alignment configuration for the tip to the slider. ... */ - align?: string; - /** [Config Option] (Number) The minimum width of the tip in pixels. ... */ - minWidth?: number; - /** [Config Option] (Array) Offsets for aligning the tip to the slider. ... */ - offsets?: any[]; - /** [Config Option] (String) Sets the position for where the tip will be displayed related to the thumb. ... */ - position?: string; - /** [Method] Used to create the text that appears in the Tip s body - * @param thumb Ext.slider.IThumb The Thumb that the Tip is attached to - */ - getText?( thumb?:Ext.slider.IThumb ): string; - } -} -declare module Ext.state { - export interface ICookieProvider extends Ext.state.IProvider { - /** [Config Option] (String) The domain to save the cookie for. ... */ - domain?: string; - /** [Config Option] (Date) The cookie expiration date. ... */ - expires?: any; - /** [Config Option] (String) The path for which the cookie is active. ... */ - path?: string; - /** [Config Option] (Boolean) True if the site is using SSL ... */ - secure?: boolean; - /** [Method] private Clears a value from the state - * @param name String The key name - */ - clear?( name?:string ): void; - /** [Method] private Sets the value for a key - * @param name String The key name - * @param value Object The value to set - */ - set?( name?:string, value?:any ): void; - } -} -declare module Ext.state { - export interface ILocalStorageProvider extends Ext.state.IProvider { - /** [Method] private Clears a value from the state - * @param name String The key name - */ - clear?( name?:string ): void; - /** [Method] Sets the value for a key - * @param name String The key name - * @param value Object The value to set - */ - set?( name?:string, value?:any ): void; - } -} -declare module Ext.state { - export interface IManager extends Ext.IBase { - } - export class Manager { - /** [Method] */ - constructor(); - /** [Method] Clears a value from the state - * @param name String The key name - */ - static clear( name?:string ): void; - /** [Method] Returns the current value for a key - * @param name String The key name - * @param defaultValue Object The default value to return if the key lookup does not match - */ - static get( name?:string, defaultValue?:any ): any; - /** [Method] Gets the currently configured state provider */ - static getProvider(): Ext.state.IProvider; - /** [Method] Sets the value for a key - * @param name String The key name - * @param value Object The state data - */ - static set( name?:string, value?:any ): void; - /** [Method] Configures the default state provider for your application - * @param stateProvider Ext.state.IProvider The state provider to set - */ - static setProvider( stateProvider?:Ext.state.IProvider ): void; - } -} -declare module Ext.state { - export interface IProvider extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (String) A string to prefix to items stored in the underlying state store. ... */ - prefix?: string; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Clears a value from the state - * @param name String The key name - */ - clear?( name?:string ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Decodes a string previously encoded with encodeValue - * @param value String The value to decode - */ - decodeValue?( value?:string ): any; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Encodes a value including type information - * @param value Object The value to encode - */ - encodeValue?( value?:any ): string; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the current value for a key - * @param name String The key name - * @param defaultValue Object A default value to return if the key's value is not found - */ - get?( name?:string, defaultValue?:any ): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Sets the value for a key - * @param name String The key name - * @param value Object The value to set - */ - set?( name?:string, value?:any ): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.state { - export interface IStateful extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Number) A buffer to be applied if many state events are fired within a short period. ... */ - saveDelay?: number; - /** [Config Option] (String[]) An array of events that, when fired, should trigger this object to save its state. ... */ - stateEvents?: string[]; - /** [Config Option] (String) The unique id for this object to use for state management purposes. ... */ - stateId?: string; - /** [Config Option] (Boolean) A flag which causes the object to attempt to restore the state of internal properties from a saved state on startup. ... */ - stateful?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Add events that will trigger the state to be saved - * @param events String The event name or an array of event names. - */ - addStateEvents?( events?:string ): void; - addStateEvents?( events?:string[] ): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Destroys this stateful object */ - destroy?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Gets the current state of the object */ - getState?(): any; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Conditionally saves a single property from this object to the given state object - * @param propName String The name of the property to save. - * @param state Object The state object in to which to save the property. - * @param stateName String The name to use for the property in state. - */ - savePropToState?( propName?:string, state?:any, stateName?:string ): boolean; - /** [Method] Gathers additional named properties of the instance and adds their current values to the passed state object - * @param propNames any The name (or array of names) of the property to save. - * @param state any The state object in to which to save the property values. - */ - savePropsToState?( propNames?:any, state?:any ): any; - savePropsToState?( propNames?:string, state?:any ): any; - savePropsToState?( propNames?:string[], state?:any ): any; - /** [Method] Saves the state of the object to the persistence store */ - saveState?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IString { - } - export class String { - /** [Method] Adds a set of character entity definitions to the set used by htmlEncode and htmlDecode - * @param entities Object The set of character entities to add to the current definitions. - */ - static addCharacterEntities( entities?:any ): void; - /** [Method] Capitalize the given string - * @param string String - */ - static capitalize( string?:string ): string; - /** [Method] Converts a string of characters into a legal parse able JavaScript var name as long as the passed string contains at - * @param s String A string to be converted into a var name. - */ - static createVarName( s?:string ): string; - /** [Method] Truncate a string and add an ellipsis to the end if it exceeds the specified length - * @param value String The string to truncate. - * @param length Number The maximum length to allow before truncating. - * @param word Boolean true to try to find a common word break. - */ - static ellipsis( value?:string, length?:number, word?:boolean ): string; - /** [Method] Checks if a string ends with a substring - * @param s String The original string - * @param start String The substring to check - * @param ignoreCase Boolean True to ignore the case in the comparison - */ - static endsWith( s?:string, start?:string, ignoreCase?:boolean ): void; - /** [Method] Escapes the passed string for and - * @param string String The string to escape - */ - static escape( string?:string ): string; - /** [Method] Escapes the passed string for use in a regular expression - * @param string String - */ - static escapeRegex( string?:string ): string; - /** [Method] Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens - * @param string String The tokenized string to be formatted. - * @param values Mixed... The values to replace tokens {0}, {1}, etc in order. - */ - static format( string:string, ...values:any[] ): string; - /** [Method] Convert certain characters amp lt and from their HTML character equivalents - * @param value String The string to decode. - */ - static htmlDecode( value?:string ): string; - /** [Method] Convert certain characters amp lt and to their HTML character equivalents for literal display in web - * @param value String The string to encode. - */ - static htmlEncode( value?:string ): string; - /** [Method] Inserts a substring into a string - * @param s String The original string. - * @param value String The substring to insert. - * @param index Number The index to insert the substring. Negative indexes will insert from the end of the string. Example: Ext.String.insert("abcdefg", "h", -1); // abcdefhg - */ - static insert( s?:string, value?:string, index?:number ): string; - /** [Method] Pads the left side of a string with a specified character - * @param string String The original string. - * @param size Number The total length of the output string. - * @param character String The character with which to pad the original string. - */ - static leftPad( string?:string, size?:number, character?:string ): string; - /** [Method] Returns a string with a specified number of repetitions a given string pattern - * @param pattern String The pattern to repeat. - * @param count Number The number of times to repeat the pattern (may be 0). - * @param sep String An option string to separate each pattern. - */ - static repeat( pattern?:string, count?:number, sep?:string ): void; - /** [Method] Resets the set of character entity definitions used by htmlEncode and htmlDecode back to the default state */ - static resetCharacterEntities(): void; - /** [Method] Splits a string of space separated words into an array trimming as needed - * @param words String - */ - static splitWords( words?:string ): void; - static splitWords( words?:any[] ): void; - /** [Method] Checks if a string starts with a substring - * @param s String The original string - * @param start String The substring to check - * @param ignoreCase Boolean True to ignore the case in the comparison - */ - static startsWith( s?:string, start?:string, ignoreCase?:boolean ): void; - /** [Method] Utility function that allows you to easily switch a string between two alternating values - * @param string String The current string. - * @param value String The value to compare to the current string. - * @param other String The new value to use if the string already equals the first value passed in. - */ - static toggle( string?:string, value?:string, other?:string ): string; - /** [Method] Trims whitespace from either end of a string leaving spaces within the string intact - * @param string String The string to trim. - */ - static trim( string?:string ): string; - /** [Method] Uncapitalize the given string - * @param string String - */ - static uncapitalize( string?:string ): string; - /** [Method] Appends content to the query string of a URL handling logic for whether to place a question mark or ampersand - * @param url String The URL to append to. - * @param string String The content to append to the URL. - */ - static urlAppend( url?:string, string?:string ): string; - } -} -declare module Ext { - export interface Isupports { - } - export class supports { - } -} -declare module Ext.tab { - export interface IBar extends Ext.panel.IHeader { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number) The maximum width for a tab in this tab Bar. ... */ - maxTabWidth?: number; - /** [Config Option] (Number) The minimum width for a tab in this tab Bar. ... */ - minTabWidth?: number; - /** [Config Option] (Boolean) True to not show the full background on the tabbar ... */ - plain?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Tab Bar, or subclass thereof. ... */ - isTabBar?: boolean; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Invoked after the Container has laid out and rendered if necessary its child Components - * @param layout Ext.layout.container.IContainer - */ - afterLayout?( layout?:Ext.layout.container.IContainer ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Returns the layout instance currently associated with this Container */ - getLayout?(): Ext.layout.container.IContainer; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Set up the tools lt tool type gt link in the owning Panel - * @param component Object - * @param index Object - */ - onAdd?( component?:any, index?:any ): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - } -} -declare module Ext.tab { - export interface IPanel extends Ext.panel.IPanel { - /** [Config Option] (String/Number) */ - activeItem?: any; - /** [Config Option] (String/Number/Ext.Component) The tab to activate initially. ... */ - activeTab?: any; - /** [Config Option] (Boolean) True by default to defer the rendering of child items to the browsers DOM until a tab is activated. ... */ - deferredRender?: boolean; - /** [Config Option] (String) The class added to each child item of this TabPanel. ... */ - itemCls?: string; - /** [Config Option] (Ext.enums.Layout/Object) Optional configuration object for the internal card layout. ... */ - layout?: any; - /** [Config Option] (Number) */ - maxTabWidth?: number; - /** [Config Option] (Number) */ - minTabWidth?: number; - /** [Config Option] (Boolean) True to not show the full background on the TabBar. ... */ - plain?: boolean; - /** [Config Option] (Boolean) True to instruct each Panel added to the TabContainer to not render its header element. ... */ - removePanelHeader?: boolean; - /** [Config Option] (Object) Optional configuration object for the internal Ext.tab.Bar. ... */ - tabBar?: any; - /** [Config Option] ("top"/"bottom"/"left"/"right") The position where the tab strip should be rendered. ... */ - tabPosition?: any; - /** [Method] Returns the item that is currently active inside this TabPanel */ - getActiveTab?(): Ext.IComponent; - /** [Method] Returns the Ext tab Bar currently used in this TabPanel */ - getTabBar?(): Ext.tab.IBar; - /** [Method] inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Makes sure we have a Tab for each item added to the TabPanel - * @param item Object - * @param index Object - */ - onAdd?( item?:any, index?:any ): void; - /** [Method] Makes the given card active - * @param card any The card to make active. Either an ID, index or the component itself. - */ - setActiveTab?( card?:any ): any; - setActiveTab?( card?:string ): Ext.IComponent; - setActiveTab?( card?:number ): Ext.IComponent; - setActiveTab?( card?:Ext.IComponent ): Ext.IComponent; - } -} -declare module Ext { - export interface ITabPanel extends Ext.panel.IPanel { - /** [Config Option] (String/Number) */ - activeItem?: any; - /** [Config Option] (String/Number/Ext.Component) The tab to activate initially. ... */ - activeTab?: any; - /** [Config Option] (Boolean) True by default to defer the rendering of child items to the browsers DOM until a tab is activated. ... */ - deferredRender?: boolean; - /** [Config Option] (String) The class added to each child item of this TabPanel. ... */ - itemCls?: string; - /** [Config Option] (Ext.enums.Layout/Object) Optional configuration object for the internal card layout. ... */ - layout?: any; - /** [Config Option] (Number) */ - maxTabWidth?: number; - /** [Config Option] (Number) */ - minTabWidth?: number; - /** [Config Option] (Boolean) True to not show the full background on the TabBar. ... */ - plain?: boolean; - /** [Config Option] (Boolean) True to instruct each Panel added to the TabContainer to not render its header element. ... */ - removePanelHeader?: boolean; - /** [Config Option] (Object) Optional configuration object for the internal Ext.tab.Bar. ... */ - tabBar?: any; - /** [Config Option] ("top"/"bottom"/"left"/"right") The position where the tab strip should be rendered. ... */ - tabPosition?: any; - /** [Method] Returns the item that is currently active inside this TabPanel */ - getActiveTab?(): Ext.IComponent; - /** [Method] Returns the Ext tab Bar currently used in this TabPanel */ - getTabBar?(): Ext.tab.IBar; - /** [Method] inherit docs The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Makes sure we have a Tab for each item added to the TabPanel - * @param item Object - * @param index Object - */ - onAdd?( item?:any, index?:any ): void; - /** [Method] Makes the given card active - * @param card any The card to make active. Either an ID, index or the component itself. - */ - setActiveTab?( card?:any ): any; - setActiveTab?( card?:string ): Ext.IComponent; - setActiveTab?( card?:number ): Ext.IComponent; - setActiveTab?( card?:Ext.IComponent ): Ext.IComponent; - } -} -declare module Ext.tab { - export interface ITab extends Ext.button.IButton { - /** [Config Option] (String) The CSS class to be applied to a Tab when it is active. ... */ - activeCls?: string; - /** [Config Option] (String) The base CSS class to add to all buttons. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to make the Tab start closable (the close icon will be visible). ... */ - closable?: boolean; - /** [Config Option] (String) The CSS class which is added to the tab when it is closable ... */ - closableCls?: string; - /** [Config Option] (String) The accessible text label for the close button link; only used when closable = true. ... */ - closeText?: string; - /** [Config Option] (String) The CSS class to be applied to a Tab when it is disabled. ... */ - disabledCls?: string; - /** [Config Option] ("small"/"medium"/"large") The size of the Button. ... */ - scale?: any; - /** [Property] (Boolean) Indicates that this tab is currently active. ... */ - active?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Tab, or subclass thereof. ... */ - isTab?: boolean; - /** [Method] inherit docs Disable the component - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): void; - /** [Method] inherit docs Enable the component - * @param silent Boolean Passing true will suppress the enable event from being fired. - */ - enable?( silent?:boolean ): void; - /** [Method] This method returns an object which provides substitution parameters for the XTemplate used to create this Button s D */ - getTemplateArgs?(): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Sets this tab s attached card - * @param card Ext.IComponent The card to set - */ - setCard?( card?:Ext.IComponent ): void; - /** [Method] Sets the tab as either closable or not - * @param closable Boolean Pass false to make the tab not closable. Otherwise the tab will be made closable (eg a close button will appear on the tab) - */ - setClosable?( closable?:boolean ): void; - } -} -declare module Ext { - export interface ITemplate extends Ext.IBase { - /** [Config Option] (Boolean) True to immediately compile the template. ... */ - compiled?: boolean; - /** [Config Option] (Boolean) True to disable format functions in the template. ... */ - disableFormats?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Template, or subclass thereof. ... */ - isTemplate?: boolean; - /** [Method] Applies the supplied values to the template and appends the new node s to the specified el - * @param el any The context element - * @param values any The template values. See applyTemplate for details. - * @param returnElement any true to return an Ext.Element. - */ - append?( el?:any, values?:any, returnElement?:any ): any; - append?( el?:string, values?:any, returnElement?:boolean ): any; - append?( el?:HTMLElement, values?:any, returnElement?:boolean ): any; - append?( el?:Ext.IElement, values?:any, returnElement?:boolean ): any; - /** [Method] Returns an HTML fragment of this template with the specified values applied - * @param values any The template values. Can be an array if your params are numeric: var tpl = new Ext.Template('Name: {0}, Age: {1}'); tpl.apply(['John', 25]); or an object: var tpl = new Ext.Template('Name: {name}, Age: {age}'); tpl.apply({name: 'John', age: 25}); - */ - apply?( values?:any ): string; - /** [Method] Appends the result of this template to the provided output array - * @param values any The template values. See apply. - * @param out Array The array to which output is pushed. - */ - applyOut?( values?:any, out?:any[] ): any[]; - /** [Method] Alias for apply - * @param values any The template values. Can be an array if your params are numeric: var tpl = new Ext.Template('Name: {0}, Age: {1}'); tpl.apply(['John', 25]); or an object: var tpl = new Ext.Template('Name: {name}, Age: {age}'); tpl.apply({name: 'John', age: 25}); - */ - applyTemplate?( values?:any ): string; - /** [Method] Compiles the template into an internal function eliminating the RegEx overhead */ - compile?(): Ext.ITemplate; - /** [Method] Applies the supplied values to the template and inserts the new node s after el - * @param el any The context element - * @param values any The template values. See applyTemplate for details. - * @param returnElement any true to return a Ext.Element. - */ - insertAfter?( el?:any, values?:any, returnElement?:any ): any; - insertAfter?( el?:string, values?:any, returnElement?:boolean ): any; - insertAfter?( el?:HTMLElement, values?:any, returnElement?:boolean ): any; - insertAfter?( el?:Ext.IElement, values?:any, returnElement?:boolean ): any; - /** [Method] Applies the supplied values to the template and inserts the new node s before el - * @param el any The context element - * @param values any The template values. See applyTemplate for details. - * @param returnElement any true to return a Ext.Element. - */ - insertBefore?( el?:any, values?:any, returnElement?:any ): any; - insertBefore?( el?:string, values?:any, returnElement?:boolean ): any; - insertBefore?( el?:HTMLElement, values?:any, returnElement?:boolean ): any; - insertBefore?( el?:Ext.IElement, values?:any, returnElement?:boolean ): any; - /** [Method] Applies the supplied values to the template and inserts the new node s as the first child of el - * @param el any The context element - * @param values any The template values. See applyTemplate for details. - * @param returnElement any true to return a Ext.Element. - */ - insertFirst?( el?:any, values?:any, returnElement?:any ): any; - insertFirst?( el?:string, values?:any, returnElement?:boolean ): any; - insertFirst?( el?:HTMLElement, values?:any, returnElement?:boolean ): any; - insertFirst?( el?:Ext.IElement, values?:any, returnElement?:boolean ): any; - /** [Method] Applies the supplied values to the template and overwrites the content of el with the new node s - * @param el any The context element - * @param values any The template values. See applyTemplate for details. - * @param returnElement any true to return a Ext.Element. - */ - overwrite?( el?:any, values?:any, returnElement?:any ): any; - overwrite?( el?:string, values?:any, returnElement?:boolean ): any; - overwrite?( el?:HTMLElement, values?:any, returnElement?:boolean ): any; - overwrite?( el?:Ext.IElement, values?:any, returnElement?:boolean ): any; - /** [Method] Sets the HTML used as the template and optionally compiles it - * @param html String - * @param compile Boolean True to compile the template. - */ - set?( html?:string, compile?:boolean ): Ext.ITemplate; - } -} -declare module Ext.tip { - export interface IQuickTip extends Ext.tip.IToolTip { - /** [Config Option] (Boolean) true to automatically use the element's DOM title value if available. ... */ - interceptTitles?: boolean; - /** [Config Option] (String/HTMLElement/Ext.Element) The target HTMLElement, Ext.Element or id to associate with this Quicktip. ... */ - target?: any; - /** [Config Option] (String) Force creation of header Component The title text to be used to display in the panel header. ... */ - title?: string; - /** [Method] Hides a visible tip or cancels an impending show for a particular element - * @param el String The element that is the target of the tip or ID of the element. - */ - cancelShow?( el?:string ): void; - cancelShow?( el?:HTMLElement ): void; - cancelShow?( el?:Ext.IElement ): void; - /** [Method] Hides this tooltip if visible */ - hide? (animateTarget?: any, callback?: any, scope?: any): any; - hide? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IComponent, callback?: any, scope?: any): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Configures a new quick tip instance and assigns it to a target element - * @param config Object The config object with the following properties: - */ - register?( config?:any ): void; - /** [Method] Shows this tooltip at the current event target XY position */ - show? (animateTarget?: any, callback?: any, scope?: any): any; - show? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - show? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - /** [Method] Removes this quick tip from its element and destroys it - * @param el String The element from which the quick tip is to be removed or ID of the element. - */ - unregister?( el?:string ): void; - unregister?( el?:HTMLElement ): void; - unregister?( el?:Ext.IElement ): void; - } -} -declare module Ext { - export interface IQuickTip extends Ext.tip.IToolTip { - /** [Config Option] (Boolean) true to automatically use the element's DOM title value if available. ... */ - interceptTitles?: boolean; - /** [Config Option] (String/HTMLElement/Ext.Element) The target HTMLElement, Ext.Element or id to associate with this Quicktip. ... */ - target?: any; - /** [Config Option] (String) Force creation of header Component The title text to be used to display in the panel header. ... */ - title?: string; - /** [Method] Hides a visible tip or cancels an impending show for a particular element - * @param el String The element that is the target of the tip or ID of the element. - */ - cancelShow?( el?:string ): void; - cancelShow?( el?:HTMLElement ): void; - cancelShow?( el?:Ext.IElement ): void; - /** [Method] Hides this tooltip if visible */ - hide? (animateTarget?: any, callback?: any, scope?: any): any; - hide? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IComponent, callback?: any, scope?: any): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Configures a new quick tip instance and assigns it to a target element - * @param config Object The config object with the following properties: - */ - register?( config?:any ): void; - /** [Method] Shows this tooltip at the current event target XY position */ - show? (animateTarget?: any, callback?: any, scope?: any): any; - show? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - show? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - /** [Method] Removes this quick tip from its element and destroys it - * @param el String The element from which the quick tip is to be removed or ID of the element. - */ - unregister?( el?:string ): void; - unregister?( el?:HTMLElement ): void; - unregister?( el?:Ext.IElement ): void; - } -} -declare module Ext.tip { - export interface IQuickTipManager extends Ext.IBase { - } - export class QuickTipManager { - /** [Method] Destroys the QuickTips instance */ - static destroy(): void; - /** [Method] Disables quick tips globally */ - static disable(): void; - /** [Method] Enables quick tips globally */ - static enable(): void; - /** [Method] Gets the single QuickTip instance used to show tips from all registered elements */ - static getQuickTip(): Ext.tip.IQuickTip; - /** [Method] Initializes the global QuickTips instance and prepare any quick tips - * @param autoRender Boolean True to render the QuickTips container immediately to preload images. - * @param config Object config object for the created QuickTip. By default, the QuickTip class is instantiated, but this can be changed by supplying an xtype property or a className property in this object. All other properties on this object are configuration for the created component. - */ - static init( autoRender?:boolean, config?:any ): void; - /** [Method] Returns true if quick tips are enabled else false */ - static isEnabled(): boolean; - /** [Method] Configures a new quick tip instance and assigns it to a target element - * @param config Object The config object - */ - static register( config?:any ): void; - /** [Method] Alias of register - * @param config Object The config object - */ - static tips( config?:any ): void; - /** [Method] Removes any registered quick tip from the target element and destroys it - * @param el String The element from which the quick tip is to be removed or ID of the element. - */ - static unregister( el?:string ): void; - static unregister( el?:HTMLElement ): void; - static unregister( el?:Ext.IElement ): void; - } -} -declare module Ext.tip { - export interface ITip extends Ext.panel.IPanel { - /** [Config Option] (Boolean/String/HTMLElement/Ext.Element) private panel overrides This config is intended mainly for non-floating Components which may or may not be shown. ... */ - autoRender?: any; - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to render a close tool button into the tooltip header. ... */ - closable?: boolean; - /** [Config Option] (String) The action to take when the close header tool is clicked: destroy : remove the window from the DOM and destroy it a... */ - closeAction?: string; - /** [Config Option] (Boolean) If true, then the tooltip will be automatically constrained to stay within the browser viewport. ... */ - constrainPosition?: boolean; - /** [Config Option] (String) Experimental. ... */ - defaultAlign?: string; - /** [Config Option] (Boolean) Specify as true to float the Component outside of the document flow using CSS absolute positioning. ... */ - floating?: boolean; - /** [Config Option] (Boolean) Specifies whether the floated component should be automatically focused when it is brought to the front. ... */ - focusOnToFront?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel panels header (if 'frame' is true). ... */ - frameHeader?: boolean; - /** [Config Option] (Boolean) true to hide the component. ... */ - hidden?: boolean; - /** [Config Option] (Number) The maximum width of the tip in pixels. ... */ - maxWidth?: number; - /** [Config Option] (Number) The minimum width of the tip in pixels. ... */ - minWidth?: number; - /** [Config Option] (Boolean/String) true or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow. ... */ - shadow?: any; - /** [Config Option] (Number) Width in pixels of the tip. ... */ - width?: number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext { - export interface ITip extends Ext.panel.IPanel { - /** [Config Option] (Boolean/String/HTMLElement/Ext.Element) private panel overrides This config is intended mainly for non-floating Components which may or may not be shown. ... */ - autoRender?: any; - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to render a close tool button into the tooltip header. ... */ - closable?: boolean; - /** [Config Option] (String) The action to take when the close header tool is clicked: destroy : remove the window from the DOM and destroy it a... */ - closeAction?: string; - /** [Config Option] (Boolean) If true, then the tooltip will be automatically constrained to stay within the browser viewport. ... */ - constrainPosition?: boolean; - /** [Config Option] (String) Experimental. ... */ - defaultAlign?: string; - /** [Config Option] (Boolean) Specify as true to float the Component outside of the document flow using CSS absolute positioning. ... */ - floating?: boolean; - /** [Config Option] (Boolean) Specifies whether the floated component should be automatically focused when it is brought to the front. ... */ - focusOnToFront?: boolean; - /** [Config Option] (Boolean) True to apply a frame to the panel panels header (if 'frame' is true). ... */ - frameHeader?: boolean; - /** [Config Option] (Boolean) true to hide the component. ... */ - hidden?: boolean; - /** [Config Option] (Number) The maximum width of the tip in pixels. ... */ - maxWidth?: number; - /** [Config Option] (Number) The minimum width of the tip in pixels. ... */ - minWidth?: number; - /** [Config Option] (Boolean/String) true or "sides" for the default effect, "frame" for 4-way shadow, and "drop" for bottom-right shadow. ... */ - shadow?: any; - /** [Config Option] (Number) Width in pixels of the tip. ... */ - width?: number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext.tip { - export interface IToolTip extends Ext.tip.ITip { - /** [Config Option] (String) If specified, indicates that the tip should be anchored to a particular side of the target element or mouse pointer (... */ - anchor?: string; - /** [Config Option] (Number) A numeric pixel value used to offset the default position of the anchor arrow. ... */ - anchorOffset?: number; - /** [Config Option] (Boolean) True to anchor the tooltip to the target element, false to anchor it relative to the mouse coordinates. ... */ - anchorToTarget?: boolean; - /** [Config Option] (Boolean) True to automatically hide the tooltip after the mouse exits the target element or after the dismissDelay has expired... */ - autoHide?: boolean; - /** [Config Option] (String) A DomQuery selector which allows selection of individual elements within the target element to trigger showing and hi... */ - delegate?: string; - /** [Config Option] (Number) Delay in milliseconds before the tooltip automatically hides. ... */ - dismissDelay?: number; - /** [Config Option] (Number) Delay in milliseconds after the mouse exits the target element but before the tooltip actually hides. ... */ - hideDelay?: number; - /** [Config Option] (Number[]) An XY offset from the mouse position where the tooltip should be shown. ... */ - mouseOffset?: number[]; - /** [Config Option] (Number) Delay in milliseconds before the tooltip displays after the mouse enters the target element. ... */ - showDelay?: number; - /** [Config Option] (HTMLElement/Ext.Element/String) */ - target?: any; - /** [Config Option] (Boolean) True to have the tooltip follow the mouse as it moves over the target element. ... */ - trackMouse?: boolean; - /** [Property] (HTMLElement) When a ToolTip is configured with the delegate option to cause selected child elements of the target Element to each ... */ - triggerElement?: HTMLElement; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Hides this tooltip if visible */ - hide? (animateTarget?: any, callback?: any, scope?: any): any; - hide? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IComponent, callback?: any, scope?: any): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Binds this ToolTip to the specified element - * @param t String The Element, HtmlElement, or ID of an element to bind to - */ - setTarget?( t?:string ): void; - setTarget?( t?:HTMLElement ): void; - setTarget?( t?:Ext.IElement ): void; - /** [Method] Shows this tooltip at the current event target XY position */ - show? (animateTarget?: any, callback?: any, scope?: any): any; - show? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - show? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - } -} -declare module Ext { - export interface IToolTip extends Ext.tip.ITip { - /** [Config Option] (String) If specified, indicates that the tip should be anchored to a particular side of the target element or mouse pointer (... */ - anchor?: string; - /** [Config Option] (Number) A numeric pixel value used to offset the default position of the anchor arrow. ... */ - anchorOffset?: number; - /** [Config Option] (Boolean) True to anchor the tooltip to the target element, false to anchor it relative to the mouse coordinates. ... */ - anchorToTarget?: boolean; - /** [Config Option] (Boolean) True to automatically hide the tooltip after the mouse exits the target element or after the dismissDelay has expired... */ - autoHide?: boolean; - /** [Config Option] (String) A DomQuery selector which allows selection of individual elements within the target element to trigger showing and hi... */ - delegate?: string; - /** [Config Option] (Number) Delay in milliseconds before the tooltip automatically hides. ... */ - dismissDelay?: number; - /** [Config Option] (Number) Delay in milliseconds after the mouse exits the target element but before the tooltip actually hides. ... */ - hideDelay?: number; - /** [Config Option] (Number[]) An XY offset from the mouse position where the tooltip should be shown. ... */ - mouseOffset?: number[]; - /** [Config Option] (Number) Delay in milliseconds before the tooltip displays after the mouse enters the target element. ... */ - showDelay?: number; - /** [Config Option] (HTMLElement/Ext.Element/String) */ - target?: any; - /** [Config Option] (Boolean) True to have the tooltip follow the mouse as it moves over the target element. ... */ - trackMouse?: boolean; - /** [Property] (HTMLElement) When a ToolTip is configured with the delegate option to cause selected child elements of the target Element to each ... */ - triggerElement?: HTMLElement; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Hides this tooltip if visible */ - hide? (animateTarget?: any, callback?: any, scope?: any): any; - hide? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - hide? (animateTarget?: Ext.IComponent, callback?: any, scope?: any): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Allows addition of behavior to the disable operation */ - onDisable?(): void; - /** [Method] Possibly animates down to a target element - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onHide?( animateTarget?:string, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - onHide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Binds this ToolTip to the specified element - * @param t String The Element, HtmlElement, or ID of an element to bind to - */ - setTarget?( t?:string ): void; - setTarget?( t?:HTMLElement ): void; - setTarget?( t?:Ext.IElement ): void; - /** [Method] Shows this tooltip at the current event target XY position */ - show? (animateTarget?: any, callback?: any, scope?: any): any; - show? (animateTarget?: string, callback?: any, scope?: any): Ext.IComponent; - show? (animateTarget?: Ext.IElement, callback?: any, scope?: any): Ext.IComponent; - } -} -declare module Ext.toolbar { - export interface IFill extends Ext.IComponent { - /** [Property] (Boolean) true in this class to identify an object as an instantiated Fill, or subclass thereof. ... */ - isFill?: boolean; - } -} -declare module Ext.toolbar { - export interface IItem extends Ext.IComponent { - /** [Config Option] (String) */ - overflowText?: string; - /** [Method] Disable the component - * @param silent Boolean Passing true will suppress the disable event from being fired. - */ - disable?( silent?:boolean ): void; - /** [Method] Enable the component - * @param silent Boolean Passing true will suppress the enable event from being fired. - */ - enable?( silent?:boolean ): void; - /** [Method] Try to focus this component - * @param selectText any If applicable, true to also select the text in this component - * @param delay any Delay the focus this number of milliseconds (true for 10 milliseconds). - */ - focus?( selectText?:any, delay?:any ): any; - focus?( selectText?:boolean, delay?:boolean ): Ext.IComponent; - focus?( selectText?:boolean, delay?:number ): Ext.IComponent; - } -} -declare module Ext.toolbar { - export interface IPaging extends Ext.toolbar.IToolbar,Ext.util.IBindable { - /** [Config Option] (String) Customizable piece of the default paging text. ... */ - afterPageText?: string; - /** [Config Option] (String) The text displayed before the input item. ... */ - beforePageText?: string; - /** [Config Option] (Boolean) true to display the displayMsg ... */ - displayInfo?: boolean; - /** [Config Option] (String) The paging status message to display. ... */ - displayMsg?: string; - /** [Config Option] (String) The message to display when no records are found. ... */ - emptyMsg?: string; - /** [Config Option] (String) The quicktip text displayed for the first page button. ... */ - firstText?: string; - /** [Config Option] (Number) The width in pixels of the input field used to display and change the current page number. ... */ - inputItemWidth?: number; - /** [Config Option] (String) The quicktip text displayed for the last page button. ... */ - lastText?: string; - /** [Config Option] (String) The quicktip text displayed for the next page button. ... */ - nextText?: string; - /** [Config Option] (Boolean) true to insert any configured items before the paging buttons. ... */ - prependButtons?: boolean; - /** [Config Option] (String) The quicktip text displayed for the previous page button. ... */ - prevText?: string; - /** [Config Option] (String) The quicktip text displayed for the Refresh button. ... */ - refreshText?: string; - /** [Config Option] (Ext.data.Store) */ - store?: Ext.data.IStore; - /** [Method] Binds the paging toolbar to the specified Ext data Store deprecated - * @param store Ext.data.IStore The data store to bind - */ - bind?( store?:Ext.data.IStore ): void; - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Refresh the current page has the same effect as clicking the refresh button */ - doRefresh?(): void; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Move to the first page has the same effect as clicking the first button */ - moveFirst?(): void; - /** [Method] Move to the last page has the same effect as clicking the last button */ - moveLast?(): void; - /** [Method] Move to the next page has the same effect as clicking the next button */ - moveNext?(): void; - /** [Method] Move to the previous page has the same effect as clicking the previous button */ - movePrevious?(): void; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Unbinds the paging toolbar from the specified Ext data Store deprecated - * @param store Ext.data.IStore The data store to unbind - */ - unbind?( store?:Ext.data.IStore ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext { - export interface IPagingToolbar extends Ext.toolbar.IToolbar,Ext.util.IBindable { - /** [Config Option] (String) Customizable piece of the default paging text. ... */ - afterPageText?: string; - /** [Config Option] (String) The text displayed before the input item. ... */ - beforePageText?: string; - /** [Config Option] (Boolean) true to display the displayMsg ... */ - displayInfo?: boolean; - /** [Config Option] (String) The paging status message to display. ... */ - displayMsg?: string; - /** [Config Option] (String) The message to display when no records are found. ... */ - emptyMsg?: string; - /** [Config Option] (String) The quicktip text displayed for the first page button. ... */ - firstText?: string; - /** [Config Option] (Number) The width in pixels of the input field used to display and change the current page number. ... */ - inputItemWidth?: number; - /** [Config Option] (String) The quicktip text displayed for the last page button. ... */ - lastText?: string; - /** [Config Option] (String) The quicktip text displayed for the next page button. ... */ - nextText?: string; - /** [Config Option] (Boolean) true to insert any configured items before the paging buttons. ... */ - prependButtons?: boolean; - /** [Config Option] (String) The quicktip text displayed for the previous page button. ... */ - prevText?: string; - /** [Config Option] (String) The quicktip text displayed for the Refresh button. ... */ - refreshText?: string; - /** [Config Option] (Ext.data.Store) */ - store?: Ext.data.IStore; - /** [Method] Binds the paging toolbar to the specified Ext data Store deprecated - * @param store Ext.data.IStore The data store to bind - */ - bind?( store?:Ext.data.IStore ): void; - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Refresh the current page has the same effect as clicking the refresh button */ - doRefresh?(): void; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Move to the first page has the same effect as clicking the first button */ - moveFirst?(): void; - /** [Method] Move to the last page has the same effect as clicking the last button */ - moveLast?(): void; - /** [Method] Move to the next page has the same effect as clicking the next button */ - moveNext?(): void; - /** [Method] Move to the previous page has the same effect as clicking the previous button */ - movePrevious?(): void; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Unbinds the paging toolbar from the specified Ext data Store deprecated - * @param store Ext.data.IStore The data store to unbind - */ - unbind?( store?:Ext.data.IStore ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.toolbar { - export interface ISeparator extends Ext.toolbar.IItem { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Number/String/Boolean) Force border: true so container border is not set on this Specifies the border size for this component. ... */ - border?: any; - } -} -declare module Ext.toolbar { - export interface ISpacer extends Ext.IComponent { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - } -} -declare module Ext.toolbar { - export interface ITextItem extends Ext.toolbar.IItem { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String) The text to be used as innerHTML (html tags are accepted). ... */ - text?: string; - /** [Method] Updates this item s text setting the text to be used as innerHTML - * @param text String The text to display (html accepted). - */ - setText?( text?:string ): void; - } -} -declare module Ext.toolbar { - export interface IToolbar extends Ext.container.IContainer { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Boolean) Configure true to make the toolbar provide a button which activates a dropdown Menu to show items which overflow the ... */ - enableOverflow?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) This class assigns a default layout (layout: 'hbox'). ... */ - layout?: any; - /** [Config Option] (String) Configure the icon class of the overflow button. ... */ - menuTriggerCls?: string; - /** [Config Option] (Boolean) Set to true to make the toolbar vertical. ... */ - vertical?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Toolbar, or subclass thereof. ... */ - isToolbar?: boolean; - /** [Method] Adds element s to the toolbar this function takes a variable number of arguments of mixed type and adds them to t - * @param args any The following types of arguments are all valid: config: A valid button config object HtmlElement: Any standard HTML element Field: Any form field Item: Any subclass of Ext.toolbar.Item String: Any generic string (gets wrapped in a Ext.toolbar.TextItem). Note that there are a few special strings that are treated differently as explained next: '-': Creates a separator element ' ': Creates a spacer element '->': Creates a fill element - */ - add?( args?:any ): any; - /** [Method] Used by ComponentQuery child and down to retrieve all of the items which can potentially be considered a child of th - * @param deep Object - */ - getRefItems?( deep?:any ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Inserts a Component into this Container at a specified index - * @param index Number The index at which the Component will be inserted. - * @param component any See add method for overview of possible values. - */ - insert?( index?:number, component?:any ): Ext.IComponent; - /** [Method] This method is invoked after a new Component has been added - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] This method is invoked before adding a new child Component - * @param item Ext.IComponent - */ - onBeforeAdd?( item?:Ext.IComponent ): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - } -} -declare module Ext { - export interface IToolbar extends Ext.container.IContainer { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String) */ - defaultButtonUI?: string; - /** [Config Option] (String) The default xtype of child Components to create in this Container when a child item is specified as a raw configurati... */ - defaultType?: string; - /** [Config Option] (Boolean) Configure true to make the toolbar provide a button which activates a dropdown Menu to show items which overflow the ... */ - enableOverflow?: boolean; - /** [Config Option] (Ext.enums.Layout/Object) This class assigns a default layout (layout: 'hbox'). ... */ - layout?: any; - /** [Config Option] (String) Configure the icon class of the overflow button. ... */ - menuTriggerCls?: string; - /** [Config Option] (Boolean) Set to true to make the toolbar vertical. ... */ - vertical?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Toolbar, or subclass thereof. ... */ - isToolbar?: boolean; - /** [Method] Adds element s to the toolbar this function takes a variable number of arguments of mixed type and adds them to t - * @param args any The following types of arguments are all valid: config: A valid button config object HtmlElement: Any standard HTML element Field: Any form field Item: Any subclass of Ext.toolbar.Item String: Any generic string (gets wrapped in a Ext.toolbar.TextItem). Note that there are a few special strings that are treated differently as explained next: '-': Creates a separator element ' ': Creates a spacer element '->': Creates a fill element - */ - add?( args?:any ): any; - /** [Method] Used by ComponentQuery child and down to retrieve all of the items which can potentially be considered a child of th - * @param deep Object - */ - getRefItems?( deep?:any ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Inserts a Component into this Container at a specified index - * @param index Number The index at which the Component will be inserted. - * @param component any See add method for overview of possible values. - */ - insert?( index?:number, component?:any ): Ext.IComponent; - /** [Method] This method is invoked after a new Component has been added - * @param component Ext.IComponent - * @param position Number - */ - onAdd?( component?:Ext.IComponent, position?:number ): void; - /** [Method] This method is invoked before adding a new child Component - * @param item Ext.IComponent - */ - onBeforeAdd?( item?:Ext.IComponent ): void; - /** [Method] This method is invoked after a new Component has been removed - * @param component Ext.IComponent - * @param autoDestroy Boolean - */ - onRemove?( component?:Ext.IComponent, autoDestroy?:boolean ): void; - } -} -declare module Ext.tree { - export interface IColumn extends Ext.grid.column.IColumn { - /** [Config Option] (Boolean) False to prevent the user from hiding this column. ... */ - hideable?: boolean; - /** [Config Option] (Boolean) If the grid is configured with enableLocking, or has columns which are configured with a locked value, this option ma... */ - lockable?: boolean; - /** [Config Option] (String) A CSS class names to apply to the table cells for this column. ... */ - tdCls?: string; - /** [Property] (Boolean) Indicates whether or not the component can be dragged. ... */ - draggable?: boolean; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - } -} -declare module Ext.tree { - export interface IPanel extends Ext.panel.ITable { - /** [Config Option] (Boolean) True to enable animated expand/collapse. ... */ - animate?: boolean; - /** [Config Option] (Boolean) Defaults to true to enable deferred row rendering. ... */ - deferRowRender?: boolean; - /** [Config Option] (String) The field inside the model that will be used as the node's text. ... */ - displayField?: string; - /** [Config Option] (Boolean) */ - folderSort?: boolean; - /** [Config Option] (Boolean) */ - hideHeaders?: boolean; - /** [Config Option] (Boolean) False to disable tree lines. ... */ - lines?: boolean; - /** [Config Option] (Ext.data.Model/Ext.data.NodeInterface/Object) Allows you to not specify a store on this TreePanel. ... */ - root?: any; - /** [Config Option] (Boolean) False to hide the root node. ... */ - rootVisible?: boolean; - /** [Config Option] (Boolean) False so that rows are not separated by lines. ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of selection model to use. ... */ - selType?: string; - /** [Config Option] (Boolean) True if only 1 node per branch may be expanded. ... */ - singleExpand?: boolean; - /** [Config Option] (Ext.data.TreeStore) */ - store?: Ext.data.ITreeStore; - /** [Config Option] (Boolean) True to use Vista-style arrows in the tree. ... */ - useArrows?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Collapse all nodes - * @param callback Function A function to execute when the collapse finishes. - * @param scope Object The scope of the callback function - */ - collapseAll?( callback?:any, scope?:any ): void; - /** [Method] Collapses a record that is loaded in the tree - * @param record Ext.data.IModel The record to collapse - * @param deep Boolean True to collapse nodes all the way up the tree hierarchy. - * @param callback Function The function to run after the collapse is completed - * @param scope Object The scope of the callback function. - */ - collapseNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand all nodes - * @param callback Function A function to execute when the expand finishes. - * @param scope Object The scope of the callback function - */ - expandAll?( callback?:any, scope?:any ): void; - /** [Method] Expands a record that is loaded in the tree - * @param record Ext.data.IModel The record to expand - * @param deep Boolean True to expand nodes all the way down the tree hierarchy. - * @param callback Function The function to run after the expand is completed - * @param scope Object The scope of the callback function. - */ - expandNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand the tree to the path of a particular node - * @param path String The path to expand. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the expand finishes. The callback will be called with (success, lastNode) where success is if the expand was successful and lastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - expandPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Retrieve an array of checked records */ - getChecked?(): Ext.data.INodeInterface[]; - /** [Method] Returns the root node for this tree */ - getRootNode?(): Ext.data.INodeInterface; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Expand the tree to the path of a particular node then select it - * @param path String The path to select. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the select finishes. The callback will be called with (bSuccess, oLastNode) where bSuccess is if the select was successful and oLastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - selectPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Sets root node of this tree - * @param root any - */ - setRootNode?( root?:any ): Ext.data.INodeInterface; - } -} -declare module Ext { - export interface ITreePanel extends Ext.panel.ITable { - /** [Config Option] (Boolean) True to enable animated expand/collapse. ... */ - animate?: boolean; - /** [Config Option] (Boolean) Defaults to true to enable deferred row rendering. ... */ - deferRowRender?: boolean; - /** [Config Option] (String) The field inside the model that will be used as the node's text. ... */ - displayField?: string; - /** [Config Option] (Boolean) */ - folderSort?: boolean; - /** [Config Option] (Boolean) */ - hideHeaders?: boolean; - /** [Config Option] (Boolean) False to disable tree lines. ... */ - lines?: boolean; - /** [Config Option] (Ext.data.Model/Ext.data.NodeInterface/Object) Allows you to not specify a store on this TreePanel. ... */ - root?: any; - /** [Config Option] (Boolean) False to hide the root node. ... */ - rootVisible?: boolean; - /** [Config Option] (Boolean) False so that rows are not separated by lines. ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of selection model to use. ... */ - selType?: string; - /** [Config Option] (Boolean) True if only 1 node per branch may be expanded. ... */ - singleExpand?: boolean; - /** [Config Option] (Ext.data.TreeStore) */ - store?: Ext.data.ITreeStore; - /** [Config Option] (Boolean) True to use Vista-style arrows in the tree. ... */ - useArrows?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Collapse all nodes - * @param callback Function A function to execute when the collapse finishes. - * @param scope Object The scope of the callback function - */ - collapseAll?( callback?:any, scope?:any ): void; - /** [Method] Collapses a record that is loaded in the tree - * @param record Ext.data.IModel The record to collapse - * @param deep Boolean True to collapse nodes all the way up the tree hierarchy. - * @param callback Function The function to run after the collapse is completed - * @param scope Object The scope of the callback function. - */ - collapseNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand all nodes - * @param callback Function A function to execute when the expand finishes. - * @param scope Object The scope of the callback function - */ - expandAll?( callback?:any, scope?:any ): void; - /** [Method] Expands a record that is loaded in the tree - * @param record Ext.data.IModel The record to expand - * @param deep Boolean True to expand nodes all the way down the tree hierarchy. - * @param callback Function The function to run after the expand is completed - * @param scope Object The scope of the callback function. - */ - expandNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand the tree to the path of a particular node - * @param path String The path to expand. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the expand finishes. The callback will be called with (success, lastNode) where success is if the expand was successful and lastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - expandPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Retrieve an array of checked records */ - getChecked?(): Ext.data.INodeInterface[]; - /** [Method] Returns the root node for this tree */ - getRootNode?(): Ext.data.INodeInterface; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Expand the tree to the path of a particular node then select it - * @param path String The path to select. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the select finishes. The callback will be called with (bSuccess, oLastNode) where bSuccess is if the select was successful and oLastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - selectPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Sets root node of this tree - * @param root any - */ - setRootNode?( root?:any ): Ext.data.INodeInterface; - } -} -declare module Ext.tree { - export interface ITreePanel extends Ext.panel.ITable { - /** [Config Option] (Boolean) True to enable animated expand/collapse. ... */ - animate?: boolean; - /** [Config Option] (Boolean) Defaults to true to enable deferred row rendering. ... */ - deferRowRender?: boolean; - /** [Config Option] (String) The field inside the model that will be used as the node's text. ... */ - displayField?: string; - /** [Config Option] (Boolean) */ - folderSort?: boolean; - /** [Config Option] (Boolean) */ - hideHeaders?: boolean; - /** [Config Option] (Boolean) False to disable tree lines. ... */ - lines?: boolean; - /** [Config Option] (Ext.data.Model/Ext.data.NodeInterface/Object) Allows you to not specify a store on this TreePanel. ... */ - root?: any; - /** [Config Option] (Boolean) False to hide the root node. ... */ - rootVisible?: boolean; - /** [Config Option] (Boolean) False so that rows are not separated by lines. ... */ - rowLines?: boolean; - /** [Config Option] (String) An xtype of selection model to use. ... */ - selType?: string; - /** [Config Option] (Boolean) True if only 1 node per branch may be expanded. ... */ - singleExpand?: boolean; - /** [Config Option] (Ext.data.TreeStore) */ - store?: Ext.data.ITreeStore; - /** [Config Option] (Boolean) True to use Vista-style arrows in the tree. ... */ - useArrows?: boolean; - /** [Config Option] (String) An xtype of view to use. ... */ - viewType?: string; - /** [Method] Collapse all nodes - * @param callback Function A function to execute when the collapse finishes. - * @param scope Object The scope of the callback function - */ - collapseAll?( callback?:any, scope?:any ): void; - /** [Method] Collapses a record that is loaded in the tree - * @param record Ext.data.IModel The record to collapse - * @param deep Boolean True to collapse nodes all the way up the tree hierarchy. - * @param callback Function The function to run after the collapse is completed - * @param scope Object The scope of the callback function. - */ - collapseNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand all nodes - * @param callback Function A function to execute when the expand finishes. - * @param scope Object The scope of the callback function - */ - expandAll?( callback?:any, scope?:any ): void; - /** [Method] Expands a record that is loaded in the tree - * @param record Ext.data.IModel The record to expand - * @param deep Boolean True to expand nodes all the way down the tree hierarchy. - * @param callback Function The function to run after the expand is completed - * @param scope Object The scope of the callback function. - */ - expandNode?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expand the tree to the path of a particular node - * @param path String The path to expand. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the expand finishes. The callback will be called with (success, lastNode) where success is if the expand was successful and lastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - expandPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Retrieve an array of checked records */ - getChecked?(): Ext.data.INodeInterface[]; - /** [Method] Returns the root node for this tree */ - getRootNode?(): Ext.data.INodeInterface; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Expand the tree to the path of a particular node then select it - * @param path String The path to select. The path should include a leading separator. - * @param field String The field to get the data from. Defaults to the model idProperty. - * @param separator String A separator to use. - * @param callback Function A function to execute when the select finishes. The callback will be called with (bSuccess, oLastNode) where bSuccess is if the select was successful and oLastNode is the last node that was expanded. - * @param scope Object The scope of the callback function - */ - selectPath?( path?:string, field?:string, separator?:string, callback?:any, scope?:any ): void; - /** [Method] Sets root node of this tree - * @param root any - */ - setRootNode?( root?:any ): Ext.data.INodeInterface; - } -} -declare module Ext.tree.plugin { - export interface ITreeViewDragDrop extends Ext.IAbstractPlugin { - /** [Config Option] (Boolean) True if drops on the tree container (outside of a specific tree node) are allowed. ... */ - allowContainerDrops?: boolean; - /** [Config Option] (Boolean) Allow inserting a dragged node between an expanded parent node and its first child that will become a sibling of the ... */ - allowParentInserts?: boolean; - /** [Config Option] (Boolean) True if the tree should only allow append drops (use for trees which are sorted). ... */ - appendOnly?: boolean; - /** [Config Option] (Object/Boolean) True to register this container with the Scrollmanager for auto scrolling during drag operations. ... */ - containerScroll?: any; - /** [Config Option] (String) A named drag drop group to which this object belongs. ... */ - ddGroup?: string; - /** [Config Option] (String) The name of the model field that is used to display the text for the nodes ... */ - displayField?: string; - /** [Config Option] (String) The ddGroup to which the DragZone will belong. ... */ - dragGroup?: string; - /** [Config Option] (String) The text to show while dragging. ... */ - dragText?: string; - /** [Config Option] (String) The ddGroup to which the DropZone will belong. ... */ - dropGroup?: string; - /** [Config Option] (Boolean) Set to false to disallow dragging items from the View. ... */ - enableDrag?: boolean; - /** [Config Option] (Boolean) Set to false to disallow the View from accepting drop gestures. ... */ - enableDrop?: boolean; - /** [Config Option] (String) The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node over the target. ... */ - expandDelay?: string; - /** [Config Option] (String) The color to use when visually highlighting the dragged or dropped node (default value is light blue). ... */ - nodeHighlightColor?: string; - /** [Config Option] (Boolean) Whether or not to highlight any nodes after they are successfully dropped on their target. ... */ - nodeHighlightOnDrop?: boolean; - /** [Config Option] (Boolean) Whether or not to highlight any nodes after they are repaired from an unsuccessful drag/drop. ... */ - nodeHighlightOnRepair?: boolean; - /** [Config Option] (Boolean) Configure as true to sort the target node into the current tree sort order after the dropped node is added. ... */ - sortOnDrop?: boolean; - /** [Method] The init method is invoked after initComponent method has been run for the client Component - * @param client Ext.IComponent The client Component which owns this plugin. - */ - init?( client?:Ext.IComponent ): void; - } -} -declare module Ext.tree { - export interface IView extends Ext.view.ITable { - /** [Config Option] (Boolean) */ - animate?: boolean; - /** [Config Option] (Boolean) Set this to true to ignore refresh events on the bound store. ... */ - blockRefresh?: boolean; - /** [Config Option] (Boolean) Must be false for Tree Views because the root node must be rendered in order to be updated with its child nodes. ... */ - deferInitialRefresh?: boolean; - /** [Config Option] (Boolean/Object) False to disable a load mask from displaying while the view is loading. ... */ - loadMask?: any; - /** [Config Option] (String) The CSS class to apply to the loading message element. ... */ - loadingCls?: string; - /** [Config Option] (Boolean) False to hide the root node. ... */ - rootVisible?: boolean; - /** [Config Option] (Boolean) True to stripe the rows. ... */ - stripeRows?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated TreeView, or subclass thereof. ... */ - isTreeView?: boolean; - /** [Method] Called by the layout system after the Component has been laid out - * @param width Number The width that was set - * @param height Number The height that was set - * @param oldWidth Number The old width, or undefined if this was the initial layout. - * @param oldHeight Number The old height, or undefined if this was the initial layout. - */ - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:number ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:number, oldHeight?:any ): void; - afterComponentLayout?( width?:number, height?:number, oldWidth?:any, oldHeight?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Collapses a record that is loaded in the view - * @param record Ext.data.IModel The record to collapse - * @param deep Boolean True to collapse nodes all the way up the tree hierarchy. - * @param callback Function The function to run after the collapse is completed - * @param scope Object The scope of the callback function. - */ - collapse?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Expands a record that is loaded in the view - * @param record Ext.data.IModel The record to expand - * @param deep Boolean True to expand nodes all the way down the tree hierarchy. - * @param callback Function The function to run after the expand is completed - * @param scope Object The scope of the callback function. - */ - expand?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Gets the base TreeStore from the bound TreePanel */ - getTreeStore?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Toggles a record between expanded and collapsed - * @param record Ext.data.IModel - * @param deep Boolean True to collapse nodes all the way up the tree hierarchy. - * @param callback Function The function to run after the expand/collapse is completed - * @param scope Object The scope of the callback function. - */ - toggle?( record?:Ext.data.IModel, deep?:boolean, callback?:any, scope?:any ): void; - } -} -declare module Ext.tree { - export interface IViewDragZone extends Ext.view.IDragZone { - } -} -declare module Ext.tree { - export interface IViewDropZone extends Ext.view.IDropZone { - /** [Config Option] (String) */ - allowContainerDrop?: string; - /** [Config Option] (Boolean) Allow inserting a dragged node between an expanded parent node and its first child that will become a sibling of the ... */ - allowParentInserts?: boolean; - /** [Config Option] (String) True if the tree should only allow append drops (use for trees which are sorted). ... */ - appendOnly?: string; - /** [Config Option] (String) The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node over the target. ... */ - expandDelay?: string; - /** [Method] The function a Ext dd DragSource calls once to notify this drop zone that the source has been dragged out of the zone - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag zone - */ - notifyOut?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called while the DropZone determines that a Ext dd DragSource is being dragged over it but not over any of its regis - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onContainerOver?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] The mouse is no longer over a tree node so dropping is not valid Called when the DropZone determines that a Ext dd - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOut?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called while the DropZone determines that a Ext dd DragSource is over a drop node that has either been registered or - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOver?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - } -} -declare module Ext.util { - export interface IAbstractMixedCollection extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Boolean) Specify true if the addAll function should add function references to the collection. ... */ - allowFunctions?: boolean; - /** [Property] (Boolean) true in this class to identify an object as an instantiated MixedCollection, or subclass thereof. ... */ - isMixedCollection?: boolean; - /** [Method] Adds an item to the collection - * @param key any The key to associate with the item, or the new item. If a getKey implementation was specified for this MixedCollection, or if the key of the stored items is in a property called id, the MixedCollection will be able to derive the key for the new item. In this case just pass the new item in this parameter. - * @param obj Object The item to add. - */ - add?( key?:any, obj?:any ): any; - /** [Method] Adds all elements of an Array or an Object to the collection - * @param objs any An Object containing properties which will be added to the collection, or an Array of values, each of which are added to the collection. Functions references will be added to the collection if allowFunctions has been set to true. - */ - addAll?( objs?:any ): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all items from the collection */ - clear?(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Creates a shallow copy of this collection */ - clone?(): Ext.util.IMixedCollection; - /** [Method] Collects unique values of a particular property in this MixedCollection - * @param property String The property to collect on - * @param root String 'root' property to extract the first argument from. This is used mainly when summing fields in records, where the fields are all stored inside the 'data' object - * @param allowBlank Boolean Pass true to allow null, undefined or empty string values - */ - collect?( property?:string, root?:string, allowBlank?:boolean ): any[]; - /** [Method] Returns true if the collection contains the passed Object as an item - * @param o Object The Object to look for in the collection. - */ - contains?( o?:any ): boolean; - /** [Method] Returns true if the collection contains the passed Object as a key - * @param key String The key to look for in the collection. - */ - containsKey?( key?:string ): boolean; - /** [Method] Executes the specified function once for every item in the collection - * @param fn Function The function to execute for each item. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current item in the iteration. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Executes the specified function once for every key in the collection passing each key and its associated item as th - * @param fn Function The function to execute for each item. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - eachKey?( fn?:any, scope?:any ): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Filters the objects in this collection by a set of Filters or by a single property value pair with optional paramete - * @param property any A property on your objects, or an array of Filter objects - * @param value any Either string that the property values should start with or a RegExp to test against the property - * @param anyMatch any True to match any part of the string, not just the beginning - * @param caseSensitive any True for case sensitive comparison. - */ - filter?( property?:any, value?:any, anyMatch?:any, caseSensitive?:any ): any; - filter?( property?:Ext.util.IFilter[], value?:string, anyMatch?:boolean, caseSensitive?:boolean ): Ext.util.IMixedCollection; - filter?( property?:string, value?:string, anyMatch?:boolean, caseSensitive?:boolean ): Ext.util.IMixedCollection; - filter?( property?:Ext.util.IFilter[], value?:RegExp, anyMatch?:boolean, caseSensitive?:boolean ): Ext.util.IMixedCollection; - filter?( property?:string, value?:RegExp, anyMatch?:boolean, caseSensitive?:boolean ): Ext.util.IMixedCollection; - /** [Method] Filter by a function - * @param fn Function The function to be called. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to this MixedCollection. - */ - filterBy?( fn?:any, scope?:any ): Ext.util.IMixedCollection; - /** [Method] Returns the first item in the collection which elicits a true return value from the passed selection function - * @param fn Function The selection function to execute for each item. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - findBy?( fn?:any, scope?:any ): any; - /** [Method] Finds the index of the first matching object in this collection by a specific property value - * @param property any The name of a property on your objects. - * @param value any A string that the property values should start with or a RegExp to test against the property. - * @param start any The index to start searching at. - * @param anyMatch any True to match any part of the string, not just the beginning. - * @param caseSensitive any True for case sensitive comparison. - */ - findIndex?( property?:any, value?:any, start?:any, anyMatch?:any, caseSensitive?:any ): any; - findIndex?( property?:string, value?:string, start?:number, anyMatch?:boolean, caseSensitive?:boolean ): number; - findIndex?( property?:string, value?:RegExp, start?:number, anyMatch?:boolean, caseSensitive?:boolean ): number; - /** [Method] Find the index of the first matching object in this collection by a function - * @param fn Function The function to be called. - * @param scope Object The scope (this reference) in which the function is executed. Defaults to this MixedCollection. - * @param start Number The index to start searching at. - */ - findIndexBy?( fn?:any, scope?:any, start?:number ): number; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Returns the first item in the collection */ - first?(): any; - /** [Method] Returns the item associated with the passed key OR index - * @param key any The key or index of the item. - */ - get?( key?:any ): any; - get?( key?:string ): any; - get?( key?:number ): any; - /** [Method] Returns the item at the specified index - * @param index Number The index of the item. - */ - getAt?( index?:number ): any; - /** [Method] Returns the item associated with the passed key - * @param key any The key of the item. - */ - getByKey?( key?:any ): any; - getByKey?( key?:string ): any; - getByKey?( key?:number ): any; - /** [Method] Returns the number of items in the collection */ - getCount?(): number; - /** [Method] A function which will be called passing a newly added object when the object is added without a separate id - * @param item Object The item for which to find the key. - */ - getKey?( item?:any ): any; - /** [Method] Returns a range of items in this collection - * @param startIndex Number The starting index. Defaults to 0. - * @param endIndex Number The ending index. Defaults to the last item. - */ - getRange?( startIndex?:number, endIndex?:number ): any[]; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Returns index within the collection of the passed Object - * @param o Object The item to find the index of. - */ - indexOf?( o?:any ): number; - /** [Method] Returns index within the collection of the passed key - * @param key String The key to find the index of. - */ - indexOfKey?( key?:string ): number; - /** [Method] Inserts an item at the specified index in the collection - * @param index Number The index to insert the item at. - * @param key any The key to associate with the new item, or the item itself. May also be an array of either to insert multiple items at once. - * @param o any If the second parameter was a key, the new item. May also be an array to insert multiple items at once. - */ - insert?( index?:number, key?:any, o?:any ): any; - /** [Method] Returns the last item in the collection */ - last?(): any; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Remove an item from the collection - * @param o Object The item to remove. - */ - remove?( o?:any ): any; - /** [Method] Remove all items in the collection - * @param items Array An array of items to be removed. - */ - removeAll?( items?:any[] ): Ext.util.IMixedCollection; - /** [Method] Remove an item from a specified index in the collection - * @param index Number The index within the collection of the item to remove. - */ - removeAt?( index?:number ): any; - /** [Method] Removes an item associated with the passed key fom the collection - * @param key String The key of the item to remove. If null is passed, all objects which yielded no key from the configured getKey function are removed. - */ - removeAtKey?( key?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Remove a range of items starting at a specified index in the collection - * @param index Number The index within the collection of the item to remove. - * @param removeCount Number The nuber of items to remove beginning at the specified index. - */ - removeRange?( index?:number, removeCount?:number ): any; - /** [Method] Replaces an item in the collection - * @param key String The key associated with the item to replace, or the replacement item. If you supplied a getKey implementation for this MixedCollection, or if the key of your stored items is in a property called id, then the MixedCollection will be able to derive the key of the replacement item. If you want to replace an item with one having the same key value, then just pass the replacement item in this parameter. - * @param o Object {Object} o (optional) If the first parameter passed was a key, the item to associate with that key. - */ - replace?( key?:string, o?:any ): any; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Collects all of the values of the given property and returns their sum - * @param property String The property to sum by - * @param root String 'root' property to extract the first argument from. This is used mainly when summing fields in records, where the fields are all stored inside the 'data' object - * @param start Number The record index to start at - * @param end Number The record index to end at - */ - sum?( property?:string, root?:string, start?:number, end?:number ): number; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Change the key for an existing item in the collection - * @param oldKey Object The old key - * @param newKey Object The new key - */ - updateKey?( oldKey?:any, newKey?:any ): void; - } -} -declare module Ext.util { - export interface IAnimate extends Ext.IBase { - /** [Method] Performs custom animation on this object. ... */ - animate?: any; - /** [Method] Returns the current animation if this object has any effects actively running or queued else returns false */ - getActiveAnimation?(): any; - /** [Method] Ensures that all effects queued after sequenceFx is called on this object are run in sequence */ - sequenceFx?(): any; - /** [Method] Stops any running effects and clears this object s internal effects queue if it contains any additional effects that */ - stopAnimation?(): Ext.IElement; - /** [Method] Ensures that all effects queued after syncFx is called on this object are run concurrently */ - syncFx?(): any; - } -} -declare module Ext.util { - export interface IBindable extends Ext.IBase { - /** [Method] Binds a store to this instance - * @param store Ext.data.IAbstractStore The store to bind or ID of the store. When no store given (or when null or undefined passed), unbinds the existing store. - */ - bindStore?( store?:Ext.data.IAbstractStore ): void; - bindStore?( store?:string ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Gets the current store instance */ - getStore?(): Ext.data.IAbstractStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.util { - export interface IClickRepeater extends Ext.util.IObservable { - /** [Config Option] (Boolean) True if autorepeating should start slowly and accelerate. ... */ - accelerate?: boolean; - /** [Config Option] (Number) The initial delay before the repeating event begins firing. ... */ - delay?: number; - /** [Config Option] (String/HTMLElement/Ext.Element) */ - el?: any; - /** [Config Option] (Number) The interval between firings of the "click" event (in milliseconds). ... */ - interval?: number; - /** [Config Option] (String) */ - pressedCls?: string; - /** [Config Option] (Boolean) True to prevent the default click event ... */ - preventDefault?: boolean; - /** [Config Option] (Boolean) True to stop the default click event ... */ - stopDefault?: boolean; - /** [Method] Disables the repeater and stops events from firing - * @param force Object - */ - disable?( force?:any ): void; - /** [Method] Enables the repeater and allows events to fire */ - enable?(): void; - /** [Method] Convenience function for setting disabled enabled by boolean - * @param disabled Boolean - */ - setDisabled?( disabled?:boolean ): void; - } -} -declare module Ext.util { - export interface IComponentDragger extends Ext.dd.IDragTracker { - /** [Config Option] (Boolean) */ - constrain?: boolean; - /** [Config Option] (Boolean) */ - constrainDelegate?: boolean; - /** [Method] Move either the ghost Component or the target Component to its new position on drag Template method which should be - * @param e Ext.IEventObject The event object - */ - onDrag?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onEnd?( e?:Ext.IEventObject ): void; - /** [Method] Template method which should be overridden by each DragTracker instance - * @param e Ext.IEventObject The event object - */ - onStart?( e?:Ext.IEventObject ): void; - } -} -declare module Ext.util { - export interface ICookies extends Ext.IBase { - } - export class Cookies { - /** [Method] Removes a cookie with the provided name from the browser if found by setting its expiration date to sometime in the p - * @param name String The name of the cookie to remove - * @param path String The path for the cookie. This must be included if you included a path while setting the cookie. - */ - static clear( name?:string, path?:string ): void; - /** [Method] Retrieves cookies that are accessible by the current page - * @param name String The name of the cookie to get - */ - static get( name?:string ): any; - /** [Method] Creates a cookie with the specified name and value - * @param name String The name of the cookie to set. - * @param value Object The value to set for the cookie. - * @param expires Object Specify an expiration date the cookie is to persist until. Note that the specified Date object will be converted to Greenwich Mean Time (GMT). - * @param path String Setting a path on the cookie restricts access to pages that match that path. Defaults to all pages ('/'). - * @param domain String Setting a domain restricts access to pages on a given domain (typically used to allow cookie access across subdomains). For example, "sencha.com" will create a cookie that can be accessed from any subdomain of sencha.com, including www.sencha.com, support.sencha.com, etc. - * @param secure Boolean Specify true to indicate that the cookie should only be accessible via SSL on a page using the HTTPS protocol. Defaults to false. Note that this will only work if the page calling this code uses the HTTPS protocol, otherwise the cookie will be created with default options. - */ - static set( name?:string, value?:any, expires?:any, path?:string, domain?:string, secure?:boolean ): void; - } -} -declare module Ext.util { - export interface ICSS extends Ext.IBase { - } - export class CSS { - /** [Method] Creates a rule - * @param styleSheet CSSStyleSheet The StyleSheet to create the rule in as returned from createStyleSheet. - * @param selector String The selector to target the rule. - * @param property String The cssText specification eg "color:red;font-weight:bold;text-decoration:underline" - */ - static createRule( styleSheet?:CSSStyleSheet, selector?:string, property?:string ): CSSStyleRule; - /** [Method] Creates a stylesheet from a text blob of rules - * @param cssText String The text containing the css rules - * @param id String An id to add to the stylesheet for later removal - */ - static createStyleSheet( cssText?:string, id?:string ): CSSStyleSheet; - /** [Method] Gets an an individual CSS rule by selector s - * @param selector any The CSS selector or an array of selectors to try. The first selector that is found is returned. - * @param refreshCache any true to refresh the internal cache if you have recently updated any rules or added styles dynamically - */ - static getRule( selector?:any, refreshCache?:any ): any; - static getRule( selector?:string, refreshCache?:boolean ): CSSStyleRule; - static getRule( selector?:string[], refreshCache?:boolean ): CSSStyleRule; - /** [Method] Gets all css rules for the document - * @param refreshCache Boolean true to refresh the internal cache - */ - static getRules( refreshCache?:boolean ): any; - /** [Method] Refresh the rule cache if you have dynamically added stylesheets */ - static refreshCache(): any; - /** [Method] Removes a style or link tag by id - * @param id String The id of the tag - */ - static removeStyleSheet( id?:string ): void; - /** [Method] Dynamically swaps an existing stylesheet reference for a new one - * @param id String The id of an existing link tag to remove - * @param url String The href of the new stylesheet to include - */ - static swapStyleSheet( id?:string, url?:string ): void; - /** [Method] Updates a rule property - * @param selector any If it's an array it tries each selector until it finds one. Stops immediately once one is found. - * @param property any The css property or a cssText specification eg "color:red;font-weight:bold;text-decoration:underline" - * @param value any The new value for the property - */ - static updateRule( selector?:any, property?:any, value?:any ): any; - static updateRule( selector?:string, property?:string, value?:string ): boolean; - static updateRule( selector?:string[], property?:string, value?:string ): boolean; - } -} -declare module Ext.util { - export interface IDelayedTask { - /** [Method] Cancel the last queued timeout */ - cancel?(): void; - /** [Method] By default cancels any pending timeout and queues a new one - * @param newDelay Number The milliseconds to delay - * @param newFn Function Overrides function passed to constructor - * @param newScope Object Overrides scope passed to constructor. Remember that if no scope is specified, this will refer to the browser window. - * @param newArgs Array Overrides args passed to constructor - */ - delay?( newDelay?:number, newFn?:any, newScope?:any, newArgs?:any[] ): void; - } -} -declare module Ext.util { - export interface IElementContainer extends Ext.IBase { - /** [Method] Adds each argument passed to this method to the childEls array */ - addChildEls?(): void; - /** [Method] Removes items in the childEls array based on the return value of a supplied test function - * @param testFn Function The test function. - */ - removeChildEls?( testFn?:any ): void; - } -} -declare module Ext.util { - export interface IEvent extends Ext.IBase { - /** [Property] (Boolean) true in this class to identify an object as an instantiated Event, or subclass thereof. ... */ - isEvent?: boolean; - } -} -declare module Ext.util { - export interface IFilter extends Ext.IBase { - /** [Config Option] (Boolean) True to allow any match - no regex start/end line anchors will be added. ... */ - anyMatch?: boolean; - /** [Config Option] (Boolean) True to make the regex case sensitive (adds 'i' switch to regex). ... */ - caseSensitive?: boolean; - /** [Config Option] (Boolean) True to force exact match (^ and $ characters added to the regex). ... */ - exactMatch?: boolean; - /** [Config Option] (Function) A custom filter function which is passed each item in the Ext.util.MixedCollection in turn. ... */ - filterFn?: any; - /** [Config Option] (String) An identifier by which this Filter is indexed in a Store's filters collection Identified Filters may be individually... */ - id?: string; - /** [Config Option] (String) The operator to use to compare the property to this Filter's value Possible values are: * < * <= * = ... */ - operator?: string; - /** [Config Option] (String) The property to filter on. ... */ - property?: string; - /** [Config Option] (String) Optional root property. ... */ - root?: string; - /** [Config Option] (Mixed) The value to filter on. ... */ - value?: any; - /** [Property] (Boolean) Setting this property to true disables this individual Filter so that it no longer contributes to a Store's filter se... */ - disabled?: boolean; - /** [Method] Changes the filtering function which this Filter uses to choose items to include - * @param filterFn Function A function which returns true or false to either include or exclude the passed object. - */ - setFilterFn?( filterFn?:any ): void; - /** [Method] Changes the value that this filter tests its configured link cfg property with - * @param value Mixed The new value to compare the property with. - */ - setValue?( value?:any ): void; - } -} -declare module Ext.util { - export interface IFloating extends Ext.IBase { - /** [Config Option] (Boolean) True to constrain this Components within its containing element, false to allow it to fall outside of its containing ... */ - constrain?: boolean; - /** [Config Option] (Boolean) Configure as true to have this Component fixed at its X, Y coordinates in the browser viewport, immune to scrolling t... */ - fixed?: boolean; - /** [Config Option] (Boolean) Specifies whether the floated component should be automatically focused when it is brought to the front. ... */ - focusOnToFront?: boolean; - /** [Config Option] (String/Boolean) Specifies whether the floating component should be given a shadow. ... */ - shadow?: any; - /** [Config Option] (Number) */ - shadowOffset?: number; - /** [Method] Center this Component in its container */ - center?(): Ext.IComponent; - /** [Method] Moves this floating Component into a constrain region - * @param constrainTo String The Element or Region into which this Component is to be constrained. Defaults to the element into which this floating Component was rendered. - */ - doConstrain?( constrainTo?:string ): void; - doConstrain?( constrainTo?:HTMLElement ): void; - doConstrain?( constrainTo?:Ext.IElement ): void; - doConstrain?( constrainTo?:Ext.util.IRegion ): void; - /** [Method] This method is called internally by Ext ZIndexManager to signal that a floating Component has either been moved to th - * @param active Boolean True to activate the Component, false to deactivate it. - * @param newActive Ext.IComponent The newly active Component which is taking over topmost zIndex position. - */ - setActive?( active?:boolean, newActive?:Ext.IComponent ): void; - /** [Method] Sends this Component to the back of lower z index than any other visible windows */ - toBack?(): Ext.IComponent; - /** [Method] Brings this floating Component to the front of any other visible floating Components managed by the same ZIndexManag - * @param preventFocus Boolean Specify true to prevent the Component from being focused. - */ - toFront?( preventFocus?:boolean ): Ext.IComponent; - } -} -declare module Ext.util { - export interface IFormat { - } - export class Format { - /** [Method] Formats an object of name value properties as HTML element attribute values suitable for using when creating textual - * @param attributes Object An object containing the HTML attributes as properties eg: {height:40, vAlign:'top'} - */ - static attributes( attributes?:any ): void; - /** [Method] Alias for Ext String capitalize - * @param string String - */ - static capitalize( string?:string ): string; - /** [Method] Format a number as a currency - * @param value any The numeric value to format - * @param sign any The currency sign to use (defaults to currencySign) - * @param decimals any The number of decimals to use for the currency (defaults to currencyPrecision) - * @param end any True if the currency sign should be at the end of the string (defaults to currencyAtEnd) - */ - static currency( value?:any, sign?:any, decimals?:any, end?:any ): any; - static currency( value?:number, sign?:string, decimals?:number, end?:boolean ): string; - static currency( value?:string, sign?:string, decimals?:number, end?:boolean ): string; - /** [Method] Formats the passed date using the specified format pattern - * @param value any The value to format. If a string is passed, it is converted to a Date by the Javascript's built-in Date.parse method. - * @param format any Any valid date format string. Defaults to Ext.Date.defaultFormat. - */ - static date( value?:any, format?:any ): any; - static date( value?:string, format?:string ): string; - static date( value?:any, format?:string ): string; - /** [Method] Returns a date rendering function that can be reused to apply a date format multiple times efficiently - * @param format String Any valid date format string. Defaults to Ext.Date.defaultFormat. - */ - static dateRenderer( format?:string ): any; - /** [Method] Checks a reference and converts it to the default value if it s empty - * @param value Object Reference to check - * @param defaultValue String The value to insert of it's undefined. - */ - static defaultValue( value?:any, defaultValue?:string ): string; - /** [Method] Alias for Ext String ellipsis - * @param value String The string to truncate. - * @param length Number The maximum length to allow before truncating. - * @param word Boolean true to try to find a common word break. - */ - static ellipsis( value?:string, length?:number, word?:boolean ): string; - /** [Method] Escapes the passed string for use in a regular expression - * @param str String - */ - static escapeRegex( str?:string ): string; - /** [Method] Simple format for a file size xxx bytes xxx KB xxx MB - * @param size any The numeric value to format - */ - static fileSize( size?:any ): any; - static fileSize( size?:number ): string; - static fileSize( size?:string ): string; - /** [Method] Alias for Ext String format - * @param string String The tokenized string to be formatted. - * @param values Mixed... The values to replace tokens {0}, {1}, etc in order. - */ - static format( string:string, ...values:any[] ): string; - /** [Method] Alias for Ext String htmlDecode - * @param value String The string to decode. - */ - static htmlDecode( value?:string ): string; - /** [Method] Alias for Ext String htmlEncode - * @param value String The string to encode. - */ - static htmlEncode( value?:string ): string; - /** [Method] Alias for Ext String leftPad - * @param string String The original string. - * @param size Number The total length of the output string. - * @param character String The character with which to pad the original string. - */ - static leftPad( string?:string, size?:number, character?:string ): string; - /** [Method] Converts a string to all lower case letters - * @param value String The text to convert - */ - static lowercase( value?:string ): string; - /** [Method] It does simple math for use in a template for example var tpl new Ext Template value 10 value math 10 */ - static math(): any; - /** [Method] Converts newline characters to the HTML tag lt br gt - * @param v String The string value to format. - */ - static nl2br( v?:string ): string; - /** [Method] Formats the passed number according to the passed format string - * @param v Number The number to format. - * @param format String The way you would like to format this text. - */ - static number( v?:number, format?:string ): string; - /** [Method] Returns a number rendering function that can be reused to apply a number format multiple times efficiently - * @param format String Any valid number format string for number - */ - static numberRenderer( format?:string ): any; - /** [Method] Parses a number or string representing margin sizes into an object - * @param v any The encoded margins - */ - static parseBox( v?:any ): any; - static parseBox( v?:number ): any; - static parseBox( v?:string ): any; - /** [Method] Selectively do a plural form of a word based on a numeric value - * @param value Number The value to compare against - * @param singular String The singular form of the word - * @param plural String The plural form of the word (defaults to the singular with an "s") - */ - static plural( value?:number, singular?:string, plural?:string ): void; - /** [Method] Rounds the passed number to the required decimal precision - * @param value any The numeric value to round. - * @param precision any The number of decimal places to which to round the first parameter's value. - */ - static round( value?:any, precision?:any ): any; - static round( value?:number, precision?:number ): number; - static round( value?:string, precision?:number ): number; - /** [Method] Strips all script tags - * @param value Object The text from which to strip script tags - */ - static stripScripts( value?:any ): string; - /** [Method] Strips all HTML tags - * @param value Object The text from which to strip tags - */ - static stripTags( value?:any ): string; - /** [Method] Returns a substring from within an original string - * @param value String The original text - * @param start Number The start index of the substring - * @param length Number The length of the substring - */ - static substr( value?:string, start?:number, length?:number ): string; - /** [Method] Alias for Ext String trim - * @param string String The string to trim. - */ - static trim( string?:string ): string; - /** [Method] Checks a reference and converts it to empty string if it is undefined - * @param value Object Reference to check - */ - static undef( value?:any ): any; - /** [Method] Converts a string to all upper case letters - * @param value String The text to convert - */ - static uppercase( value?:string ): string; - /** [Method] Format a number as US currency - * @param value any The numeric value to format - */ - static usMoney( value?:any ): any; - static usMoney( value?:number ): string; - static usMoney( value?:string ): string; - } -} -declare module Ext.util { - export interface IGrouper extends Ext.util.ISorter { - /** [Method] Returns the value for grouping to be used - * @param instance Ext.data.IModel The Model instance - */ - getGroupString?( instance?:Ext.data.IModel ): string; - } -} -declare module Ext.util { - export interface IHashMap extends Ext.IBase,Ext.util.IObservable { - /** [Config Option] (Function) A function that is used to retrieve a default key for a passed object. ... */ - keyFn?: any; - /** [Method] Adds an item to the collection - * @param key any The key to associate with the item, or the new item. If a getKey implementation was specified for this HashMap, or if the key of the stored items is in a property called id, the HashMap will be able to derive the key for the new item. In this case just pass the new item in this parameter. - * @param o Object The item to add. - */ - add?( key?:any, o?:any ): any; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all items from the hash - * @param initial Object - */ - clear?( initial?:any ): Ext.util.IHashMap; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Performs a shallow copy on this hash */ - clone?(): Ext.util.IHashMap; - /** [Method] Checks whether a value exists in the hash - * @param value Object The value to check for. - */ - contains?( value?:any ): boolean; - /** [Method] Checks whether a key exists in the hash - * @param key String The key to check for. - */ - containsKey?( key?:string ): boolean; - /** [Method] Executes the specified function once for each item in the hash - * @param fn Function The function to execute. - * @param scope Object The scope to execute in. Defaults to this. - */ - each?( fn?:any, scope?:any ): Ext.util.IHashMap; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Retrieves an item with a particular key - * @param key String The key to lookup. - */ - get?( key?:string ): any; - /** [Method] Gets the number of items in the hash */ - getCount?(): number; - /** [Method] Extracts the key from an object - * @param o Object The object to get the key from - */ - getKey?( o?:any ): string; - /** [Method] Return all of the keys in the hash */ - getKeys?(): any[]; - /** [Method] Return all of the values in the hash */ - getValues?(): any[]; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Remove an item from the hash - * @param o Object The value of the item to remove. - */ - remove?( o?:any ): boolean; - /** [Method] Remove an item from the hash - * @param key String The key to remove. - */ - removeAtKey?( key?:string ): boolean; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Replaces an item in the hash - * @param key String The key of the item. - * @param value Object The new value for the item. - */ - replace?( key?:string, value?:any ): any; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.util { - export interface IHistory extends Ext.IBase,Ext.util.IObservable { - } - export class History { - /** [Method] */ - constructor(); - /** [Method] Add a new token to the history stack - * @param token String The value that defines a particular application-specific history state - * @param preventDuplicates Boolean When true, if the passed token matches the current token it will not save a new history step. Set to false if the same state can be saved more than once at the same history stack location. - */ - static add( token?:string, preventDuplicates?:boolean ): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Programmatically steps back one step in browser history equivalent to the user pressing the Back button */ - static back(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Programmatically steps forward one step in browser history equivalent to the user pressing the Forward button */ - static forward(): void; - /** [Method] Retrieves the currently active history token */ - static getToken(): string; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Initializes the global History instance - * @param onReady Function A callback function that will be called once the history component is fully initialized. - * @param scope Object The scope (this reference) in which the callback is executed. Defaults to the browser window. - */ - static init( onReady?:any, scope?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IHistory extends Ext.IBase,Ext.util.IObservable { - } - export class History { - /** [Method] */ - constructor(); - /** [Method] Add a new token to the history stack - * @param token String The value that defines a particular application-specific history state - * @param preventDuplicates Boolean When true, if the passed token matches the current token it will not save a new history step. Set to false if the same state can be saved more than once at the same history stack location. - */ - static add( token?:string, preventDuplicates?:boolean ): void; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - static addEvents( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static addListener( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static addManagedListener( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static addManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Programmatically steps back one step in browser history equivalent to the user pressing the Back button */ - static back(): void; - /** [Method] Removes all listeners for this object including the managed listeners */ - static clearListeners(): void; - /** [Method] Removes all managed listeners for this object */ - static clearManagedListeners(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - static enableBubble( eventNames?:string ): void; - static enableBubble( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - static fireEvent( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - static fireEventArgs( eventName?:string, args?:Object[] ): boolean; - /** [Method] Programmatically steps forward one step in browser history equivalent to the user pressing the Forward button */ - static forward(): void; - /** [Method] Retrieves the currently active history token */ - static getToken(): string; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - static hasListener( eventName?:string ): boolean; - /** [Method] Initializes the global History instance - * @param onReady Function A callback function that will be called once the history component is fully initialized. - * @param scope Object The scope (this reference) in which the callback is executed. Defaults to the browser window. - */ - static init( onReady?:any, scope?:any ): void; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - static mon( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - static mon( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static mun( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static mun( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - static on( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - static relayEvents( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static removeListener( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - static removeManagedListener( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - static removeManagedListener( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - static resumeEvent( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - static resumeEvents(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - static suspendEvent( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - static suspendEvents( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - static un( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.util { - export interface IInflector extends Ext.IBase { - } - export class Inflector { - /** [Method] Returns the correct Model name for a given string - * @param word String The word to classify - */ - static classify( word?:string ): string; - /** [Method] Removes all registered pluralization rules */ - static clearPlurals(): void; - /** [Method] Removes all registered singularization rules */ - static clearSingulars(): void; - /** [Method] Returns true if the given word is transnumeral the word is its own singular and plural form e g - * @param word String The word to test - */ - static isTransnumeral( word?:string ): boolean; - /** [Method] Ordinalizes a given number by adding a prefix such as st nd rd or th based on the last digit of the number - * @param number Number The number to ordinalize - */ - static ordinalize( number?:number ): string; - /** [Method] Adds a new pluralization rule to the Inflector - * @param matcher RegExp The matcher regex - * @param replacer String The replacement string, which can reference matches from the matcher argument - */ - static plural( matcher?:RegExp, replacer?:string ): void; - /** [Method] Returns the pluralized form of a word e g - * @param word String The word to pluralize - */ - static pluralize( word?:string ): string; - /** [Method] Adds a new singularization rule to the Inflector - * @param matcher RegExp The matcher regex - * @param replacer String The replacement string, which can reference matches from the matcher argument - */ - static singular( matcher?:RegExp, replacer?:string ): void; - /** [Method] Returns the singularized form of a word e g - * @param word String The word to singularize - */ - static singularize( word?:string ): string; - } -} -declare module Ext.util { - export interface IKeyMap extends Ext.IBase { - /** [Config Option] (Object/Object[][]) Either a single object describing a handling function for s specified key (or set of keys), or an array of such objects. ... */ - binding?: any; - /** [Config Option] (String) The event to listen for to pick up key events. ... */ - eventName?: string; - /** [Config Option] (Boolean) Configure this as true if there are any input fields within the target, and this KeyNav should not process events fro... */ - ignoreInputFields?: boolean; - /** [Config Option] (Function) An optional event processor function which accepts the argument list provided by the configured event of the target, ... */ - processEvent?: any; - /** [Config Option] (Object) The scope (this context) in which the processEvent method is executed. ... */ - processEventScope?: any; - /** [Config Option] (Ext.Component/Ext.Element/HTMLElement/String) */ - target?: any; - /** [Method] Add a new binding to this KeyMap - * @param binding any A single KeyMap config or an array of configs. The following config object properties are supported: - */ - addBinding?( binding?:any ): void; - /** [Method] Destroys the KeyMap instance and removes all handlers - * @param removeTarget Boolean True to also remove the target - */ - destroy?( removeTarget?:boolean ): void; - /** [Method] Disable this KeyMap */ - disable?(): void; - /** [Method] Enables this KeyMap */ - enable?(): void; - /** [Method] Returns true if this KeyMap is enabled */ - isEnabled?(): boolean; - /** [Method] Shorthand for adding a single key listener - * @param key any Either the numeric key code, array of key codes or an object with the following options: {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)} - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - on?( key?:any, fn?:any, scope?:any ): void; - /** [Method] Remove a binding from this KeyMap - * @param binding Object See for options - */ - removeBinding?( binding?:any ): void; - /** [Method] Convenience function for setting disabled enabled by boolean - * @param disabled Boolean - */ - setDisabled?( disabled?:boolean ): void; - /** [Method] Shorthand for removing a single key listener - * @param key any Either the numeric key code, array of key codes or an object with the following options: {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)} - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - un?( key?:any, fn?:any, scope?:any ): void; - } -} -declare module Ext { - export interface IKeyMap extends Ext.IBase { - /** [Config Option] (Object/Object[][]) Either a single object describing a handling function for s specified key (or set of keys), or an array of such objects. ... */ - binding?: any; - /** [Config Option] (String) The event to listen for to pick up key events. ... */ - eventName?: string; - /** [Config Option] (Boolean) Configure this as true if there are any input fields within the target, and this KeyNav should not process events fro... */ - ignoreInputFields?: boolean; - /** [Config Option] (Function) An optional event processor function which accepts the argument list provided by the configured event of the target, ... */ - processEvent?: any; - /** [Config Option] (Object) The scope (this context) in which the processEvent method is executed. ... */ - processEventScope?: any; - /** [Config Option] (Ext.Component/Ext.Element/HTMLElement/String) */ - target?: any; - /** [Method] Add a new binding to this KeyMap - * @param binding any A single KeyMap config or an array of configs. The following config object properties are supported: - */ - addBinding?( binding?:any ): void; - /** [Method] Destroys the KeyMap instance and removes all handlers - * @param removeTarget Boolean True to also remove the target - */ - destroy?( removeTarget?:boolean ): void; - /** [Method] Disable this KeyMap */ - disable?(): void; - /** [Method] Enables this KeyMap */ - enable?(): void; - /** [Method] Returns true if this KeyMap is enabled */ - isEnabled?(): boolean; - /** [Method] Shorthand for adding a single key listener - * @param key any Either the numeric key code, array of key codes or an object with the following options: {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)} - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - on?( key?:any, fn?:any, scope?:any ): void; - /** [Method] Remove a binding from this KeyMap - * @param binding Object See for options - */ - removeBinding?( binding?:any ): void; - /** [Method] Convenience function for setting disabled enabled by boolean - * @param disabled Boolean - */ - setDisabled?( disabled?:boolean ): void; - /** [Method] Shorthand for removing a single key listener - * @param key any Either the numeric key code, array of key codes or an object with the following options: {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)} - * @param fn Function The function to call - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - un?( key?:any, fn?:any, scope?:any ): void; - } -} -declare module Ext.util { - export interface IKeyNav extends Ext.IBase { - /** [Config Option] (String) The method to call on the Ext.EventObject after this KeyNav intercepts a key. ... */ - defaultEventAction?: string; - /** [Config Option] (Boolean) True to disable this KeyNav instance. ... */ - disabled?: boolean; - /** [Config Option] (String) The event to listen for to pick up key events. ... */ - eventName?: string; - /** [Config Option] (Boolean) Handle the keydown event instead of keypress. ... */ - forceKeyDown?: boolean; - /** [Config Option] (Boolean) Configure this as true if there are any input fields within the target, and this KeyNav should not process events fro... */ - ignoreInputFields?: boolean; - /** [Config Option] (Ext.util.KeyMap) An optional pre-existing KeyMap to use to listen for key events. ... */ - keyMap?: Ext.util.IKeyMap; - /** [Config Option] (Function) An optional event processor function which accepts the argument list provided by the configured event of the target, ... */ - processEvent?: any; - /** [Config Option] (Object) The scope (this context) in which the processEvent method is executed. ... */ - processEventScope?: any; - /** [Config Option] (Ext.Component/Ext.Element/HTMLElement/String) */ - target?: any; - /** [Method] Destroy this KeyNav - * @param removeEl Boolean Pass true to remove the element associated with this KeyNav. - */ - destroy?( removeEl?:boolean ): void; - /** [Method] Disables this KeyNav */ - disable?(): void; - /** [Method] Enables this KeyNav */ - enable?(): void; - /** [Method] Convenience function for setting disabled enabled by boolean - * @param disabled Boolean - */ - setDisabled?( disabled?:boolean ): void; - } -} -declare module Ext { - export interface IKeyNav extends Ext.IBase { - /** [Config Option] (String) The method to call on the Ext.EventObject after this KeyNav intercepts a key. ... */ - defaultEventAction?: string; - /** [Config Option] (Boolean) True to disable this KeyNav instance. ... */ - disabled?: boolean; - /** [Config Option] (String) The event to listen for to pick up key events. ... */ - eventName?: string; - /** [Config Option] (Boolean) Handle the keydown event instead of keypress. ... */ - forceKeyDown?: boolean; - /** [Config Option] (Boolean) Configure this as true if there are any input fields within the target, and this KeyNav should not process events fro... */ - ignoreInputFields?: boolean; - /** [Config Option] (Ext.util.KeyMap) An optional pre-existing KeyMap to use to listen for key events. ... */ - keyMap?: Ext.util.IKeyMap; - /** [Config Option] (Function) An optional event processor function which accepts the argument list provided by the configured event of the target, ... */ - processEvent?: any; - /** [Config Option] (Object) The scope (this context) in which the processEvent method is executed. ... */ - processEventScope?: any; - /** [Config Option] (Ext.Component/Ext.Element/HTMLElement/String) */ - target?: any; - /** [Method] Destroy this KeyNav - * @param removeEl Boolean Pass true to remove the element associated with this KeyNav. - */ - destroy?( removeEl?:boolean ): void; - /** [Method] Disables this KeyNav */ - disable?(): void; - /** [Method] Enables this KeyNav */ - enable?(): void; - /** [Method] Convenience function for setting disabled enabled by boolean - * @param disabled Boolean - */ - setDisabled?( disabled?:boolean ): void; - } -} -declare module Ext.util { - export interface ILruCache extends Ext.util.IHashMap { - /** [Config Option] (Number) The maximum size the cache is allowed to grow to before further additions cause removal of the least recently used en... */ - maxSize?: number; - /** [Method] Adds an item to the collection - * @param key any The key to associate with the item, or the new item. If a getKey implementation was specified for this HashMap, or if the key of the stored items is in a property called id, the HashMap will be able to derive the key for the new item. In this case just pass the new item in this parameter. - * @param o Object The item to add. - */ - add?( key?:any, o?:any ): any; - /** [Method] Removes all items from the hash - * @param initial Object - */ - clear?( initial?:any ): Ext.util.IHashMap; - /** [Method] Performs a shallow copy on this haLruCachesh */ - clone?(): Ext.util.IHashMap; - /** [Method] Executes the specified function once for each item in the cache - * @param fn Function The function to execute. - * @param scope Object The scope (this reference) to execute in. Defaults to this LruCache. - * @param reverse Boolean Pass true to iterate the list in reverse (most recent first) order. - */ - each?( fn?:any, scope?:any, reverse?:boolean ): Ext.util.ILruCache; - /** [Method] Retrieves an item with a particular key - * @param key String The key to lookup. - */ - get?( key?:string ): any; - /** [Method] Purge the least recently used entries if the maxSize has been exceeded */ - prune?(): void; - } -} -declare module Ext.util { - export interface IMemento extends Ext.IBase { - /** [Property] (Object) */ - target?: any; - /** [Method] Captures the specified properties from the target object in this memento - * @param props String The property or array of properties to capture. - * @param target Object The object from which to capture properties. - */ - capture?( props?:string, target?:any ): void; - capture?( props?:string[], target?:any ): void; - /** [Method] Removes the specified properties from this memento - * @param props String The property or array of properties to remove. - */ - remove?( props?:string ): void; - remove?( props?:string[] ): void; - /** [Method] Restores the specified properties from this memento to the target object - * @param props String The property or array of properties to restore. - * @param clear Boolean True to remove the restored properties from this memento or false to keep them (default is true). - * @param target Object The object to which to restore properties. - */ - restore?( props?:string, clear?:boolean, target?:any ): void; - restore?( props?:string[], clear?:boolean, target?:any ): void; - /** [Method] Restores all captured properties in this memento to the target object - * @param clear Boolean True to remove the restored properties from this memento or false to keep them (default is true). - * @param target Object The object to which to restore properties. - */ - restoreAll?( clear?:boolean, target?:any ): void; - } -} -declare module Ext.util { - export interface IMixedCollection extends Ext.util.IAbstractMixedCollection,Ext.util.ISortable { - /** [Config Option] (Boolean) */ - allowFunctions?: boolean; - /** [Method] Calculates the insertion index of the new item based upon the comparison function passed or the current sort order - * @param newItem Object The new object to find the insertion position of. - * @param sorterFn Function The function to sort by. This is the same as the sorting function passed to sortBy. It accepts 2 items from this MixedCollection, and returns -1 0, or 1 depending on the relative sort positions of the 2 compared items. If omitted, a function generated from the currently defined set of sorters will be used. - */ - findInsertionIndex?( newItem?:any, sorterFn?:any ): number; - /** [Method] Returns a comparator function which compares two items and returns 1 0 or 1 depending on the currently defined set */ - generateComparator?(): void; - /** [Method] Gets the first sorter from the sorters collection excluding any groupers that may be in place */ - getFirstSorter?(): Ext.util.ISorter; - /** [Method] Performs initialization of this mixin */ - initSortable?(): void; - /** [Method] Reorders each of the items based on a mapping from old index to new index - * @param mapping Object Mapping from old item index to new item index - */ - reorder?( mapping?:any ): void; - /** [Method] Sorts the data in the Store by one or more of its properties - * @param sorters any Either a string name of one of the fields in this Store's configured Model, or an array of sorter configurations. - * @param direction any The overall direction to sort the data by. - */ - sort?( sorters?:any, direction?:any ): any; - sort?( sorters?:string, direction?:string ): Ext.util.ISorter[]; - sort?( sorters?:Ext.util.ISorter[], direction?:string ): Ext.util.ISorter[]; - /** [Method] Sorts the collection by a single sorter function - * @param sorterFn Function The function to sort by - */ - sortBy?( sorterFn?:any ): void; - /** [Method] Sorts this collection by keys - * @param direction String 'ASC' or 'DESC'. Defaults to 'ASC'. - * @param fn Function Comparison function that defines the sort order. Defaults to sorting by case insensitive string. - */ - sortByKey?( direction?:string, fn?:any ): void; - } -} -declare module Ext.util { - export interface IObservable extends Ext.IBase { - /** [Config Option] (Object) A config object containing one or more event handlers to be added to this object during initialization. ... */ - listeners?: any; - /** [Property] (Object) This object holds a key for any event that has a listener. ... */ - hasListeners?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Observable, or subclass thereof. ... */ - isObservable?: boolean; - /** [Method] Adds the specified events to the list of events which this Observable may fire - * @param eventNames any Either an object with event names as properties with a value of true. For example: this.addEvents({ storeloaded: true, storecleared: true }); Or any number of event names as separate parameters. For example: this.addEvents('storeloaded', 'storecleared'); - */ - addEvents?( eventNames?:any ): void; - /** [Method] Appends an event handler to this object - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - addListener?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Adds listeners to any Observable object or Ext Element which are automatically removed when this Component is destr - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - addManagedListener?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - addManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Removes all listeners for this object including the managed listeners */ - clearListeners?(): void; - /** [Method] Removes all managed listeners for this object */ - clearManagedListeners?(): void; - /** [Method] Enables events fired by this Observable to bubble up an owner hierarchy by calling this getBubbleTarget if present - * @param eventNames String The event name to bubble, or an Array of event names. - */ - enableBubble?( eventNames?:string ): void; - enableBubble?( eventNames?:string[] ): void; - /** [Method] Fires the specified event with the passed parameters minus the event name plus the options object passed to addList - * @param eventName String The name of the event to fire. - * @param args Object... Variable number of parameters are passed to handlers. - */ - fireEvent?( eventName:string, ...args:any[] ): boolean; - /** [Method] Fires the specified event with the passed parameter list - * @param eventName String The name of the event to fire. - * @param args Object[] An array of parameters which are passed to handlers. - */ - fireEventArgs?( eventName?:string, args?:Object[] ): boolean; - /** [Method] Checks to see if this object has any listeners for a specified event or whether the event bubbles - * @param eventName String The name of the event to check for - */ - hasListener?( eventName?:string ): boolean; - /** [Method] Shorthand for addManagedListener - * @param item any The item to which to add a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn any If the ename parameter was an event name, this is the handler function. - * @param scope any If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - * @param options any If the ename parameter was an event name, this is the addListener options. - */ - mon?( item?:any, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any, options?:any ): any; - mon?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Shorthand for removeManagedListener - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - mun?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - mun?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Shorthand for addListener - * @param eventName any The name of the event to listen for. May also be an object who's property names are event names. - * @param fn Function The method the event invokes, or if scope is specified, the name* of the method within the specified scope. Will be called with arguments given to Ext.util.Observable.fireEvent plus the options parameter described below. - * @param scope Object The scope (this reference) in which the handler function is executed. If omitted, defaults to the object which fired the event. - * @param options Object An object containing handler configuration. Note: Unlike in ExtJS 3.x, the options object will also be passed as the last argument to every event handler. This object may contain any of the following properties: - */ - on?( eventName?:any, fn?:any, scope?:any, options?:any ): any; - /** [Method] Relays selected events from the specified Observable as if the events were fired by this - * @param origin Object The Observable whose events this object is to relay. - * @param events String[] Array of event names to relay. - * @param prefix String A common prefix to prepend to the event names. For example: this.relayEvents(this.getStore(), ['load', 'clear'], 'store'); Now the grid will forward 'load' and 'clear' events of store as 'storeload' and 'storeclear'. - */ - relayEvents?( origin?:any, events?:string[], prefix?:string ): any; - /** [Method] Removes an event handler - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - removeListener?( eventName?:string, fn?:any, scope?:any ): void; - /** [Method] Removes listeners that were added by the mon method - * @param item Ext.util.IObservable The item from which to remove a listener/listeners. - * @param ename any The event name, or an object containing event name properties. - * @param fn Function If the ename parameter was an event name, this is the handler function. - * @param scope Object If the ename parameter was an event name, this is the scope (this reference) in which the handler function is executed. - */ - removeManagedListener?( item?:Ext.util.IObservable, ename?:any, fn?:any, scope?:any ): void; - removeManagedListener?( item?:Ext.IElement, ename?:any, fn?:any, scope?:any ): void; - /** [Method] Resumes firing of the named event s - * @param eventName String... Multiple event names to resume. - */ - resumeEvent?( ...eventName:any[] ): void; - /** [Method] Resumes firing events see suspendEvents */ - resumeEvents?(): void; - /** [Method] Suspends firing of the named event s - * @param eventName String... Multiple event names to suspend. - */ - suspendEvent?( ...eventName:any[] ): void; - /** [Method] Suspends the firing of all events - * @param queueSuspended Boolean Pass as true to queue up suspended events to be fired after the resumeEvents call instead of discarding all suspended events. - */ - suspendEvents?( queueSuspended?:boolean ): void; - /** [Method] Shorthand for removeListener - * @param eventName String The type of event the handler was associated with. - * @param fn Function The handler to remove. This must be a reference to the function passed into the Ext.util.Observable.addListener call. - * @param scope Object The scope originally specified for the handler. It must be the same as the scope argument specified in the original call to Ext.util.Observable.addListener or the listener will not be removed. - */ - un?( eventName?:string, fn?:any, scope?:any ): void; - } -} -declare module Ext.util { - export interface IOffset extends Ext.IBase { - } -} -declare module Ext.util { - export interface IPoint extends Ext.util.IRegion { - /** [Method] Compare this point and another point - * @param p any The point to compare with, either an instance of Ext.util.Point or an object with left and top properties - */ - equals?( p?:any ): boolean; - /** [Method] Determins whether this Point contained by the passed Region Component or element - * @param region any The rectangle to check that this Point is within. - */ - isContainedBy?( region?:any ): any; - isContainedBy?( region?:Ext.util.IRegion ): boolean; - isContainedBy?( region?:Ext.IComponent ): boolean; - isContainedBy?( region?:Ext.dom.IElement ): boolean; - isContainedBy?( region?:HTMLElement ): boolean; - /** [Method] Whether the given point is not away from this point within the given threshold amount - * @param p any The point to check with, either an instance of Ext.util.Point or an object with left and top properties - * @param threshold any Can be either an object with x and y properties or a number - */ - isWithin?( p?:any, threshold?:any ): boolean; - /** [Method] Compare this point with another point when the x and y values of both points are rounded - * @param p any The point to compare with, either an instance of Ext.util.Point or an object with x and y properties - */ - roundedEquals?( p?:any ): boolean; - /** [Method] Returns a human eye friendly string that represents this point useful for debugging */ - toString?(): string; - /** [Method] Alias for translateBy Translate this region by the given offset amount - * @param x any Object containing the x and y properties. Or the x value is using the two argument form. - * @param y Number The y value unless using an Offset object. - */ - translate?( x?:any, y?:number ): Ext.util.IRegion; - } -} -declare module Ext.util { - export interface IPositionable extends Ext.IBase { - /** [Method] Aligns the element with another element relative to the specified anchor points - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - * @param animate any true for the default animation or a standard Element animation config object - */ - alignTo?( element?:any, position?:any, offsets?:any, animate?:any ): any; - alignTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - alignTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - alignTo?( element?:string, position?:string, offsets?:number[], animate?:any ): Ext.util.IPositionable; - /** [Method] Anchors an element to another element and realigns it when the window is resized - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - * @param animate any true for the default animation or a standard Element animation config object - * @param monitorScroll any True to monitor body scroll and reposition. If this parameter is a number, it is used as the buffer delay in milliseconds. - * @param callback any The function to call after the animation finishes - */ - anchorTo?( element?:any, position?:any, offsets?:any, animate?:any, monitorScroll?:any, callback?:any ): any; - anchorTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:string, position?:string, offsets?:number[], animate?:any, monitorScroll?:boolean, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:Ext.util.IPositionable, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:HTMLElement, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - anchorTo?( element?:string, position?:string, offsets?:number[], animate?:any, monitorScroll?:number, callback?:any ): Ext.util.IPositionable; - /** [Method] Calculates the new x y position to move this Positionable into a constrain region - * @param constrainTo any The Element or Region into which this Component is to be constrained. Defaults to the element into which this Positionable was rendered, or this Component's {@link Ext.Component.constrainTo. - * @param proposedPosition any A proposed [X, Y] position to test for validity and to coerce into constraints instead of using this Positionable's current position. - * @param local any The proposedPosition is local (relative to floatParent if a floating Component) - * @param proposedSize any A proposed [width, height] size to use when calculating constraints instead of using this Positionable's current size. - */ - calculateConstrainedPosition?( constrainTo?:any, proposedPosition?:any, local?:any, proposedSize?:any ): any; - calculateConstrainedPosition?( constrainTo?:string, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:HTMLElement, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:Ext.IElement, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - calculateConstrainedPosition?( constrainTo?:Ext.util.IRegion, proposedPosition?:number[], local?:boolean, proposedSize?:number[] ): number[]; - /** [Method] Gets the x y coordinates to align this element with another element - * @param element any The Positionable, HTMLElement, or id of the element to align to. - * @param position any The position to align to - * @param offsets any Offset the positioning by [x, y] - */ - getAlignToXY?( element?:any, position?:any, offsets?:any ): any; - getAlignToXY?( element?:Ext.util.IPositionable, position?:string, offsets?:number[] ): number[]; - getAlignToXY?( element?:HTMLElement, position?:string, offsets?:number[] ): number[]; - getAlignToXY?( element?:string, position?:string, offsets?:number[] ): number[]; - /** [Method] Gets the x y coordinates specified by the anchor position on the element - * @param anchor String The specified anchor position. See alignTo for details on supported anchor positions. - * @param local Boolean True to get the local (element top/left-relative) anchor position instead of page coordinates - * @param size Object An object containing the size to use for calculating anchor position {width: (target width), height: (target height)} (defaults to the element's current size) - */ - getAnchorXY?( anchor?:string, local?:boolean, size?:any ): number[]; - /** [Method] Return an object defining the area of this Element which can be passed to setBox to set another Element s size locati - * @param contentBox Boolean If true a box for the content of the element is returned. - * @param local Boolean If true the element's left and top relative to its offsetParent are returned instead of page x/y. - */ - getBox?( contentBox?:boolean, local?:boolean ): any; - /** [Method] Returns the X Y vector by which this Positionable s element must be translated to make a best attempt to constrain - * @param constrainTo any The Positionable, HTMLElement, element id, or Region into which the element is to be constrained. - * @param proposedPosition any A proposed [X, Y] position to test for validity and to produce a vector for instead of using the element's current position - * @param proposedSize any A proposed [width, height] size to constrain instead of using the element's current size - */ - getConstrainVector?( constrainTo?:any, proposedPosition?:any, proposedSize?:any ): any; - getConstrainVector?( constrainTo?:Ext.util.IPositionable, proposedPosition?:number[], proposedSize?:number[] ): number[]; - getConstrainVector?( constrainTo?:HTMLElement, proposedPosition?:number[], proposedSize?:number[] ): number[]; - getConstrainVector?( constrainTo?:string, proposedPosition?:number[], proposedSize?:number[] ): number[]; - getConstrainVector?( constrainTo?:Ext.util.IRegion, proposedPosition?:number[], proposedSize?:number[] ): number[]; - /** [Method] Returns the X Y vector by which this Positionable s element must be translated to make a best attempt to constrain - * @param constrainTo Ext.util.IPositionable The Positionable, HTMLElement, element id, or Region into which the element is to be constrained. - * @param proposedPosition Number[] A proposed [X, Y] position to test for validity and to produce a vector for instead of using the element's current position - * @param proposedSize Number[] A proposed [width, height] size to constrain instead of using the element's current size - */ - getConstrainVector?( constrainTo?:Ext.util.IPositionable, proposedPosition?:number[], proposedSize?:number[] ): boolean; - getConstrainVector?( constrainTo?:HTMLElement, proposedPosition?:number[], proposedSize?:number[] ): boolean; - getConstrainVector?( constrainTo?:string, proposedPosition?:number[], proposedSize?:number[] ): boolean; - getConstrainVector?( constrainTo?:Ext.util.IRegion, proposedPosition?:number[], proposedSize?:number[] ): boolean; - /** [Method] Returns the x coordinate of this element reletive to its offsetParent */ - getLocalX?(): number; - /** [Method] Returns the x and y coordinates of this element relative to its offsetParent */ - getLocalXY?(): number[]; - /** [Method] Returns the y coordinate of this element reletive to its offsetParent */ - getLocalY?(): number; - /** [Method] Returns the offsets of this element from the passed element - * @param offsetsTo any The Positionable, HTMLElement, or element id to get get the offsets from. - */ - getOffsetsTo?( offsetsTo?:any ): any; - getOffsetsTo?( offsetsTo?:Ext.util.IPositionable ): number[]; - getOffsetsTo?( offsetsTo?:HTMLElement ): number[]; - getOffsetsTo?( offsetsTo?:string ): number[]; - /** [Method] Returns a region object that defines the area of this element */ - getRegion?(): Ext.util.IRegion; - /** [Method] Returns the content region of this element */ - getViewRegion?(): Ext.util.IRegion; - /** [Method] Gets the current X position of the DOM element based on page coordinates */ - getX?(): number; - /** [Method] Gets the current position of the DOM element based on page coordinates */ - getXY?(): number[]; - /** [Method] Gets the current Y position of the DOM element based on page coordinates */ - getY?(): number; - /** [Method] Move the element relative to its current position - * @param direction String Possible values are: "l" (or "left") "r" (or "right") "t" (or "top", or "up") "b" (or "bottom", or "down") - * @param distance Number How far to move the element in pixels - * @param animate any true for the default animation or a standard Element animation config object - */ - move?( direction?:string, distance?:number, animate?:any ): void; - /** [Method] Remove any anchor to this element */ - removeAnchor?(): Ext.util.IPositionable; - /** [Method] Sets the element s box - * @param box Object The box to fill {x, y, width, height} - * @param animate any true for the default animation or a standard Element animation config object - */ - setBox?( box?:any, animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the local x coordinate of this element using CSS style - * @param x Number The x coordinate. A value of null sets the left style to 'auto'. - */ - setLocalX?( x?:number ): Ext.util.IPositionable; - /** [Method] Sets the local x and y coordinates of this element using CSS style - * @param x any The x coordinate or an array containing [x, y]. A value of null sets the left style to 'auto' - * @param y any The y coordinate, required if x is not an array. A value of null sets the top style to 'auto' - */ - setLocalXY?( x?:any, y?:any ): any; - setLocalXY?( x?:number, y?:number ): Ext.util.IPositionable; - setLocalXY?( x?:any[], y?:number ): Ext.util.IPositionable; - /** [Method] Sets the local y coordinate of this element using CSS style - * @param y Number The y coordinate. A value of null sets the top style to 'auto'. - */ - setLocalY?( y?:number ): Ext.util.IPositionable; - /** [Method] Sets the element s position and size to the specified region - * @param region Ext.util.IRegion The region to fill - * @param animate any true for the default animation or a standard Element animation config object - */ - setRegion?( region?:Ext.util.IRegion, animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the X position of the DOM element based on page coordinates - * @param The Number X position - * @param animate any True for the default animation, or a standard Element animation config object - */ - setX?( The?:number, animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the position of the DOM element in page coordinates - * @param pos Number[] Contains X & Y [x, y] values for new position (coordinates are page-based) - * @param animate any True for the default animation, or a standard Element animation config object - */ - setXY?( pos?:number[], animate?:any ): Ext.util.IPositionable; - /** [Method] Sets the Y position of the DOM element based on page coordinates - * @param The Number Y position - * @param animate any True for the default animation, or a standard Element animation config object - */ - setY?( The?:number, animate?:any ): Ext.util.IPositionable; - /** [Method] Translates the passed page coordinates into left top css values for the element - * @param x any The page x or an array containing [x, y] - * @param y any The page y, required if x is not an array - */ - translatePoints?( x?:any, y?:any ): any; - translatePoints?( x?:number, y?:number ): any; - translatePoints?( x?:any[], y?:number ): any; - } -} -declare module Ext.util { - export interface IProtoElement extends Ext.IBase { - /** [Property] (String) The property name for the className on the data object passed to writeTo. ... */ - clsProp?: string; - /** [Property] (String) The property name for the removed classes on the data object passed to writeTo. ... */ - removedProp?: string; - /** [Property] (Boolean) True if the style must be converted to text during writeTo. ... */ - styleIsText?: boolean; - /** [Property] (String) The property name for the style on the data object passed to writeTo. ... */ - styleProp?: string; - /** [Method] Adds class to the element - * @param cls String One or more classnames separated with spaces. - */ - addCls?( cls?:string ): Ext.util.IProtoElement; - /** [Method] Indicates that the current state of the object has been flushed to the DOM so we need to track any subsequent changes */ - flush?(): void; - /** [Method] True if the element has given class - * @param cls String - */ - hasCls?( cls?:string ): boolean; - /** [Method] Removes class from the element - * @param cls String One or more classnames separated with spaces. - */ - removeCls?( cls?:string ): Ext.util.IProtoElement; - /** [Method] Adds styles to the element - * @param prop any The style property to be set, or an object of multiple styles. - * @param value String The value to apply to the given property. - */ - setStyle?( prop?:any, value?:string ): Ext.util.IProtoElement; - /** [Method] Writes style and class properties to given object - * @param to Object - */ - writeTo?( to?:any ): any; - } -} -declare module Ext.util { - export interface IQueue extends Ext.IBase { - /** [Method] Removes all items from the collection */ - clear?(): void; - /** [Method] Returns the number of items in the collection */ - getCount?(): number; - /** [Method] Remove an item from the collection - * @param obj Object The item to remove. - */ - remove?( obj?:any ): any; - } -} -declare module Ext.util { - export interface IRegion extends Ext.IBase { - /** [Method] Modifies the current region to be adjusted by offsets - * @param top Number top offset - * @param right Number right offset - * @param bottom Number bottom offset - * @param left Number left offset - */ - adjust?( top?:number, right?:number, bottom?:number, left?:number ): Ext.util.IRegion; - /** [Method] Modifies the current region to be constrained to the targetRegion - * @param targetRegion Ext.util.IRegion - */ - constrainTo?( targetRegion?:Ext.util.IRegion ): Ext.util.IRegion; - /** [Method] Checks if this region completely contains the region that is passed in - * @param region Ext.util.IRegion - */ - contains?( region?:Ext.util.IRegion ): boolean; - /** [Method] Create a copy of this Region */ - copy?(): Ext.util.IRegion; - /** [Method] Copy the values of another Region to this Region - * @param p Ext.util.IRegion The region to copy from. - */ - copyFrom?( p?:Ext.util.IRegion ): Ext.util.IRegion; - /** [Method] Check whether this region is equivalent to the given region - * @param region Ext.util.IRegion The region to compare with - */ - equals?( region?:Ext.util.IRegion ): boolean; - /** [Method] Get the offset amount of a point outside the region - * @param axis String - * @param p Ext.util.IPoint the point - */ - getOutOfBoundOffset?( axis?:string, p?:Ext.util.IPoint ): Ext.util.IOffset; - /** [Method] Get the offset amount on the x axis - * @param p Number the offset - */ - getOutOfBoundOffsetX?( p?:number ): number; - /** [Method] Get the offset amount on the y axis - * @param p Number the offset - */ - getOutOfBoundOffsetY?( p?:number ): number; - /** [Method] Checks if this region intersects the region passed in - * @param region Ext.util.IRegion - */ - intersect?( region?:Ext.util.IRegion ): any; - /** [Method] Check whether the point offset is out of bound - * @param axis any - * @param p any the point / offset - */ - isOutOfBound?( axis?:any, p?:any ): any; - isOutOfBound?( axis?:string, p?:Ext.util.IPoint ): boolean; - isOutOfBound?( axis?:string, p?:number ): boolean; - /** [Method] Check whether the offset is out of bound in the x axis - * @param p Number the offset - */ - isOutOfBoundX?( p?:number ): boolean; - /** [Method] Check whether the offset is out of bound in the y axis - * @param p Number the offset - */ - isOutOfBoundY?( p?:number ): boolean; - /** [Method] Round all the properties of this region */ - round?(): Ext.util.IRegion; - /** [Method] Translate this region by the given offset amount - * @param x any Object containing the x and y properties. Or the x value is using the two argument form. - * @param y Number The y value unless using an Offset object. - */ - translateBy?( x?:any, y?:number ): Ext.util.IRegion; - /** [Method] Returns the smallest region that contains the current AND targetRegion - * @param region Ext.util.IRegion - */ - union?( region?:Ext.util.IRegion ): Ext.util.IRegion; - } -} -declare module Ext.util { - export interface IRenderable extends Ext.IBase { - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Handles autoRender */ - doAutoRender?(): void; - /** [Method] Ensures that this component is attached to document body - * @param runLayout Boolean True to run the component's layout. - */ - ensureAttachedToBody?( runLayout?:boolean ): void; - /** [Method] This function takes the position argument passed to onRender and returns a DOM element that you can use in the insert - * @param position any Index, element id or element you want to put this component before. - */ - getInsertPosition?( position?:any ): any; - getInsertPosition?( position?:string ): HTMLElement; - getInsertPosition?( position?:number ): HTMLElement; - getInsertPosition?( position?:Ext.dom.IElement ): HTMLElement; - getInsertPosition?( position?:HTMLElement ): HTMLElement; - /** [Method] Initialized the renderData to be used when rendering the renderTpl */ - initRenderData?(): any; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Renders the Component into the passed HTML element - * @param container Ext.IElement The element this Component should be rendered into. If it is being created from existing markup, this should be omitted. - * @param position String The element ID or DOM node index within the container before which this component will be inserted (defaults to appending to the end of the container) - */ - render?( container?:Ext.IElement, position?:string ): void; - render?( container?:HTMLElement, position?:string ): void; - render?( container?:string, position?:string ): void; - render?( container?:Ext.IElement, position?:number ): void; - render?( container?:HTMLElement, position?:number ): void; - render?( container?:string, position?:number ): void; - } -} -declare module Ext.util { - export interface ISortable extends Ext.IBase { - /** [Config Option] (String) The default sort direction to use if one is not specified. ... */ - defaultSortDirection?: string; - /** [Config Option] (String) */ - sortRoot?: string; - /** [Config Option] (Ext.util.Sorter[]/Object[]) */ - sorters?: any; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Sortable, or subclass thereof. ... */ - isSortable?: boolean; - /** [Method] Returns a comparator function which compares two items and returns 1 0 or 1 depending on the currently defined set */ - generateComparator?(): void; - /** [Method] Gets the first sorter from the sorters collection excluding any groupers that may be in place */ - getFirstSorter?(): Ext.util.ISorter; - /** [Method] Performs initialization of this mixin */ - initSortable?(): void; - /** [Method] Sorts the data in the Store by one or more of its properties - * @param sorters any Either a string name of one of the fields in this Store's configured Model, or an array of sorter configurations. - * @param direction any The overall direction to sort the data by. - */ - sort?( sorters?:any, direction?:any ): any; - sort?( sorters?:string, direction?:string ): Ext.util.ISorter[]; - sort?( sorters?:Ext.util.ISorter[], direction?:string ): Ext.util.ISorter[]; - } -} -declare module Ext.util { - export interface ISorter extends Ext.IBase { - /** [Config Option] (String) The direction to sort by. ... */ - direction?: string; - /** [Config Option] (String) The property to sort by. ... */ - property?: string; - /** [Config Option] (String) Optional root property. ... */ - root?: string; - /** [Config Option] (Function) A specific sorter function to execute. ... */ - sorterFn?: any; - /** [Config Option] (Function) A function that will be run on each value before it is compared in the sorter. ... */ - transform?: any; - /** [Method] Set the sorting direction for this sorter - * @param direction String The direction to sort in. Should be either 'ASC' or 'DESC'. - */ - setDirection?( direction?:string ): void; - /** [Method] Toggles the sorting direction for this sorter */ - toggle?(): void; - /** [Method] Update the sort function for this sorter - * @param fn Function A new sorter function for this sorter. If not specified it will use the default sorting function. - */ - updateSortFunction?( fn?:any ): void; - } -} -declare module Ext.util { - export interface ITaskManager extends Ext.util.ITaskRunner { - } - export class TaskManager { - } -} -declare module Ext { - export interface ITaskManager extends Ext.util.ITaskRunner { - } - export class TaskManager { - } -} -declare module Ext.util { - export interface ITaskRunner extends Ext.IBase { - /** [Config Option] (Boolean) This may be configured false to inhibit firing of the idle event after task invocation. ... */ - fireIdleEvent?: boolean; - /** [Config Option] (Number) The timer resolution. ... */ - interval?: number; - /** [Method] Destroys this instance stopping all tasks that are currently running */ - destroy?(): void; - /** [Method] Creates a new Task instance - * @param config Object The config object. For details on the supported properties, see start. - */ - newTask?( config?:any ): void; - /** [Method] Starts a new task - * @param task Object A config object that supports the following properties: - */ - start?( task?:any ): any; - /** [Method] Stops an existing running task - * @param task Object The task to stop - */ - stop?( task?:any ): any; - /** [Method] Stops all tasks that are currently running */ - stopAll?(): void; - } -} -declare module Ext.util.taskrunner { - export interface ITask { - /** [Property] (Boolean) Override default behavior ... */ - fireOnStart?: boolean; - /** [Method] Destroys this instance stopping this task s execution */ - destroy?(): void; - /** [Method] Restarts this task clearing it duration expiration and run count - * @param interval Number Optionally reset this task's interval. - */ - restart?( interval?:number ): void; - /** [Method] Starts this task if it is not already started - * @param interval Number Optionally reset this task's interval. - */ - start?( interval?:number ): void; - /** [Method] Stops this task */ - stop?(): void; - } -} -declare module Ext.util { - export interface ITextMetrics extends Ext.IBase { - /** [Method] Binds this TextMetrics instance to a new element - * @param el String The element or its ID. - */ - bind?( el?:string ): void; - bind?( el?:HTMLElement ): void; - bind?( el?:Ext.IElement ): void; - /** [Method] Destroy this instance */ - destroy?(): void; - /** [Method] Returns the measured height of the specified text - * @param text String The text to measure - */ - getHeight?( text?:string ): number; - /** [Method] Returns the size of the specified text based on the internal element s style and width properties - * @param text String The text to measure - */ - getSize?( text?:string ): any; - /** [Method] Returns the measured width of the specified text - * @param text String The text to measure - */ - getWidth?( text?:string ): number; - /** [Method] Sets a fixed width on the internal measurement element - * @param width Number The width to set on the element - */ - setFixedWidth?( width?:number ): void; - } -} -declare module Ext { - export interface IVersion { - /** [Method] Returns whether this version equals to the supplied argument - * @param target any The version to compare with - */ - equals?( target?:any ): any; - equals?( target?:string ): boolean; - equals?( target?:number ): boolean; - /** [Method] Returns the build component value */ - getBuild?(): number; - /** [Method] Returns the major component value */ - getMajor?(): number; - /** [Method] Returns the minor component value */ - getMinor?(): number; - /** [Method] Returns the patch component value */ - getPatch?(): number; - /** [Method] Returns the release component value */ - getRelease?(): number; - /** [Method] Returns shortVersion version without dots and release */ - getShortVersion?(): string; - /** [Method] Convenient alias to isGreaterThan - * @param target any - */ - gt?( target?:any ): any; - gt?( target?:string ): boolean; - gt?( target?:number ): boolean; - /** [Method] Convenient alias to isGreaterThanOrEqual - * @param target any - */ - gtEq?( target?:any ): any; - gtEq?( target?:string ): boolean; - gtEq?( target?:number ): boolean; - /** [Method] Returns whether this version if greater than the supplied argument - * @param target any The version to compare with - */ - isGreaterThan?( target?:any ): any; - isGreaterThan?( target?:string ): boolean; - isGreaterThan?( target?:number ): boolean; - /** [Method] Returns whether this version if greater than or equal to the supplied argument - * @param target any The version to compare with - */ - isGreaterThanOrEqual?( target?:any ): any; - isGreaterThanOrEqual?( target?:string ): boolean; - isGreaterThanOrEqual?( target?:number ): boolean; - /** [Method] Returns whether this version if smaller than the supplied argument - * @param target any The version to compare with - */ - isLessThan?( target?:any ): any; - isLessThan?( target?:string ): boolean; - isLessThan?( target?:number ): boolean; - /** [Method] Returns whether this version if less than or equal to the supplied argument - * @param target any The version to compare with - */ - isLessThanOrEqual?( target?:any ): any; - isLessThanOrEqual?( target?:string ): boolean; - isLessThanOrEqual?( target?:number ): boolean; - /** [Method] Convenient alias to isLessThan - * @param target any - */ - lt?( target?:any ): any; - lt?( target?:string ): boolean; - lt?( target?:number ): boolean; - /** [Method] Convenient alias to isLessThanOrEqual - * @param target any - */ - ltEq?( target?:any ): any; - ltEq?( target?:string ): boolean; - ltEq?( target?:number ): boolean; - /** [Method] Returns whether this version matches the supplied argument - * @param target any The version to compare with - */ - match?( target?:any ): any; - match?( target?:string ): boolean; - match?( target?:number ): boolean; - /** [Method] Returns this format major minor patch build release */ - toArray?(): number[]; - } -} -declare module Ext.view { - export interface IAbstractView extends Ext.IComponent,Ext.util.IBindable { - /** [Config Option] (Boolean) Set this to true to ignore refresh events on the bound store. ... */ - blockRefresh?: boolean; - /** [Config Option] (Boolean) True to defer emptyText being applied until the store's first load. ... */ - deferEmptyText?: boolean; - /** [Config Option] (Boolean) Defaults to true to defer the initial refresh of the view. ... */ - deferInitialRefresh?: boolean; - /** [Config Option] (Boolean) True to disable selection within the DataView. ... */ - disableSelection?: boolean; - /** [Config Option] (String) The text to display in the view when there is no data to display. ... */ - emptyText?: string; - /** [Config Option] (String) Specifies the class to be assigned to each element in the view when used in conjunction with the itemTpl configuration. ... */ - itemCls?: string; - /** [Config Option] (String) This is a required setting. ... */ - itemSelector?: string; - /** [Config Option] (String/String[]/Ext.XTemplate) The inner portion of the item template to be rendered. ... */ - itemTpl?: any; - /** [Config Option] (Boolean/Object) False to disable a load mask from displaying while the view is loading. ... */ - loadMask?: any; - /** [Config Option] (String) The CSS class to apply to the loading message element. ... */ - loadingCls?: string; - /** [Config Option] (Number) If specified, gives an explicit height for the data view when it is showing the loadingText, if that is specified. ... */ - loadingHeight?: number; - /** [Config Option] (String) A string to display during data load operations. ... */ - loadingText?: string; - /** [Config Option] (Boolean) True to allow selection of more than one item at a time, false to allow selection of only a single item at a time or ... */ - multiSelect?: boolean; - /** [Config Option] (String) A CSS class to apply to each item in the view on mouseover. ... */ - overItemCls?: string; - /** [Config Option] (Boolean) True to preserve scroll position across refresh operations. ... */ - preserveScrollOnRefresh?: boolean; - /** [Config Option] (String) A CSS class to apply to each selected item in the view. ... */ - selectedItemCls?: string; - /** [Config Option] (Boolean) True to enable multiselection by clicking on multiple items without requiring the user to hold Shift or Ctrl, false t... */ - simpleSelect?: boolean; - /** [Config Option] (Boolean) Allows selection of exactly one item at a time. ... */ - singleSelect?: boolean; - /** [Config Option] (Ext.data.Store) */ - store?: Ext.data.IStore; - /** [Config Option] (String/String[]/Ext.XTemplate) The HTML fragment or an array of fragments that will make up the template used by this DataView. ... */ - tpl?: any; - /** [Config Option] (Boolean) When true the overItemCls will be applied to rows when hovered over. ... */ - trackOver?: boolean; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Changes the data store bound to this view and refreshes it - * @param store Ext.data.IStore The store to bind to this view - */ - bindStore?( store?:Ext.data.IStore ): void; - /** [Method] Binds listeners for this component to the store - * @param store Ext.data.IAbstractStore The store to bind to - */ - bindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - /** [Method] Function which can be overridden which returns the data object passed to this DataView s template to render the whole - * @param records Ext.data.IModel[] An Array of Ext.data.Models to be rendered into the DataView. - * @param startIndex Number the index number of the Record being prepared for rendering. - */ - collectData?( records?:Ext.data.IModel[], startIndex?:number ): Object[]; - /** [Method] Deselects a record instance by record instance or index - * @param records Ext.data.IModel[] An array of records or an index - * @param suppressEvent Boolean Set to false to not fire a deselect event - */ - deselect?( records?:Ext.data.IModel[], suppressEvent?:boolean ): void; - deselect?( records?:number, suppressEvent?:boolean ): void; - /** [Method] Returns the template node the passed child belongs to or null if it doesn t belong to one - * @param node HTMLElement - */ - findItemByChild?( node?:HTMLElement ): HTMLElement; - /** [Method] Returns the template node by the Ext EventObject or null if it is not found - * @param e Ext.IEventObject - */ - findTargetByEvent?( e?:Ext.IEventObject ): void; - /** [Method] Gets a template node - * @param nodeInfo any An HTMLElement template node, index of a template node, the id of a template node or the record associated with the node. - */ - getNode?( nodeInfo?:any ): any; - getNode?( nodeInfo?:HTMLElement ): HTMLElement; - getNode?( nodeInfo?:string ): HTMLElement; - getNode?( nodeInfo?:number ): HTMLElement; - getNode?( nodeInfo?:Ext.data.IModel ): HTMLElement; - /** [Method] Gets a range nodes - * @param start Number The index of the first node in the range - * @param end Number The index of the last node in the range - */ - getNodes?( start?:number, end?:number ): HTMLElement[]; - /** [Method] Gets a record from a node - * @param node any The node to evaluate - */ - getRecord?( node?:any ): any; - getRecord?( node?:Ext.IElement ): Ext.data.IModel; - getRecord?( node?:HTMLElement ): Ext.data.IModel; - /** [Method] Gets an array of the records from an array of nodes - * @param nodes HTMLElement[] The nodes to evaluate - */ - getRecords?( nodes?:HTMLElement[] ): Ext.data.IModel[]; - /** [Method] Gets the currently selected nodes */ - getSelectedNodes?(): HTMLElement[]; - /** [Method] Gets the selection model for this view */ - getSelectionModel?(): Ext.selection.IModel; - /** [Method] Returns the store associated with this DataView */ - getStore?(): Ext.data.IStore; - /** [Method] Gets the listeners to bind to a new store - * @param store Ext.data.IStore The Store which is being bound to for which a listeners object should be returned. - */ - getStoreListeners?( store?:Ext.data.IStore ): any; - /** [Method] Finds the index of the passed node - * @param nodeInfo any An HTMLElement template node, index of a template node, the id of a template node or a record associated with a node. - */ - indexOf?( nodeInfo?:any ): any; - indexOf?( nodeInfo?:HTMLElement ): number; - indexOf?( nodeInfo?:string ): number; - indexOf?( nodeInfo?:number ): number; - indexOf?( nodeInfo?:Ext.data.IModel ): number; - /** [Method] private The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Returns true if the passed node is selected else false - * @param node any The node, node index or record to check - */ - isSelected?( node?:any ): any; - isSelected?( node?:HTMLElement ): boolean; - isSelected?( node?:number ): boolean; - isSelected?( node?:Ext.data.IModel ): boolean; - /** [Method] Template method it is called when a new store is bound to the current instance - * @param store Ext.data.IAbstractStore The store being bound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onBindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Template method it is called when an existing store is unbound from the current instance - * @param store Ext.data.IAbstractStore The store being unbound - * @param initial Boolean True if this store is being bound as initialization of the instance. - */ - onUnbindStore?( store?:Ext.data.IAbstractStore, initial?:boolean ): void; - /** [Method] Function which can be overridden to provide custom formatting for each Record that is used by this DataView s templat - * @param data any The raw data object that was used to create the Record. - * @param recordIndex Number the index number of the Record being prepared for rendering. - * @param record Ext.data.IModel The Record being prepared for rendering. - */ - prepareData?( data?:any, recordIndex?:number, record?:Ext.data.IModel ): any; - /** [Method] Refreshes the view by reloading the data from the store and re rendering the template */ - refresh?(): void; - /** [Method] Refreshes an individual node s data from the store - * @param index Number The item's data index in the store - */ - refreshNode?( index?:number ): void; - /** [Method] Unbinds listeners from this component to the store - * @param store Ext.data.IAbstractStore The store to unbind from - */ - unbindStoreListeners?( store?:Ext.data.IAbstractStore ): void; - } -} -declare module Ext.view { - export interface IBoundList extends Ext.view.IView { - /** [Config Option] (String) private overrides The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) This Component is used as a popup, not part of a complex layout. ... */ - deferInitialRefresh?: boolean; - /** [Config Option] (String) The field from the store to show in the view. ... */ - displayField?: string; - /** [Config Option] (String) Specifies the class to be assigned to each element in the view when used in conjunction with the itemTpl configuration. ... */ - itemCls?: string; - /** [Config Option] (Number) If greater than 0, a Ext.toolbar.Paging is displayed at the bottom of the list and store queries will execute with pa... */ - pageSize?: number; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String/Boolean) Specifies whether the floating component should be given a shadow. ... */ - shadow?: any; - /** [Config Option] (String/Ext.XTemplate) A String or Ext.XTemplate instance to apply to inner template. ... */ - tpl?: any; - /** [Config Option] (Boolean) When true the overItemCls will be applied to rows when hovered over. ... */ - trackOver?: boolean; - /** [Property] (Ext.toolbar.Paging) A reference to the PagingToolbar instance in this view. ... */ - pagingToolbar?: Ext.toolbar.IPaging; - /** [Method] Changes the data store bound to this view and refreshes it - * @param store Ext.data.IStore The store to bind to this view - */ - bindStore?( store?:Ext.data.IStore ): void; - /** [Method] A method that returns the inner template for displaying items in the list - * @param displayField String The displayField for the BoundList. - */ - getInnerTpl?( displayField?:string ): string; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Refreshes the view by reloading the data from the store and re rendering the template */ - refresh?(): void; - } -} -declare module Ext { - export interface IBoundList extends Ext.view.IView { - /** [Config Option] (String) private overrides The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) This Component is used as a popup, not part of a complex layout. ... */ - deferInitialRefresh?: boolean; - /** [Config Option] (String) The field from the store to show in the view. ... */ - displayField?: string; - /** [Config Option] (String) Specifies the class to be assigned to each element in the view when used in conjunction with the itemTpl configuration. ... */ - itemCls?: string; - /** [Config Option] (Number) If greater than 0, a Ext.toolbar.Paging is displayed at the bottom of the list and store queries will execute with pa... */ - pageSize?: number; - /** [Config Option] (Ext.XTemplate/String/String[]) An XTemplate used to create the internal structure inside this Component's encapsulating Element. ... */ - renderTpl?: any; - /** [Config Option] (String/Boolean) Specifies whether the floating component should be given a shadow. ... */ - shadow?: any; - /** [Config Option] (String/Ext.XTemplate) A String or Ext.XTemplate instance to apply to inner template. ... */ - tpl?: any; - /** [Config Option] (Boolean) When true the overItemCls will be applied to rows when hovered over. ... */ - trackOver?: boolean; - /** [Property] (Ext.toolbar.Paging) A reference to the PagingToolbar instance in this view. ... */ - pagingToolbar?: Ext.toolbar.IPaging; - /** [Method] Changes the data store bound to this view and refreshes it - * @param store Ext.data.IStore The store to bind to this view - */ - bindStore?( store?:Ext.data.IStore ): void; - /** [Method] A method that returns the inner template for displaying items in the list - * @param displayField String The displayField for the BoundList. - */ - getInnerTpl?( displayField?:string ): string; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Refreshes the view by reloading the data from the store and re rendering the template */ - refresh?(): void; - } -} -declare module Ext.view { - export interface IBoundListKeyNav extends Ext.util.IKeyNav { - /** [Config Option] (Ext.view.BoundList) */ - boundList?: Ext.view.IBoundList; - /** [Method] Highlights the item at the given index - * @param index Number - */ - highlightAt?( index?:number ): void; - /** [Method] Triggers selection of the currently highlighted item according to the behavior of the configured SelectionModel - * @param e Object - */ - selectHighlighted?( e?:any ): void; - } -} -declare module Ext.view { - export interface IDragZone extends Ext.dd.IDragZone { - /** [Config Option] (Object/Boolean) True to register this container with the Scrollmanager for auto scrolling during drag operations. ... */ - containerScroll?: any; - /** [Method] Called when a mousedown occurs in this container - * @param e Event The mouse down event - */ - getDragData?( e?:Event ): any; - /** [Method] Called before a repair of an invalid drop to get the XY to animate to - * @param e Event The mouse up event - */ - getRepairXY?( e?:Event ): number[]; - /** [Method] Sets up the DragDrop object - * @param id String the id of the linked element - * @param sGroup String the group of related items - * @param config Object configuration attributes - */ - init?( id?:string, sGroup?:string, config?:any ): void; - /** [Method] Called once drag threshold has been reached to initialize the proxy element - * @param x Number The x position of the click on the dragged object - * @param y Number The y position of the click on the dragged object - */ - onInitDrag?( x?:number, y?:number ): boolean; - } -} -declare module Ext.view { - export interface IDropZone extends Ext.dd.IDropZone { - /** [Method] Returns a custom data object associated with the DOM node that is the target of the event - * @param e Event The event - */ - getTargetFromEvent?( e?:Event ): any; - /** [Method] Moved out of the DropZone without dropping - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop target - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag zone - */ - notifyOut?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): void; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dropped on it but not on any of its registered - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onContainerDrop?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] The mouse is past the end of all nodes or there are no nodes Called while the DropZone determines that a Ext dd Dr - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onContainerOver?( source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - /** [Method] Called when the DropZone determines that a Ext dd DragSource has been dropped onto the drop node - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeDrop?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): boolean; - /** [Method] The mouse is over a View node Called while the DropZone determines that a Ext dd DragSource is over a drop node that - * @param nodeData Object The custom data associated with the drop node (this is the same value returned from getTargetFromEvent for this node) - * @param source Ext.dd.IDragSource The drag source that was dragged over this drop zone - * @param e Event The event - * @param data Object An object containing arbitrary data supplied by the drag source - */ - onNodeOver?( nodeData?:any, source?:Ext.dd.IDragSource, e?:Event, data?:any ): string; - } -} -declare module Ext.view { - export interface INodeCache extends Ext.IBase { - /** [Method] Removes all elements from this NodeCache - * @param removeDom Boolean True to also remove the elements from the document. - */ - clear?( removeDom?:boolean ): void; - /** [Method] Clears this NodeCache and adds the elements passed - * @param els HTMLElement[] An array of DOM elements from which to fill this NodeCache. - */ - fill?( els?:HTMLElement[] ): Ext.view.INodeCache; - /** [Method] Find the index of the passed element within the composite collection - * @param el any The id of an element, or an Ext.dom.Element, or an HtmlElement to find within the composite collection. - */ - indexOf?( el?:any ): any; - indexOf?( el?:string ): number; - indexOf?( el?:HTMLElement ): number; - indexOf?( el?:Ext.IElement ): number; - indexOf?( el?:number ): number; - /** [Method] Removes the specified element s - * @param el String The id of an element, the Element itself, the index of the element in this composite or an array of any of those. - * @param removeDom Boolean True to also remove the element from the document - */ - removeElement?( el?:string, removeDom?:boolean ): void; - removeElement?( el?:HTMLElement, removeDom?:boolean ): void; - removeElement?( el?:Ext.IElement, removeDom?:boolean ): void; - removeElement?( el?:number, removeDom?:boolean ): void; - /** [Method] Replaces the specified element with the passed element - * @param el any The id of an element, the Element itself, the index of the element in this composite to replace. - * @param replacement any The id of an element or the Element itself. - * @param domReplace any True to remove and replace the element in the document too. - */ - replaceElement?( el?:any, replacement?:any, domReplace?:any ): any; - replaceElement?( el?:string, replacement?:string, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:HTMLElement, replacement?:string, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:Ext.IElement, replacement?:string, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:number, replacement?:string, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:string, replacement?:Ext.IElement, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:HTMLElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:Ext.IElement, replacement?:Ext.IElement, domReplace?:boolean ): Ext.view.INodeCache; - replaceElement?( el?:number, replacement?:Ext.IElement, domReplace?:boolean ): Ext.view.INodeCache; - /** [Method] Appends prepends records depending on direction flag - * @param newRecords Ext.data.IModel[] Items to append/prepend - * @param direction Number -1' = scroll up,0` = scroll down. - * @param removeCount Number The number of records to remove from the end. if scrolling down, rows are removed from the top and the new rows are added at the bottom. - */ - scroll?( newRecords?:Ext.data.IModel[], direction?:number, removeCount?:number ): void; - } -} -declare module Ext.view { - export interface ITable extends Ext.view.IView { - /** [Config Option] (String) The base CSS class to apply to this component's element. ... */ - baseCls?: string; - /** [Config Option] (String/Object) The sizing and positioning of a Component's internal Elements is the responsibility of the Component's layout manager... */ - componentLayout?: any; - /** [Config Option] (Boolean) */ - enableTextSelection?: boolean; - /** [Config Option] (String) A CSS class to add to the first cell in every row to enable special styling for the first column. ... */ - firstCls?: string; - /** [Config Option] (String) view item (may be a wrapper) This is a required setting. ... */ - itemSelector?: string; - /** [Config Option] (String) A CSS class to add to the last cell in every row to enable special styling for the last column. ... */ - lastCls?: string; - /** [Config Option] (Boolean) True to show the dirty cell indicator when a cell has been modified. ... */ - markDirty?: boolean; - /** [Config Option] (String) A CSS class to apply to each item in the view on mouseover. ... */ - overItemCls?: string; - /** [Config Option] (String) A CSS class to apply to each selected item in the view. ... */ - selectedItemCls?: string; - /** [Config Option] (Boolean) True to stripe the rows. ... */ - stripeRows?: boolean; - /** [Config Option] (Boolean) cfg docs inherited When true the overItemCls will be applied to rows when hovered over. ... */ - trackOver?: boolean; - /** [Method] Adds a CSS Class to a specific row - * @param rowInfo HTMLElement An HTMLElement, index or instance of a model representing this row - * @param cls String - */ - addRowCls?( rowInfo?:HTMLElement, cls?:string ): void; - addRowCls?( rowInfo?:string, cls?:string ): void; - addRowCls?( rowInfo?:number, cls?:string ): void; - addRowCls?( rowInfo?:Ext.data.IModel, cls?:string ): void; - /** [Method] Sizes the passed header to fit the max content width - * @param header Ext.grid.column.IColumn The header (or index of header) to auto size. - */ - autoSizeColumn?( header?:Ext.grid.column.IColumn ): void; - autoSizeColumn?( header?:number ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Function which can be overridden which returns the data object passed to this DataView s template to render the whole - * @param records Ext.data.IModel[] An Array of Ext.data.Models to be rendered into the DataView. - * @param startIndex Number the index number of the Record being prepared for rendering. - */ - collectData?( records?:Ext.data.IModel[], startIndex?:number ): Object[]; - /** [Method] Try to focus this component - * @param selectText any If applicable, true to also select the text in this component - * @param delay any Delay the focus this number of milliseconds (true for 10 milliseconds). - */ - focus?( selectText?:any, delay?:any ): any; - focus?( selectText?:boolean, delay?:boolean ): Ext.IComponent; - focus?( selectText?:boolean, delay?:number ): Ext.IComponent; - /** [Method] Focuses a particular row and brings it into view - * @param rowIdx HTMLElement An HTMLElement template node, index of a template node, the id of a template node or the record associated with the node. - */ - focusRow?( rowIdx?:HTMLElement ): void; - focusRow?( rowIdx?:string ): void; - focusRow?( rowIdx?:number ): void; - focusRow?( rowIdx?:Ext.data.IModel ): void; - /** [Method] Returns a CSS selector which selects the outermost element s in this view */ - getBodySelector?(): void; - /** [Method] Returns a CSS selector which selects a particular column if the desired header is passed or a general cell selector - * @param header Ext.grid.column.IColumn The column for which to return the selector. If omitted, the general cell selector which matches ant cell will be returned. - */ - getCellSelector?( header?:Ext.grid.column.IColumn ): void; - /** [Method] Returns a CSS selector which selects the element s which define the width of a column - * @param header Object - */ - getColumnSizerSelector?( header?:any ): void; - /** [Method] Returns a CSS selector which selects a row which contains cells */ - getDataRowSelector?(): void; - /** [Method] Get a reference to a feature - * @param id String The id of the feature - */ - getFeature?( id?:string ): Ext.grid.feature.IFeature; - /** [Method] Returns a CSS selector which selects items of the view rendered by the rowTpl */ - getItemSelector?(): void; - /** [Method] Returns the node given the passed Record or index or node - * @param nodeInfo any The node or record - * @param dataRow any true to return the data row (not the top level row if wrapped), false to return the top level row. - */ - getNode?( nodeInfo?:any, dataRow?:any ): any; - getNode?( nodeInfo?:HTMLElement, dataRow?:boolean ): HTMLElement; - getNode?( nodeInfo?:string, dataRow?:boolean ): HTMLElement; - getNode?( nodeInfo?:number, dataRow?:boolean ): HTMLElement; - getNode?( nodeInfo?:Ext.data.IModel, dataRow?:boolean ): HTMLElement; - /** [Method] Returns a CSS selector which selects the element which contains record nodes */ - getNodeContainerSelector?(): void; - /** [Method] TODO have this use the new Ext grid CellContext class Gets the current XY position of the component s underlying el - * @param local Boolean If true the element's left and top are returned instead of page XY. - */ - getPosition?( local?:boolean ): number[]; - /** [Method] Gets a record from a node - * @param node any The node to evaluate - */ - getRecord?( node?:any ): any; - getRecord?( node?:Ext.IElement ): Ext.data.IModel; - getRecord?( node?:HTMLElement ): Ext.data.IModel; - /** [Method] Override this function to apply custom CSS classes to rows during rendering - * @param record Ext.data.IModel The record corresponding to the current row. - * @param index Number The row index. - * @param rowParams Object DEPRECATED. For row body use the getAdditionalData method of the rowbody feature. - * @param store Ext.data.IStore The store this grid is bound to - */ - getRowClass?( record?:Ext.data.IModel, index?:number, rowParams?:any, store?:Ext.data.IStore ): string; - /** [Method] Finds the index of the passed node - * @param nodeInfo any An HTMLElement template node, index of a template node, the id of a template node or a record associated with a node. - */ - indexOf?( nodeInfo?:any ): any; - indexOf?( nodeInfo?:HTMLElement ): number; - indexOf?( nodeInfo?:string ): number; - indexOf?( nodeInfo?:number ): number; - indexOf?( nodeInfo?:Ext.data.IModel ): number; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the destroy operation */ - onDestroy?(): void; - /** [Method] Refreshes the grid view */ - refresh?(): void; - /** [Method] Removes a CSS Class from a specific row - * @param rowInfo HTMLElement An HTMLElement, index or instance of a model representing this row - * @param cls String - */ - removeRowCls?( rowInfo?:HTMLElement, cls?:string ): void; - removeRowCls?( rowInfo?:string, cls?:string ): void; - removeRowCls?( rowInfo?:number, cls?:string ): void; - removeRowCls?( rowInfo?:Ext.data.IModel, cls?:string ): void; - /** [Method] Navigates from the passed record by the passed increment which may be ve or ve Skips hidden records - * @param startRec Ext.data.IModel The Record to start from. - * @param distance Number The distance to move from the record. May be +ve or -ve. - */ - walkRecs?( startRec?:Ext.data.IModel, distance?:number ): void; - /** [Method] Increments the passed row index by the passed increment which may be ve or ve Skips hidden rows - * @param startRow Number The zero-based row index to start from. - * @param distance Number The distance to move the row by. May be +ve or -ve. - */ - walkRows?( startRow?:number, distance?:number ): void; - } -} -declare module Ext.view { - export interface ITableLayout extends Ext.layout.component.IAuto { - /** [Method] Called before any calculation cycles to prepare for layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - beginLayout?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] Called to perform the calculations for this layout - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - calculate?( ownerContext?:Ext.layout.IContextItem ): void; - /** [Method] This method is called after all layouts are complete and their calculations flushed to the DOM - * @param ownerContext Ext.layout.IContextItem The context item for the layout's owner component. - */ - finishedLayout?( ownerContext?:Ext.layout.IContextItem ): void; - } -} -declare module Ext.view { - export interface IView extends Ext.view.IAbstractView { - /** [Config Option] (Number) The number of milliseconds to buffer mouseover and mouseout event handling on view items. ... */ - mouseOverOutBuffer?: number; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Un highlights the currently highlighted item if any */ - clearHighlight?(): void; - /** [Method] Focuses a node in the view - * @param rec Ext.data.IModel The record associated to the node that is to be focused. - */ - focusNode?( rec?:Ext.data.IModel ): void; - /** [Method] Highlights a given item in the View - * @param item HTMLElement The item to highlight - */ - highlightItem?( item?:HTMLElement ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Refreshes the view by reloading the data from the store and re rendering the template */ - refresh?(): void; - } -} -declare module Ext { - export interface IDataView extends Ext.view.IAbstractView { - /** [Config Option] (Number) The number of milliseconds to buffer mouseover and mouseout event handling on view items. ... */ - mouseOverOutBuffer?: number; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Un highlights the currently highlighted item if any */ - clearHighlight?(): void; - /** [Method] Focuses a node in the view - * @param rec Ext.data.IModel The record associated to the node that is to be focused. - */ - focusNode?( rec?:Ext.data.IModel ): void; - /** [Method] Highlights a given item in the View - * @param item HTMLElement The item to highlight - */ - highlightItem?( item?:HTMLElement ): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Refreshes the view by reloading the data from the store and re rendering the template */ - refresh?(): void; - } -} -declare module Ext.window { - export interface IMessageBox extends Ext.window.IWindow { - /** [Config Option] (String) The action to take when the close header tool is clicked: 'destroy' : remove the window from the DOM and destroy i... */ - closeAction?: string; - /** [Config Option] (String) An optional extra CSS class that will be added to this component's Element. ... */ - cls?: string; - /** [Config Option] (Boolean) True to constrain the window within its containing element, false to allow it to fall outside of its containing element. ... */ - constrain?: boolean; - /** [Config Option] (String) hide it by offsets. ... */ - hideMode?: string; - /** [Config Option] (Ext.enums.Layout/Object) Important: In order for child items to be correctly sized and positioned, typically a layout manager must be specifie... */ - layout?: any; - /** [Config Option] (Boolean/Object) Specify as true to allow user resizing at each edge and corner of the window, false to disable resizing. ... */ - resizable?: any; - /** [Config Option] (Boolean/Number) We want to shrinkWrap around all docked items Allows for this panel to include the dockedItems when trying to determ... */ - shrinkWrapDock?: any; - /** [Config Option] (String) The title text to be used to display in the panel header. ... */ - title?: string; - /** [Property] (Number) Button config that displays a single Cancel button ... */ - CANCEL?: number; - /** [Property] (String) The CSS class that provides the ERROR icon image ... */ - ERROR?: string; - /** [Property] (String) The CSS class that provides the INFO icon image ... */ - INFO?: string; - /** [Property] (Number) Button config that displays a single No button ... */ - NO?: number; - /** [Property] (Number) Button config that displays a single OK button ... */ - OK?: number; - /** [Property] (Number) Button config that displays OK and Cancel buttons ... */ - OKCANCEL?: number; - /** [Property] (String) The CSS class that provides the QUESTION icon image ... */ - QUESTION?: string; - /** [Property] (String) The CSS class that provides the WARNING icon image ... */ - WARNING?: string; - /** [Property] (Number) Button config that displays a single Yes button ... */ - YES?: number; - /** [Property] (Number) Button config that displays Yes and No buttons ... */ - YESNO?: number; - /** [Property] (Number) Button config that displays Yes, No and Cancel buttons ... */ - YESNOCANCEL?: number; - /** [Property] (Object) An object containing the default button text strings that can be overriden for localized language support. ... */ - buttonText?: any; - /** [Property] (Number) The default height in pixels of the message box's multiline textarea if displayed. ... */ - defaultTextHeight?: number; - /** [Property] (Number) The minimum width in pixels of the message box if it is a progress-style dialog. ... */ - minProgressWidth?: number; - /** [Property] (Number) The minimum width in pixels of the message box if it is a prompt dialog. ... */ - minPromptWidth?: number; - /** [Method] Displays a standard read only message box with an OK button comparable to the basic JavaScript alert prompt - * @param title String The title bar text - * @param msg String The message box body text - * @param fn Function The callback function invoked after the message box is closed. See show method for details. - * @param scope Object The scope (this reference) in which the callback is executed. - */ - alert?( title?:string, msg?:string, fn?:any, scope?:any ): Ext.window.IMessageBox; - /** [Method] Displays a confirmation message box with Yes and No buttons comparable to JavaScript s confirm - * @param title String The title bar text - * @param msg String The message box body text - * @param fn Function The callback function invoked after the message box is closed. See show method for details. - * @param scope Object The scope (this reference) in which the callback is executed. - */ - confirm?( title?:string, msg?:string, fn?:any, scope?:any ): Ext.window.IMessageBox; - /** [Method] Hides this Component setting it to invisible using the configured hideMode - * @param animateTarget any only valid for floating Components such as Windows or ToolTips, or regular Components which have been configured with floating: true.. The target to which the Component should animate while hiding. - * @param callback any A callback function to call after the Component is hidden. - * @param scope any The scope (this reference) in which the callback is executed. Defaults to this Component. - */ - hide?( animateTarget?:any, callback?:any, scope?:any ): any; - hide?( animateTarget?:string, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): Ext.IComponent; - hide?( animateTarget?:Ext.IComponent, callback?:any, scope?:any ): Ext.IComponent; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Displays a message box with a progress bar - * @param title String The title bar text - * @param msg String The message box body text - * @param progressText String The text to display inside the progress bar - */ - progress?( title?:string, msg?:string, progressText?:string ): Ext.window.IMessageBox; - /** [Method] Displays a message box with OK and Cancel buttons prompting the user to enter some text comparable to JavaScript s p - * @param title any The title bar text - * @param msg any The message box body text - * @param fn any The callback function invoked after the message box is closed. See show method for details. - * @param scope any The scope (this reference) in which the callback is executed. - * @param multiline any True to create a multiline textbox using the defaultTextHeight property, or the height in pixels to create the textbox/ - * @param value any Default value of the text input element - */ - prompt?( title?:any, msg?:any, fn?:any, scope?:any, multiline?:any, value?:any ): any; - prompt?( title?:string, msg?:string, fn?:any, scope?:any, multiline?:boolean, value?:string ): Ext.window.IMessageBox; - prompt?( title?:string, msg?:string, fn?:any, scope?:any, multiline?:number, value?:string ): Ext.window.IMessageBox; - /** [Method] Adds the specified icon to the dialog - * @param icon String A CSS classname specifying the icon's background image url, or empty string to clear the icon - * @param width Number The width of the icon. If not specified, the default is used - * @param height Number The height of the icon. If not specified, the default is used - */ - setIcon?( icon?:string, width?:number, height?:number ): Ext.window.IMessageBox; - /** [Method] Displays a new message box or reinitializes an existing message box based on the config options passed in - * @param config Object The following config options are supported: - */ - show?( config?:any ): Ext.window.IMessageBox; - /** [Method] Updates a progress style message box s text and progress bar - * @param value Number Any number between 0 and 1 (e.g., .5) - * @param progressText String The progress text to display inside the progress bar. - * @param msg String The message box's body text is replaced with the specified string (defaults to undefined so that any existing body text will not get overwritten by default unless a new value is passed in) - */ - updateProgress?( value?:number, progressText?:string, msg?:string ): Ext.window.IMessageBox; - /** [Method] Displays a message box with an infinitely auto updating progress bar - * @param msg String The message box body text - * @param title String The title bar text - * @param config Object A Ext.ProgressBar.wait config object - */ - wait?( msg?:string, title?:string, config?:any ): Ext.window.IMessageBox; - } -} -declare module Ext.window { - export interface IWindow extends Ext.panel.IPanel { - /** [Config Option] (String/Ext.Element) Id or element from which the window should animate while opening. ... */ - animateTarget?: any; - /** [Config Option] (Boolean/String/HTMLElement/Ext.Element) Windows render to the body on first show. ... */ - autoRender?: any; - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to display the 'close' tool button and allow the user to close the window, false to hide the button and disallow... */ - closable?: boolean; - /** [Config Option] (Boolean) True to render the window collapsed, false to render it expanded. ... */ - collapsed?: boolean; - /** [Config Option] (Boolean) inherited docs, same default True to make the panel collapsible and have an expand/collapse toggle Tool added into t... */ - collapsible?: boolean; - /** [Config Option] (Boolean) True to constrain the window within its containing element, false to allow it to fall outside of its containing element. ... */ - constrain?: boolean; - /** [Config Option] (Boolean) True to constrain the window header within its containing element (allowing the window body to fall outside of its co... */ - constrainHeader?: boolean; - /** [Config Option] (String/Number/Ext.Component) Specifies a Component to receive focus when this Window is focused. ... */ - defaultFocus?: any; - /** [Config Option] (Boolean) True to allow the window to be dragged by the header bar, false to disable dragging. ... */ - draggable?: boolean; - /** [Config Option] (Boolean) True to always expand the window when it is displayed, false to keep it in its current state (which may be collapsed)... */ - expandOnShow?: boolean; - /** [Config Option] (Boolean/Function) Set to false to disable the ghost panel during dragging the window. ... */ - ghost?: any; - /** [Config Option] (Boolean) Render this Window hidden. ... */ - hidden?: boolean; - /** [Config Option] (String) Windows hide using offsets in order to preserve the scroll positions of their descendants. ... */ - hideMode?: string; - /** [Config Option] (Boolean) True to hide this Window's shadow when another floating item in the same z-index stack is activated. ... */ - hideShadowOnDeactivate?: boolean; - /** [Config Option] (Boolean) True to display the 'maximize' tool button and allow the user to maximize the window, false to hide the button and di... */ - maximizable?: boolean; - /** [Config Option] (Boolean) True to initially display the window in a maximized state. ... */ - maximized?: boolean; - /** [Config Option] (Number) inherit docs The minimum value in pixels which this Component will set its height to. ... */ - minHeight?: number; - /** [Config Option] (Number) inherit docs The minimum value in pixels which this Component will set its width to. ... */ - minWidth?: number; - /** [Config Option] (Boolean) True to display the 'minimize' tool button and allow the user to minimize the window, false to hide the button and di... */ - minimizable?: boolean; - /** [Config Option] (Boolean) True to make the window modal and mask everything behind it when displayed, false to display it without restricting a... */ - modal?: boolean; - /** [Config Option] (Function) Allows override of the built-in processing for the escape key. ... */ - onEsc?: any; - /** [Config Option] (Boolean) True to overlap the header in a panel over the framing of the panel itself. ... */ - overlapHeader?: boolean; - /** [Config Option] (Boolean) True to render the window body with a transparent background so that it will blend into the framing elements, false t... */ - plain?: boolean; - /** [Config Option] (Boolean/Object) Specify as true to allow user resizing at each edge and corner of the window, false to disable resizing. ... */ - resizable?: any; - /** [Config Option] (Number) The X position of the left edge of the window on initial showing. ... */ - x?: number; - /** [Config Option] (Number) The Y position of the top edge of the window on initial showing. ... */ - y?: number; - /** [Property] (Ext.util.ComponentDragger) If this Window is configured draggable, this property will contain an instance of Ext.util.ComponentDragger (A subcla... */ - dd?: Ext.util.IComponentDragger; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Window, or subclass thereof. ... */ - isWindow?: boolean; - /** [Method] Invoked after the Panel is Collapsed - * @param animated Boolean - */ - afterCollapse?( animated?:boolean ): void; - /** [Method] Invoked after the Panel is Expanded - * @param animated Boolean - */ - afterExpand?( animated?:boolean ): void; - /** [Method] Invoked after the Component has been hidden - * @param callback Function - * @param scope Object - */ - afterHide?( callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Occurs before componentLayout is run */ - beforeLayout?(): void; - /** [Method] Gets the configured default focus item */ - getDefaultFocus?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Fits the window within its current container and automatically replaces the maximize tool button with the restore - * @param animate Boolean true to animate this Window to full size. - */ - maximize?( animate?:boolean ): Ext.window.IWindow; - /** [Method] Placeholder method for minimizing the window */ - minimize?(): Ext.window.IWindow; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Restores a maximized window back to its original size and position prior to being maximized and also replaces the re - * @param animate Object - */ - restore?( animate?:any ): Ext.window.IWindow; - /** [Method] A shortcut method for toggling between maximize and restore based on the current maximized state of the window */ - toggleMaximize?(): Ext.window.IWindow; - } -} -declare module Ext { - export interface IWindow extends Ext.panel.IPanel { - /** [Config Option] (String/Ext.Element) Id or element from which the window should animate while opening. ... */ - animateTarget?: any; - /** [Config Option] (Boolean/String/HTMLElement/Ext.Element) Windows render to the body on first show. ... */ - autoRender?: any; - /** [Config Option] (String) The base CSS class to apply to this panel's element. ... */ - baseCls?: string; - /** [Config Option] (Boolean) True to display the 'close' tool button and allow the user to close the window, false to hide the button and disallow... */ - closable?: boolean; - /** [Config Option] (Boolean) True to render the window collapsed, false to render it expanded. ... */ - collapsed?: boolean; - /** [Config Option] (Boolean) inherited docs, same default True to make the panel collapsible and have an expand/collapse toggle Tool added into t... */ - collapsible?: boolean; - /** [Config Option] (Boolean) True to constrain the window within its containing element, false to allow it to fall outside of its containing element. ... */ - constrain?: boolean; - /** [Config Option] (Boolean) True to constrain the window header within its containing element (allowing the window body to fall outside of its co... */ - constrainHeader?: boolean; - /** [Config Option] (String/Number/Ext.Component) Specifies a Component to receive focus when this Window is focused. ... */ - defaultFocus?: any; - /** [Config Option] (Boolean) True to allow the window to be dragged by the header bar, false to disable dragging. ... */ - draggable?: boolean; - /** [Config Option] (Boolean) True to always expand the window when it is displayed, false to keep it in its current state (which may be collapsed)... */ - expandOnShow?: boolean; - /** [Config Option] (Boolean/Function) Set to false to disable the ghost panel during dragging the window. ... */ - ghost?: any; - /** [Config Option] (Boolean) Render this Window hidden. ... */ - hidden?: boolean; - /** [Config Option] (String) Windows hide using offsets in order to preserve the scroll positions of their descendants. ... */ - hideMode?: string; - /** [Config Option] (Boolean) True to hide this Window's shadow when another floating item in the same z-index stack is activated. ... */ - hideShadowOnDeactivate?: boolean; - /** [Config Option] (Boolean) True to display the 'maximize' tool button and allow the user to maximize the window, false to hide the button and di... */ - maximizable?: boolean; - /** [Config Option] (Boolean) True to initially display the window in a maximized state. ... */ - maximized?: boolean; - /** [Config Option] (Number) inherit docs The minimum value in pixels which this Component will set its height to. ... */ - minHeight?: number; - /** [Config Option] (Number) inherit docs The minimum value in pixels which this Component will set its width to. ... */ - minWidth?: number; - /** [Config Option] (Boolean) True to display the 'minimize' tool button and allow the user to minimize the window, false to hide the button and di... */ - minimizable?: boolean; - /** [Config Option] (Boolean) True to make the window modal and mask everything behind it when displayed, false to display it without restricting a... */ - modal?: boolean; - /** [Config Option] (Function) Allows override of the built-in processing for the escape key. ... */ - onEsc?: any; - /** [Config Option] (Boolean) True to overlap the header in a panel over the framing of the panel itself. ... */ - overlapHeader?: boolean; - /** [Config Option] (Boolean) True to render the window body with a transparent background so that it will blend into the framing elements, false t... */ - plain?: boolean; - /** [Config Option] (Boolean/Object) Specify as true to allow user resizing at each edge and corner of the window, false to disable resizing. ... */ - resizable?: any; - /** [Config Option] (Number) The X position of the left edge of the window on initial showing. ... */ - x?: number; - /** [Config Option] (Number) The Y position of the top edge of the window on initial showing. ... */ - y?: number; - /** [Property] (Ext.util.ComponentDragger) If this Window is configured draggable, this property will contain an instance of Ext.util.ComponentDragger (A subcla... */ - dd?: Ext.util.IComponentDragger; - /** [Property] (Boolean) true in this class to identify an object as an instantiated Window, or subclass thereof. ... */ - isWindow?: boolean; - /** [Method] Invoked after the Panel is Collapsed - * @param animated Boolean - */ - afterCollapse?( animated?:boolean ): void; - /** [Method] Invoked after the Panel is Expanded - * @param animated Boolean - */ - afterExpand?( animated?:boolean ): void; - /** [Method] Invoked after the Component has been hidden - * @param callback Function - * @param scope Object - */ - afterHide?( callback?:any, scope?:any ): void; - /** [Method] Allows addition of behavior after rendering is complete */ - afterRender?(): void; - /** [Method] Applies the state to the object - * @param state Object The state - */ - applyState?( state?:any ): void; - /** [Method] Invoked before the Component is destroyed */ - beforeDestroy?(): void; - /** [Method] Occurs before componentLayout is run */ - beforeLayout?(): void; - /** [Method] Gets the configured default focus item */ - getDefaultFocus?(): void; - /** [Method] The initComponent template method is an important initialization step for a Component */ - initComponent?(): void; - /** [Method] Fits the window within its current container and automatically replaces the maximize tool button with the restore - * @param animate Boolean true to animate this Window to full size. - */ - maximize?( animate?:boolean ): Ext.window.IWindow; - /** [Method] Placeholder method for minimizing the window */ - minimize?(): Ext.window.IWindow; - /** [Method] Template method called when this Component s DOM structure is created - * @param parentNode Ext.core.IElement The parent Element in which this Component's encapsulating element is contained. - * @param containerIdx Number The index within the parent Container's child collection of this Component. - */ - onRender?( parentNode?:Ext.core.IElement, containerIdx?:number ): void; - /** [Method] Allows addition of behavior to the show operation - * @param animateTarget String - * @param callback Function - * @param scope Object - */ - onShow?( animateTarget?:string, callback?:any, scope?:any ): void; - onShow?( animateTarget?:Ext.IElement, callback?:any, scope?:any ): void; - /** [Method] Restores a maximized window back to its original size and position prior to being maximized and also replaces the re - * @param animate Object - */ - restore?( animate?:any ): Ext.window.IWindow; - /** [Method] A shortcut method for toggling between maximize and restore based on the current maximized state of the window */ - toggleMaximize?(): Ext.window.IWindow; - } -} -declare module Ext { - export interface IWindowManager extends Ext.IZIndexManager { - } - export class WindowManager { - } -} -declare module Ext { - export interface IXTemplate extends Ext.ITemplate { - /** [Config Option] (String/Array) Optional. ... */ - definitions?: any; - /** [Method] Appends the result of this template to the provided output array - * @param values any The template values. See apply. - * @param out Array The array to which output is pushed. - */ - applyOut?( values?:any, out?:any[] ): any[]; - /** [Method] Does nothing */ - compile?(): Ext.IXTemplate; - } -} -declare module Ext { - export interface IXTemplateCompiler extends Ext.IXTemplateParser { - /** [Method] This method is called to process lt tpl case action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doCase?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl default gt */ - doDefault?(): void; - /** [Method] This method is called to process lt tpl else gt */ - doElse?(): void; - /** [Method] This method is called to process lt tpl elseif action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doElseIf?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl gt - * @param type String The type of action that is being ended. - * @param actions Object The other actions keyed by the attribute name (such as 'exec'). - */ - doEnd?( type?:string, actions?:any ): void; - /** [Method] This method is called to process text - * @param text String - */ - doEval?( text?:string ): void; - /** [Method] This method is called to process lt tpl exec action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name. - */ - doExec?( action?:string, actions?:any ): void; - /** [Method] This method is called to process expressions like expr - * @param expr String The body of the expression (inside "{[" and "]}"). - */ - doExpr?( expr?:string ): void; - /** [Method] This method is called to process lt tpl for action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doFor?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl foreach action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doForEach?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl if action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doIf?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl switch action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doSwitch?( action?:string, actions?:any ): void; - /** [Method] This method is called to process simple tags like tag */ - doTag?(): void; - /** [Method] XTemplateParser callouts This method is called to process a piece of raw text from the tpl - * @param text String - */ - doText?( text?:string ): void; - } -} -declare module Ext { - export interface IXTemplateParser extends Ext.IBase { - /** [Property] (Number) The 'for' or 'foreach' loop context level. ... */ - level?: number; - /** [Method] This method is called to process lt tpl case action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doCase?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl default gt */ - doDefault?(): void; - /** [Method] This method is called to process lt tpl else gt */ - doElse?(): void; - /** [Method] This method is called to process lt tpl elseif action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doElseIf?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl gt - * @param type String The type of action that is being ended. - * @param actions Object The other actions keyed by the attribute name (such as 'exec'). - */ - doEnd?( type?:string, actions?:any ): void; - /** [Method] This method is called to process text - * @param text String - */ - doEval?( text?:string ): void; - /** [Method] This method is called to process lt tpl exec action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name. - */ - doExec?( action?:string, actions?:any ): void; - /** [Method] This method is called to process expressions like expr - * @param expr String The body of the expression (inside "{[" and "]}"). - */ - doExpr?( expr?:string ): void; - /** [Method] This method is called to process lt tpl for action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doFor?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl foreach action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doForEach?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl if action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doIf?( action?:string, actions?:any ): void; - /** [Method] This method is called to process lt tpl switch action gt - * @param action String - * @param actions Object Other actions keyed by the attribute name (such as 'exec'). - */ - doSwitch?( action?:string, actions?:any ): void; - /** [Method] This method is called to process simple tags like tag */ - doTag?(): void; - /** [Method] This method is called to process a piece of raw text from the tpl - * @param text String - */ - doText?( text?:string ): void; - /** [Method] This method is called to process an empty lt tpl gt */ - doTpl?(): void; - } -} -declare module Ext { - export interface IZIndexManager extends Ext.IBase { - /** [Method] Brings the specified Component to the front of any other active Components in this ZIndexManager - * @param comp any The id of the Component or a Ext.Component instance - */ - bringToFront?( comp?:any ): boolean; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - eachBottomUp?( fn?:any, scope?:any ): void; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - eachTopDown?( fn?:any, scope?:any ): void; - /** [Method] Gets a registered Component by id - * @param id any The id of the Component or a Ext.Component instance - */ - get?( id?:any ): Ext.IComponent; - /** [Method] Gets the currently active Component in this ZIndexManager */ - getActive?(): Ext.IComponent; - /** [Method] Returns zero or more Components in this ZIndexManager using the custom search function passed to this method - * @param fn Function The search function - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Component being tested. That gets passed to the function if not specified. - */ - getBy?( fn?:any, scope?:any ): any[]; - /** [Method] Hides all Components managed by this ZIndexManager */ - hideAll?(): void; - /** [Method] Registers a floating Ext Component with this ZIndexManager - * @param comp Ext.IComponent The Component to register. - */ - register?( comp?:Ext.IComponent ): void; - /** [Method] Sends the specified Component to the back of other active Components in this ZIndexManager - * @param comp any The id of the Component or a Ext.Component instance - */ - sendToBack?( comp?:any ): Ext.IComponent; - /** [Method] Unregisters a Ext Component from this ZIndexManager - * @param comp Ext.IComponent The Component to unregister. - */ - unregister?( comp?:Ext.IComponent ): void; - } -} -declare module Ext { - export interface IWindowGroup extends Ext.IBase { - /** [Method] Brings the specified Component to the front of any other active Components in this ZIndexManager - * @param comp any The id of the Component or a Ext.Component instance - */ - bringToFront?( comp?:any ): boolean; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - each?( fn?:any, scope?:any ): void; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - eachBottomUp?( fn?:any, scope?:any ): void; - /** [Method] Executes the specified function once for every Component in this ZIndexManager passing each Component as the only pa - * @param fn Function The function to execute for each item - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the current Component in the iteration. - */ - eachTopDown?( fn?:any, scope?:any ): void; - /** [Method] Gets a registered Component by id - * @param id any The id of the Component or a Ext.Component instance - */ - get?( id?:any ): Ext.IComponent; - /** [Method] Gets the currently active Component in this ZIndexManager */ - getActive?(): Ext.IComponent; - /** [Method] Returns zero or more Components in this ZIndexManager using the custom search function passed to this method - * @param fn Function The search function - * @param scope Object The scope (this reference) in which the function is executed. Defaults to the Component being tested. That gets passed to the function if not specified. - */ - getBy?( fn?:any, scope?:any ): any[]; - /** [Method] Hides all Components managed by this ZIndexManager */ - hideAll?(): void; - /** [Method] Registers a floating Ext Component with this ZIndexManager - * @param comp Ext.IComponent The Component to register. - */ - register?( comp?:Ext.IComponent ): void; - /** [Method] Sends the specified Component to the back of other active Components in this ZIndexManager - * @param comp any The id of the Component or a Ext.Component instance - */ - sendToBack?( comp?:any ): Ext.IComponent; - /** [Method] Unregisters a Ext Component from this ZIndexManager - * @param comp Ext.IComponent The Component to unregister. - */ - unregister?( comp?:Ext.IComponent ): void; - } -} diff --git a/fabricjs/fabricjs-tests.ts b/fabricjs/fabricjs-tests.ts index b230e2249..df0d217e8 100644 --- a/fabricjs/fabricjs-tests.ts +++ b/fabricjs/fabricjs-tests.ts @@ -8,10 +8,10 @@ function sample1() { canvas.on({ 'object:moving': function (e) { - e.target.opacity = 0.5; + (e.target).opacity = 0.5; }, 'object:modified': function (e) { - e.target.opacity = 1; + (e.target).opacity = 1; } }); diff --git a/gamepad/gamepad-tests.ts b/gamepad/gamepad-tests.ts index 7491d7970..e6ca9d272 100644 --- a/gamepad/gamepad-tests.ts +++ b/gamepad/gamepad-tests.ts @@ -18,7 +18,7 @@ window.requestAnimationFrame(runAnimation); }; -()=>{ +(()=>{ window.addEventListener('GamepadConnected', (e: GamepadEvent)=>{ console.log('Gamepad ' + e.gamepad.index + ' connected!'); }, false); @@ -69,4 +69,4 @@ runAnimation(); } -}(); \ No newline at end of file +})(); \ No newline at end of file diff --git a/gldatepicker/gldatepicker.d.ts b/gldatepicker/gldatepicker.d.ts index 34781491f..3ed84c219 100644 --- a/gldatepicker/gldatepicker.d.ts +++ b/gldatepicker/gldatepicker.d.ts @@ -64,6 +64,6 @@ interface GlDatePicker { } interface JQuery { - glDatePicker(options?: GlDatePickerOptions): JQuery; - glDatePicker(ret: boolean): GlDatePicker; + glDatePicker(ret: boolean): GlDatePicker; + glDatePicker(options?: GlDatePickerOptions): JQuery; } \ No newline at end of file diff --git a/greasemonkey/greasemonkey-tests.ts b/greasemonkey/greasemonkey-tests.ts index 914c8f4e3..a0185c4a4 100644 --- a/greasemonkey/greasemonkey-tests.ts +++ b/greasemonkey/greasemonkey-tests.ts @@ -96,9 +96,9 @@ GM_xmlhttpRequest({ "Accept": "text/xml" // If not specified, browser defaults will be used. }, onload: function(response) { - var responseXML = response.responseXML; + var responseXML = (response).responseXML; // Inject responseXML into existing Object (only appropriate for XML content). - if (!response.responseXML) { + if (!responseXML) { responseXML = new DOMParser() .parseFromString(response.responseText, "text/xml"); } @@ -205,7 +205,7 @@ var finalUrl: string = syncResult.finalUrl; var readyState: number = syncResult.readyState; var responseHeaders: string = syncResult.responseHeaders; var responseText: string = syncResult.responseText; -var status: number = syncResult.status; +(function() { var status: number = syncResult.status; })(); // conflict with state defined in lib.d.ts var statusText: string = syncResult.statusText; //// Asynchronous diff --git a/gruntjs/gruntjs.d.ts b/gruntjs/gruntjs.d.ts index be08cb237..e67618910 100644 --- a/gruntjs/gruntjs.d.ts +++ b/gruntjs/gruntjs.d.ts @@ -1,6 +1,6 @@ // Type definitions for Grunt 0.4.x // Project: http://gruntjs.com -// Definitions by: Jeff May +// Definitions by: Jeff May , Basarat Ali Syed // Definitions: https://github.com/jeffmay/DefinitelyTyped /// @@ -117,27 +117,14 @@ declare module minimatch { declare module grunt { module config { - + /** * {@link http://gruntjs.com/sample-gruntfile} */ - interface IProjectConfig extends IConfigOptionFormat { - pkg: string - } - - /** - * @see IProjectConfig - */ - interface IConfigOptionFormat { - [plugin: string]: IConfigPluginFormat - } - - /** - * A map of plugin task names to config objects. - */ - interface IConfigPluginFormat { - [task: string]: grunt.task.ITaskOptions - } + interface IProjectConfig{ + [plugin: string]: any + pkg: any; // unfortunate. It is actually a string + } /** * {@link http://gruntjs.com/api/grunt.config} diff --git a/handlebars/handlebars-tests.ts b/handlebars/handlebars-tests.ts index 1846f943d..937f93191 100644 --- a/handlebars/handlebars-tests.ts +++ b/handlebars/handlebars-tests.ts @@ -10,7 +10,7 @@ var context = { body: 'Me too!' }] }; -Handlebars.registerHelper('fullName', (person) => { +Handlebars.registerHelper('fullName', (person: typeof context.author) => { return person.firstName + ' ' + person.lastName; }); @@ -28,17 +28,18 @@ var data = { 'name': 'Alan', 'hometown': 'Somewhere, TX', 'kids': [{'name': 'Jimmy', 'age': '12'}, {'name': 'Sally', 'age': '4'}]}; var result = template(data); -Handlebars.registerHelper('link_to', (context) => { +Handlebars.registerHelper('link_to', (context: typeof post) => { return '' + context.body + ''; }); -var context2 = { posts: [{url: '/hello-world', body: 'Hello World!'}] }; +var post = { url: '/hello-world', body: 'Hello World!' }; +var context2 = { posts: [post] }; var source2 = '
    {{#posts}}
  • {{{link_to this}}}
    • {{/posts}}
'; var template2 = Handlebars.compile(source2); template2(context2); -Handlebars.registerHelper('link_to', (title, context) => { +Handlebars.registerHelper('link_to', (title: string, context: typeof post) => { return '' + title + '!'; }); @@ -48,7 +49,7 @@ var template3 = Handlebars.compile(source3); template3(context3); var source4 = '
    {{#people}}
  • {{#link}}{{name}}{{/link}}
    • {{/people}}
'; -Handlebars.registerHelper('link', function(context) { +Handlebars.registerHelper('link', function(context: any) { return '' + context.fn(this) + ''; }); var template4 = Handlebars.compile(source4); @@ -67,13 +68,13 @@ var data3 = { 'people': [ ]}; template5(data3); -Handlebars.registerHelper('list', (items, fn) => { +Handlebars.registerHelper('list', (items: any, fn: (item: any) => string) => { var out = '
    '; for(var i=0, l=items.length; i' + fn(items[i]) + ''; } return out + '
'; }); -Handlebars.registerHelper('fullName', (person) => { +Handlebars.registerHelper('fullName', (person: typeof context.author) => { return person.firstName + ' ' + person.lastName; }); diff --git a/i18next/i18next-tests.ts b/i18next/i18next-tests.ts index 7a07ed829..2b4ce5a45 100644 --- a/i18next/i18next-tests.ts +++ b/i18next/i18next-tests.ts @@ -24,7 +24,6 @@ describe('i18next', function () { dynamicLoad: false, useLocalStorage: false, sendMissing: false, - resStore: false, getAsync: true, returnObjectTrees: false, debug: true, diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts index 614a950fb..8de0366e7 100644 --- a/ix.js/ix.d.ts +++ b/ix.js/ix.d.ts @@ -48,7 +48,7 @@ declare module Ix { startWith(...values: T[]): Enumerable; - scan(seed: TSeed, accumulate: (acc: TAccumulator, item: T) => TAccumulator): Enumerable; + scan(seed: TAccumulate, accumulate: (acc: TAccumulate, item: T) => TAccumulate): Enumerable; scan(accumulate: (acc: T, item: T) => T): Enumerable; takeLast(count: number): Enumerable; diff --git a/ix.js/l2o-tests.ts b/ix.js/l2o-tests.ts index 2399d4e9f..41cc7bdc4 100644 --- a/ix.js/l2o-tests.ts +++ b/ix.js/l2o-tests.ts @@ -41,7 +41,8 @@ ax.aggregate("", (acc, i) => acc + i, acc=> acc.length); ax.aggregate("", (acc, i) => acc + i); ax.aggregate((acc, i) => acc + i); -ax.reduce((acc, i) => acc + i, 100); +//ax.reduce((acc, i) => acc + i, 100); // bug: https://typescript.codeplex.com/workitem/1960 +ax.reduce((acc, i) => acc + i, 100); ax.reduce((acc, i) => acc + i); ax.all(item => true); @@ -83,7 +84,7 @@ dx.distinct((d1, d2) => d1 === d2); ax.elementAt(2); ax.elementAtOrDefault(2); -//ax.except(bx, ec_ns); // bug https://typescript.codeplex.com/workitem/1841 +ax.except(bx, ec_ns); bx.except(fx); ax.first(); @@ -96,14 +97,14 @@ ax.singleOrDefault(); ax.forEach(a => console.log(a)); ax.forEach(a => console.log(a), cx); -//bx.groupBy(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.groupBy(b => b.length); bx.groupBy(b => b.length, b => "[" + b + "]"); bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count()); bx.groupBy(b => b.length, false, (l, values) => l + values.count()); bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count(), ec_nn); bx.groupBy(b => b.length, b => "[" + b + "]", false, (x, y) => x == y); bx.groupBy(b => b.length, false, (l, values) => l + values.count(), ec_nn); -//bx.groupBy(b => b.length, false, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.groupBy(b => b.length, false, false, ec_nn); ax.groupJoin(bx, a => a, b => b, (a, b) => [a, b], ec_ns); ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]); @@ -111,7 +112,7 @@ ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]); ax.join(bx, a => a, b => b, (a, b) => [a, b], ec_ns); ax.join(bx, a => a, b => b.length, (a, b) => [a, b]); -//ax.intersect(bx, ec_ns); // bug https://typescript.codeplex.com/workitem/1841 +ax.intersect(bx, ec_ns); ax.intersect(cx); ax.union(cx); @@ -142,14 +143,14 @@ ax.takeWhile(a => a > 10); ax.toArray(); bx.toDictionary(b => b.length, b => 10, ec_nn); -//bx.toDictionary(b => b.length, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.toDictionary(b => b.length, false, ec_nn); bx.toDictionary(b => b.length, b => 10); -//bx.toDictionary(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.toDictionary(b => b.length); bx.toLookup(b => b.length, b => 10, ec_nn); -//bx.toLookup(b => b.length, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.toLookup(b => b.length, false, ec_nn); bx.toLookup(b => b.length, b => 10); -//bx.toLookup(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal +bx.toLookup(b => b.length); ax.where(a=> a > 10, {}); ax.where(a=> a > 10); diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts index c3f3c415e..d36cb2530 100644 --- a/ix.js/l2o.d.ts +++ b/ix.js/l2o.d.ts @@ -91,9 +91,8 @@ declare module Ix { groupBy( keySelector: (item: T) => TKey, elementSelector: (item: T) => TElement): Grouping; - // spec 3.5.2, waiting for restriction on generative recursion removal - /*groupBy( - keySelector: (item: T) => TKey): Grouping;*/ + groupBy( + keySelector: (item: T) => TKey): Grouping; // if need to set comparer without resultSelector groupBy( @@ -108,12 +107,11 @@ declare module Ix { resultSelector: (key: TKey, values: Enumerable) => TResult, comparer?: EqualityComparer): Enumerable; // if need to set comparer without elementSelector and resultSelector - // spec 3.5.2, waiting for restriction on generative recursion removal - /*groupBy( + groupBy( keySelector: (item: T) => TKey, _: boolean, __: boolean, - comparer: EqualityComparer): Grouping;*/ + comparer: EqualityComparer): Grouping; groupJoin( inner: Enumerable, @@ -169,29 +167,25 @@ declare module Ix { keySelector: (item: T) => TKey, elementSelector: (item: T) => TValue, comparer?: EqualityComparer): Dictionary; - // spec 3.5.2, waiting for restriction on generative recursion removal - /*toDictionary( - keySelector: (item: T) => TKey): Dictionary;*/ + toDictionary( + keySelector: (item: T) => TKey): Dictionary; // if need to set comparer without elementSelector - // spec 3.5.2, waiting for restriction on generative recursion removal - /*toDictionary( + toDictionary( keySelector: (item: T) => TKey, _: boolean, - comparer: EqualityComparer): Dictionary;*/ + comparer: EqualityComparer): Dictionary; toLookup( keySelector: (item: T) => TKey, elementSelector: (item: T) => TValue, comparer?: EqualityComparer): Lookup; - // spec 3.5.2, waiting for restriction on generative recursion removal - /*toLookup( - keySelector: (item: T) => TKey): Lookup;*/ + toLookup( + keySelector: (item: T) => TKey): Lookup; // if need to set comparer without elementSelector - // spec 3.5.2, waiting for restriction on generative recursion removal - /*toLookup( + toLookup( keySelector: (item: T) => TKey, _: boolean, - comparer: EqualityComparer): Lookup;*/ + comparer: EqualityComparer): Lookup; where(selector: EnumerablePredicate, thisArg?: any): Enumerable; filter(selector: EnumerablePredicate, thisArg?: any): Enumerable; diff --git a/jake/jake-tests.ts b/jake/jake-tests.ts index 74e5cc92f..3459083dc 100644 --- a/jake/jake-tests.ts +++ b/jake/jake-tests.ts @@ -9,7 +9,7 @@ task('default', function (params) { }); desc('This task has prerequisites.'); -task('hasPrereqs', ['foo', 'bar', 'baz'], function (params) { +task('hasPrereqs', ['foo', 'bar', 'baz'], function () { console.log('Ran some prereqs first.'); }); diff --git a/jointjs/jointjs.d.ts b/jointjs/jointjs.d.ts index 547263021..88c67290c 100644 --- a/jointjs/jointjs.d.ts +++ b/jointjs/jointjs.d.ts @@ -34,7 +34,7 @@ declare module joint { embed(cell: Cell); unembed(cell: Cell); getEmbeddedCells(): Cell[]; - clone(opt?: any): T; // @todo: return can either be Cell or Cell[]. + clone(opt?: any): Backbone.Model; // @todo: return can either be Cell or Cell[]. attr(attrs: any): Cell; } diff --git a/jqrangeslider/jqrangeslider.d.ts b/jqrangeslider/jqrangeslider.d.ts index 7dcb3060f..ef688e5d9 100644 --- a/jqrangeslider/jqrangeslider.d.ts +++ b/jqrangeslider/jqrangeslider.d.ts @@ -57,18 +57,18 @@ interface JQDateRangeSliderOptions extends JQRangeSliderOptions { } interface JQuery { - rangeSlider(options?: JQNumericRangeSliderOptions): JQuery; rangeSlider(method: string): any; rangeSlider(method: string, value: number): JQuery; rangeSlider(method: string, min: number, max: number): JQuery; + rangeSlider(options?: JQNumericRangeSliderOptions): JQuery; - editRangeSlider(options?: JQNumericRangeSliderOptions): JQuery; editRangeSlider(method: string): any; editRangeSlider(method: string, value: number): JQuery; - editRangeSlider(method: string, min: number, max: number): JQuery; + editRangeSlider(method: string, min: number, max: number): JQuery + editRangeSlider(options?: JQNumericRangeSliderOptions): JQuery; - dateRangeSlider(options?: JQRangeSliderOptions): JQuery; dateRangeSlider(method: string): any; dateRangeSlider(method: string, value: Date): JQuery; - dateRangeSlider(method: string, min: Date, max: Date): JQuery; + dateRangeSlider(method: string, min: Date, max: Date): JQuery + dateRangeSlider(options?: JQRangeSliderOptions): JQuery; } diff --git a/jquery.bbq/jquery.bbq-tests.ts b/jquery.bbq/jquery.bbq-tests.ts index c9a337d71..6bf301f3c 100644 --- a/jquery.bbq/jquery.bbq-tests.ts +++ b/jquery.bbq/jquery.bbq-tests.ts @@ -587,7 +587,7 @@ QUnit.module( 'jQuery.fn' ); $.elemUrlAttr({ span: 'arbitrary_attr' }); var test_elems = 'a form link span'.split(' '); -function init_url_attr( container, url ) { +function init_url_attr( _, url ) { var container = $('
').hide().appendTo('body'); $.each( test_elems, function(i,v){ $('<' + v + '/>') diff --git a/jquery.gridster/gridster.d.ts b/jquery.gridster/gridster.d.ts index 6019ebb06..968c0f333 100644 --- a/jquery.gridster/gridster.d.ts +++ b/jquery.gridster/gridster.d.ts @@ -138,7 +138,7 @@ interface GridsterOptions { /** * Return the data you want for each widget in the serialization. **/ - serialize_params?: ($w: JQuery, wgd: GridsterCoords) => T; + serialize_params?: ($w: JQuery, wgd: GridsterCoords) => any; /** * An object with all options for Collision class you want to overwrite. @see GridsterCollision or docs for more info. diff --git a/jquery.tinycarousel/jquery.tinycarousel.d.ts b/jquery.tinycarousel/jquery.tinycarousel.d.ts index 83a030107..2f4f4563a 100644 --- a/jquery.tinycarousel/jquery.tinycarousel.d.ts +++ b/jquery.tinycarousel/jquery.tinycarousel.d.ts @@ -50,7 +50,7 @@ declare module JQueryTinyCarousel { /** * Function that executes after every move (default: null) */ - callback? : Function; + callback? : (element: HTMLElement, index: number) => void; } } interface JQuery { diff --git a/jquery.validation/jquery.validation-tests.ts b/jquery.validation/jquery.validation-tests.ts index b8f7a16ae..cfb10489b 100644 --- a/jquery.validation/jquery.validation-tests.ts +++ b/jquery.validation/jquery.validation-tests.ts @@ -140,14 +140,14 @@ function test_validate() { } }); $(".selector").validate({ - highlight: function (element, errorClass, validClass) { + highlight: function (element: HTMLInputElement, errorClass, validClass) { $(element).addClass(errorClass).removeClass(validClass); - $(element.form).find("label[for=" + element.id + "]") + $((element).form).find("label[for=" + element.id + "]") .addClass(errorClass); }, - unhighlight: function (element, errorClass, validClass) { + unhighlight: function (element: HTMLInputElement, errorClass, validClass) { $(element).removeClass(errorClass).addClass(validClass); - $(element.form).find("label[for=" + element.id + "]") + $((element).form).find("label[for=" + element.id + "]") .removeClass(errorClass); } }); diff --git a/jquery/jquery-tests.ts b/jquery/jquery-tests.ts index 0a935ce44..728d9d06f 100644 --- a/jquery/jquery-tests.ts +++ b/jquery/jquery-tests.ts @@ -2372,7 +2372,8 @@ function test_EventIsCallable() { var ev = jQuery.Event('click'); } -$.when($.ajax("/my/page.json")).then((a,b,c) => a.asdf); // is type JQueryPromise +$.when($.ajax("/my/page.json")).then(a => a.asdf); // is type JQueryPromise +$.when($.ajax("/my/page.json")).then((a?,b?,c?) => a.asdf); // is type JQueryPromise $.when("asdf", "jkl;").done((x,y) => x.length + y.length, (x,y) => x.length + y.length); var f1 = $.when("fetch"); // Is type JQueryPromise diff --git a/jquery/jquery.d.ts b/jquery/jquery.d.ts index e68d50e36..e8a050194 100644 --- a/jquery/jquery.d.ts +++ b/jquery/jquery.d.ts @@ -863,7 +863,8 @@ interface JQuery { toggle(showOrHide: boolean): JQuery; // Events - bind(eventType: string, eventData?: any, handler?: (eventObject: JQueryEventObject) => any): JQuery; + bind(eventType: string, eventData: any, handler: (eventObject: JQueryEventObject) => any): JQuery; + bind(eventType: string, handler: (eventObject: JQueryEventObject) => any): JQuery; bind(eventType: string, eventData: any, preventBubble: boolean): JQuery; bind(eventType: string, preventBubble: boolean): JQuery; bind(...events: any[]): JQuery; diff --git a/knockout.rx/knockout.rx.d.ts b/knockout.rx/knockout.rx.d.ts index 4f44153d8..e9c85a7f8 100644 --- a/knockout.rx/knockout.rx.d.ts +++ b/knockout.rx/knockout.rx.d.ts @@ -3,7 +3,7 @@ // Definitions by: Igor Oleinikov /// -/// +/// interface KnockoutSubscribableFunctions { toObservable(event?: string): Rx.IObservable; diff --git a/knockout/knockout.amd.d.ts b/knockout/knockout.amd.d.ts deleted file mode 100644 index d2aa8ac5b..000000000 --- a/knockout/knockout.amd.d.ts +++ /dev/null @@ -1,90 +0,0 @@ -// Type definitions for Knockout 2.2 (as an AMD module) -// Project: http://knockoutjs.com -// Definitions by: Boris Yankov -// Definitions: https://github.com/borisyankov/DefinitelyTyped -/// - -declare module 'knockout' { - export var utils: KnockoutUtils; - export var memoization: KnockoutMemoization; - export var bindingHandlers: KnockoutBindingHandlers; - export var virtualElements: KnockoutVirtualElements; - export var extenders: KnockoutExtenders; - export function applyBindings(viewModel: any, rootNode?: any): void; - export function applyBindingsToDescendants(viewModel: any, rootNode: any): void; - export function applyBindingsToNode(node: Element, options: any, viewModel: any): void; - export var subscribable: KnockoutSubscribableStatic; - export var observable: KnockoutObservableStatic; - export var computed: KnockoutComputedStatic; - export var observableArray: KnockoutObservableArrayStatic; - export function contextFor(node: any): any; - export function isSubscribable(instance: any): boolean; - export function toJSON(viewModel: any, replacer?: Function, space?: any): string; - export function toJS(viewModel: any): any; - export function isObservable(instance: any): boolean; - export function isComputed(instance: any): boolean; - export function dataFor(node: any): any; - export function removeNode(node: Element): void; - export function cleanNode(node: Element): Element; - export function renderTemplate(template: Function, viewModel: any, options?: any, target?: any, renderMode?: any): any; - export function renderTemplate(template: string, viewModel: any, options?: any, target?: any, renderMode?: any): any; - - ////////////////////////////////// - //// templateSources.js - //////////////////////////////////// - export var templateSources: KnockoutTemplateSources; - //////////////////////////////////// - //// templateEngine.js - //////////////////////////////////// - export var templateEngine: { - prototype: KnockoutTemplateEngine; - new (): KnockoutTemplateEngine; - }; - //////////////////////////////////// - //// templateRewriting.js - //////////////////////////////////// - export var templateRewriting: { - ensureTemplateIsRewritten(template: Node, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any; - ensureTemplateIsRewritten(template: string, templateEngine: KnockoutTemplateEngine, templateDocument: Document): any; - memoizeBindingAttributeSyntax(htmlString: string, templateEngine: KnockoutTemplateEngine): any; - applyMemoizedBindingsToNextSibling(bindings: any, nodeName: string): string; - }; - //////////////////////////////////// - //// nativeTemplateEngine.js - //////////////////////////////////// - export var nativeTemplateEngine: { - prototype: KnockoutNativeTemplateEngine; - new (): KnockoutNativeTemplateEngine; - instance: KnockoutNativeTemplateEngine; - }; - //////////////////////////////////// - //// jqueryTmplTemplateEngine.js - //////////////////////////////////// - export var jqueryTmplTemplateEngine: { - prototype: KnockoutTemplateEngine; - renderTemplateSource(templateSource: Object, bindingContext: KnockoutBindingContext, options: Object): Node[]; - createJavaScriptEvaluatorBlock(script: string): string; - addTemplate(templateName: string, templateMarkup: string): void; - }; - //////////////////////////////////// - //// templating.js - //////////////////////////////////// - export function renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any; - export function renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any; - export function renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any; - export function renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node, renderMode: string): any; - export function renderTemplate(template: Function, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any; - export function renderTemplate(template: any, dataOrBindingContext: KnockoutBindingContext, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any; - export function renderTemplate(template: Function, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any; - export function renderTemplate(template: any, dataOrBindingContext: any, options: Object, targetNodeOrNodeArray: Node[], renderMode: string): any; - export function renderTemplateForEach(template: Function, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any; - export function renderTemplateForEach(template: any, arrayOrObservableArray: any[], options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any; - export function renderTemplateForEach(template: Function, arrayOrObservableArray: KnockoutObservable, options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any; - export function renderTemplateForEach(template: any, arrayOrObservableArray: KnockoutObservable , options: Object, targetNode: Node, parentBindingContext: KnockoutBindingContext): any; - export var expressionRewriting: { - bindingRewriteValidators: any; - }; - - /////////////////////////////////// - export var bindingProvider: any; -} \ No newline at end of file diff --git a/knockout/tests/knockout-tests.ts b/knockout/tests/knockout-tests.ts index 8432089d9..e74012548 100644 --- a/knockout/tests/knockout-tests.ts +++ b/knockout/tests/knockout-tests.ts @@ -107,7 +107,7 @@ function testGetter() { } function test_observableArrays() { - var myObservableArray = ko.observableArray(); + var myObservableArray = ko.observableArray(); myObservableArray.push('Some value'); var anotherObservableArray = ko.observableArray([ { name: "Bungle", type: "Bear" }, diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.disabled.ts similarity index 100% rename from lodash/lodash-tests.ts rename to lodash/lodash-tests.disabled.ts diff --git a/moment/moment-tests.ts b/moment/moment-tests.ts index 9dd64d407..5150f7ebc 100644 --- a/moment/moment-tests.ts +++ b/moment/moment-tests.ts @@ -258,7 +258,7 @@ moment.lang('en', { }); moment.lang('en', { - months : function (momentToFormat, format) { + months : function (momentToFormat: Moment, format: string) { // momentToFormat is the moment currently being formatted // format is the formatting string if (/^MMMM/.test(format)) { // if the format starts with 'MMMM' @@ -277,7 +277,7 @@ moment.lang('en', { }); moment.lang('en', { - monthsShort : function (momentToFormat, format) { + monthsShort : function (momentToFormat: Moment, format: string) { if (/^MMMM/.test(format)) { return this.nominative[momentToFormat.month()]; } else { @@ -293,7 +293,7 @@ moment.lang('en', { }); moment.lang('en', { - weekdays : function (momentToFormat, format) { + weekdays : function (momentToFormat: Moment) { return this.weekdays[momentToFormat.day()]; } }); @@ -303,7 +303,7 @@ moment.lang('en', { }); moment.lang('en', { - weekdaysShort : function (momentToFormat, format) { + weekdaysShort : function (momentToFormat: Moment) { return this.weekdaysShort[momentToFormat.day()]; } }); @@ -313,7 +313,7 @@ moment.lang('en', { }); moment.lang('en', { - weekdaysMin : function (momentToFormat, format) { + weekdaysMin : function (momentToFormat: Moment) { return this.weekdaysMin[momentToFormat.day()]; } }); diff --git a/node-ffi/node-ffi-tests.ts b/node-ffi/node-ffi-tests.ts index c646af703..407036d39 100644 --- a/node-ffi/node-ffi-tests.ts +++ b/node-ffi/node-ffi-tests.ts @@ -26,7 +26,7 @@ import TArray = require('ref-array'); { var func = ffi.ForeignFunction(new Buffer(10), 'int', [ 'int' ]); func(-5); - func.async(-5, function(err, res) {}); + func.async(-5, function(err: any, res: any) {}); } { var printfPointer = ffi.DynamicLibrary().get('printf'); diff --git a/node-git/node-git.d.ts b/node-git/node-git.d.ts index dadfc8ba8..f10d217cb 100644 --- a/node-git/node-git.d.ts +++ b/node-git/node-git.d.ts @@ -17,7 +17,7 @@ declare module "git" { git(functionName:any, options:any, ...args:any[]):void; // last element is callback - call_git(prefix:string, command:any, postfix:string, options:any, args:any, callback:Function):void; + call_git(prefix:string, command:any, postfix:string, options:any, args:any, callback: (error: any, result: string) => void):void; rev_list(callback:Function):void; @@ -46,9 +46,9 @@ declare module "git" { // not implemented! clone(options:any, originalPath:any, targetPath:any, callback:Function):void; - diff(commit1:any, commit2:any, callback:Function):void; + diff(commit1:any, commit2:any, callback: (error: any, patch: string) => void):void; - diff(commit1:any, commit2:any, options:any, callback:Function):void; + diff(commit1: any, commit2: any, options: any, callback: (error: any, patch: string) => void):void; fs_exist(path:any, callback:Function):void; @@ -488,11 +488,11 @@ declare module "git" { fork_bare(path:any, options:any, callback:Function):void; // buggy? - diff(a:string, callback:Function):void; + diff(a: string, callback: (error: any, patch: string) => void):void; - diff(a:string, b:string, callback:Function):void; + diff(a: string, b: string, callback: (error: any, patch: string) => void):void; - diff(a:string, b:string, paths:any, callback:Function):void; + diff(a: string, b: string, paths: any, callback: (error: any, patch: string) => void):void; commit_diff(commit:string, callback:Function):void; diff --git a/node_redis/node_redis.d.ts b/node_redis/node_redis.d.ts index 32e19647f..8505556fb 100644 --- a/node_redis/node_redis.d.ts +++ b/node_redis/node_redis.d.ts @@ -333,8 +333,8 @@ declare module 'redis' { retry_delay : number; retry_backoff: number; - auth(password: string, callback: Function): void; - AUTH(password: string, callback: Function): void; + auth(password?: string, callback?: Function): void; + AUTH(password?: string, callback?: Function): void; end(): RedisClient; diff --git a/package.json b/package.json index 956223b70..61c1dc6cd 100644 --- a/package.json +++ b/package.json @@ -2,6 +2,6 @@ "name": "DefinitelyTyped", "version": "0.0.0", "scripts": { - "test": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.1.1" + "test": "node ./_infrastructure/tests/runner.js --tsc-version 0.9.5" } } diff --git a/pdf/pdf-tests.ts b/pdf/pdf-tests.ts index d40ffd578..90542b503 100644 --- a/pdf/pdf-tests.ts +++ b/pdf/pdf-tests.ts @@ -1,7 +1,5 @@ /// -var pdf: PDFPageProxy; - // // Fetch the PDF document from the URL using promises // diff --git a/pdf/pdf.d.ts b/pdf/pdf.d.ts index bddfca74f..6641000bc 100644 --- a/pdf/pdf.d.ts +++ b/pdf/pdf.d.ts @@ -27,7 +27,7 @@ interface PDFPromise { isRejected(): boolean; resolve(value: T): void; reject(reason: string): void; - then(onResolve: (promise: T) => void, onReject?: (reason: string) => void): PDFPromise; + then(onResolve: (promise: T) => void, onReject?: (reason: string) => void): PDFPromise; } interface PDFTreeNode { diff --git a/phonegap/phonegap-tests.ts b/phonegap/phonegap-tests.ts index 78b45609b..1eaff6040 100644 --- a/phonegap/phonegap-tests.ts +++ b/phonegap/phonegap-tests.ts @@ -318,7 +318,7 @@ function test_file() { var reader = new FileReader(); reader.onloadend = function (evt) { console.log("Read as data URL"); - console.log(evt.target.result); + console.log((evt.target).result); }; reader.readAsDataURL(file); } @@ -326,7 +326,7 @@ function test_file() { var reader = new FileReader(); reader.onloadend = function (evt) { console.log("Read as text"); - console.log(evt.target.result); + console.log((evt.target).result); }; reader.readAsText(file); } diff --git a/phonegap/phonegap.d.ts b/phonegap/phonegap.d.ts index 6e873163b..f23b473a9 100644 --- a/phonegap/phonegap.d.ts +++ b/phonegap/phonegap.d.ts @@ -3,10 +3,6 @@ // Definitions by: Boris Yankov // Definitions: https://github.com/borisyankov/DefinitelyTyped -interface EventTarget { - result: any; -} - interface GeolocationError { code: number; message: string; @@ -54,7 +50,7 @@ interface CameraOptions { mediaType?: number; correctOrientation?: boolean; saveToPhotoAlbum?: boolean; - popoverOptions?: number; + popoverOptions?: CameraPopoverOptions; } interface CameraPictureSourceTypeObject { diff --git a/rx.js/rx.js.async.d.ts.tscparams b/phonejs/dx.phonejs-tests.ts.tscparams similarity index 100% rename from rx.js/rx.js.async.d.ts.tscparams rename to phonejs/dx.phonejs-tests.ts.tscparams diff --git a/pixi/pixi-tests.ts b/pixi/pixi-tests.ts index 93ff79593..de452f72e 100644 --- a/pixi/pixi-tests.ts +++ b/pixi/pixi-tests.ts @@ -1,6 +1,8 @@ /// /// +function PixiTests() +{ var stage = new PIXI.Stage(0xFFFFFF, true); @@ -1188,3 +1190,5 @@ function update22() requestAnimFrame(update); } + +} \ No newline at end of file diff --git a/q/Q-tests.ts b/q/Q-tests.ts index 21fc95138..22f33506e 100644 --- a/q/Q-tests.ts +++ b/q/Q-tests.ts @@ -23,7 +23,7 @@ Q.delay(8, 1000).then(x => x.toExponential()); Q.delay(Q("asdf"), 1000).then(x => x.length); Q.delay("asdf", 1000).then(x => x.length); -var eventualAdd = Q.promised((a: number, b: number) => a + b); +var eventualAdd = Q.promised((a?: number, b?: number) => a + b); eventualAdd(Q(1), Q(2)).then(x => x.toExponential()); var eventually = function (eventually) { @@ -90,7 +90,7 @@ Q.all(promiseArray).then(nums => nums.map(num => num.toPrecision(2)).join(',')); Q.all(myNums).then(nums => nums.map(Math.round)); -Q.fbind((dateString) => new Date(dateString), "11/11/1991")().then(d => d.toLocaleDateString()); +Q.fbind((dateString?: string) => new Date(dateString), "11/11/1991")().then(d => d.toLocaleDateString()); Q.when(8, num => num + "!"); Q.when(Q(8), num => num + "!").then(str => str.split(',')); diff --git a/q/Q.d.ts b/q/Q.d.ts index 31537423f..4d7a7ce4f 100644 --- a/q/Q.d.ts +++ b/q/Q.d.ts @@ -106,14 +106,14 @@ declare module Q { export function nsend(nodeModule: any, functionName: string, ...args: any[]): Promise; export function nmcall(nodeModule: any, functionName: string, ...args: any[]): Promise; - export function all(promises: any[]): Promise; export function all(promises: IPromise[]): Promise; + export function all(promises: any[]): Promise; - export function allSettled(promises: any[]): Promise[]>; export function allSettled(promises: IPromise[]): Promise[]>; + export function allSettled(promises: any[]): Promise[]>; - export function allResolved(promises: any[]): Promise[]>; export function allResolved(promises: IPromise[]): Promise[]>; + export function allResolved(promises: any[]): Promise[]>; export function spread(promises: any[], onFulfilled: (...args: any[]) => IPromise, onRejected: (reason: any) => IPromise): Promise; export function spread(promises: any[], onFulfilled: (...args: any[]) => IPromise, onRejected: (reason: any) => U): Promise; diff --git a/requirejs/require-tests.ts b/requirejs/require-tests.ts index c66567e7b..a8cfdc87e 100644 --- a/requirejs/require-tests.ts +++ b/requirejs/require-tests.ts @@ -31,7 +31,7 @@ require.config({ // load AMD module main.ts (compiled to main.js) // and include shims $, _, Backbone -require(['main'], (main, $, _, Backbone) => { +require(['main'], (main: any, $: any, _: any, Backbone: any) => { var app = main.AppMain(); app.run(); @@ -39,5 +39,5 @@ require(['main'], (main, $, _, Backbone) => { }); var recOne = require.config({ baseUrl: 'js' }); -recOne(['core'], function (core) {/*some code*/}); +recOne(['core'], function (core: any) {/*some code*/}); diff --git a/rethinkdb/rethinkdb-tests.ts b/rethinkdb/rethinkdb-tests.ts index 4e6d78449..e94e5271c 100644 --- a/rethinkdb/rethinkdb-tests.ts +++ b/rethinkdb/rethinkdb-tests.ts @@ -10,7 +10,7 @@ r.connect({host:"localhost", port: 28015}, function(err, conn) { users.insert({name: "bob"}).run(conn, function() {}) - users.filter(function(doc) { + users.filter(function(doc?) { return doc("henry").eq("bob") }) .between("james", "beth") diff --git a/routie/routie-tests.ts b/routie/routie-tests.ts index aaf075675..323142c7e 100644 --- a/routie/routie-tests.ts +++ b/routie/routie-tests.ts @@ -25,7 +25,7 @@ routie("users/bob"); // window.location.hash will be #users/bob // Routie also supports regex style routes, so you can do advanced routing like this: -routie("users/:name", function (name) { +routie("users/:name", function (name: string) { // name == "bob"; }); @@ -33,7 +33,7 @@ routie("users/bob"); // Optional params: -routie("users/?:name", function (name) { +routie("users/?:name", function (name: string) { //name == undefined //then //name == bob diff --git a/royalslider/royalslider-tests.ts b/royalslider/royalslider-tests.ts index e8a166e9e..f79bd413b 100644 --- a/royalslider/royalslider-tests.ts +++ b/royalslider/royalslider-tests.ts @@ -8,7 +8,7 @@ $(".royalSlider").royalSlider({ keyboardNavEnabled: true }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -20,7 +20,7 @@ jQuery(document).ready(function ($) { }); }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -32,7 +32,7 @@ jQuery(document).ready(function ($) { }); }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -45,7 +45,7 @@ jQuery(document).ready(function ($) { }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -57,7 +57,7 @@ jQuery(document).ready(function ($) { }); }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -69,7 +69,7 @@ jQuery(document).ready(function ($) { }); }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere autoScaleSlider: true, @@ -81,7 +81,7 @@ jQuery(document).ready(function ($) { }); }); -jQuery(document).ready(function ($) { +jQuery(document).ready(function () { $(".royalSlider").royalSlider({ // general options go gere keyboardNavEnabled: true, @@ -171,7 +171,7 @@ slider.ev.on('rsAfterSlideChange', function (event) { slider.ev.on('rsBeforeAnimStart', function (event) { // before animation between slides start }); -slider.ev.on('rsBeforeMove', function (event, type, userAction) { +slider.ev.on('rsBeforeMove', function (event: JQueryEventObject, type?: string, userAction?: boolean) { // before any transition start (including after drag release) // "type" - can be "next", "prev", or ID of slide to move // userAction (Boolean) - defines if action is triggered by user (e.g. will be false if movement is triggered by autoPlay) @@ -188,7 +188,7 @@ slider.ev.on('rsDragRelease', function () { slider.ev.on('rsBeforeDestroy', function () { // triggers before slider in destroyed }); -slider.ev.on('rsOnCreateVideoElement', function (e, url) { +slider.ev.on('rsOnCreateVideoElement', function (e: JQueryEventObject, url?: string) { // triggers before video element is created, after click on play button. // Read more in Tips&Tricks section }); @@ -214,7 +214,7 @@ slider.slides[2].holder.on('rsAfterContentSet', function () { // fires when third slide content is loaded and added to DOM }); // or globally -slider.ev.on('rsAfterContentSet', function (e, slideObject) { +slider.ev.on('rsAfterContentSet', function (e: JQueryEventObject, slideObject?: RoyalSlider.RoyalSlider) { // fires when every time when slide content is loaded and added to DOM }); @@ -224,7 +224,7 @@ slider.ev.on('rsAfterContentSet', function (e, slideObject) { slider.ev.on('rsAfterInit', function () { // after slider is initialized, }); -slider.ev.on('rsBeforeParseNode', function (e, content, obj) { +slider.ev.on('rsBeforeParseNode', function (e: JQueryEventObject, content?: any, obj?: any) { // before slide node is parsed // content - HTML object of slide that is parsed // obj - RoyalSlider data object (stores image URLs) diff --git a/rx.js/rx.aggregates.d.ts b/rx.js/rx.aggregates.d.ts new file mode 100644 index 000000000..24ed13f1d --- /dev/null +++ b/rx.js/rx.aggregates.d.ts @@ -0,0 +1,55 @@ +/// + +// Type definitions for RxJS-Aggregates package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export interface Observable { + aggregate(accumulator: (acc: T, value: T) => T): Observable; + aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable; + + reduce(accumulator: (acc: T, value: T) => T): Observable; + reduce(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable; // TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751 + + any(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + some(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; // alias for any + + isEmpty(): Observable; + all(predicate?: (value: T) => boolean, thisArg?: any): Observable; + every(predicate?: (value: T) => boolean, thisArg?: any): Observable; // alias for all + contains(value: T): Observable; + contains(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable; + count(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + sum(keySelector?: (value: T, index: number, source: Observable) => number, thisArg?: any): Observable; + minBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable; + minBy(keySelector: (item: T) => number): Observable; + min(comparer?: (value1: T, value2: T) => number): Observable; + maxBy(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable; + maxBy(keySelector: (item: T) => number): Observable; + max(comparer?: (value1: T, value2: T) => number): Observable; + average(keySelector?: (value: T, index: number, source: Observable) => number, thisArg?: any): Observable; + + sequenceEqual(second: Observable, comparer: (value1: T, value2: TOther) => number): Observable; + sequenceEqual(second: Observable): Observable; + sequenceEqual(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable; + sequenceEqual(second: T[]): Observable; + + elementAt(index: number): Observable; + elementAtOrDefault(index: number, defaultValue?: T): Observable; + + single(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + singleOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + first(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + firstOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + last(predicate?: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + lastOrDefault(predicate?: (value: T, index: number, source: Observable) => boolean, defaultValue?: T, thisArg?: any): Observable; + + find(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + findIndex(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + } +} diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts new file mode 100644 index 000000000..2e511444a --- /dev/null +++ b/rx.js/rx.async.d.ts @@ -0,0 +1,94 @@ +/// + +// Type definitions for RxJS-Async package 2.2 +// Project: http://rx.codeplex.com/ +// Definitions by: zoetrope +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + interface ObservableStatic { + start(func: () => T, scheduler?: IScheduler, context?: any): Observable; + + toAsync(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable; + toAsync(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + toAsync(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable; + toAsync(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + toAsync(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable; + toAsync(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable; + toAsync(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable; + toAsync(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable; + toAsync(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable; + + fromCallback: { + // with single result callback without selector + (func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any callback with selector + (func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any callback without selector + (func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any function with selector + (func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable; + // with any function without selector + (func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable; + }; + + fromNodeCallback: { + // with single result callback without selector + (func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any callback with selector + (func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any callback without selector + (func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable; + (func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable; + (func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable; + (func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable; + // with any function with selector + (func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable; + // with any function without selector + (func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable; + }; + + fromEvent(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable; + fromEvent(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable; + fromEventPattern(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable; + + fromPromise(promise: Promise): Observable; + fromPromise(promise: any): Observable; + } + + interface Promise { + then(onFulfill: (value: T) => any, onReject?: (reason: any) => any): any; + } +} diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts new file mode 100644 index 000000000..22624cc23 --- /dev/null +++ b/rx.js/rx.binding.d.ts @@ -0,0 +1,49 @@ +/// + +// Type definitions for RxJS-Binding package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export interface BehaviorSubject extends Subject { + } + + interface BehaviorSubjectStatic { + new (initialValue: T): BehaviorSubject; + } + + export var BehaviorSubject: BehaviorSubjectStatic; + + export interface ReplaySubject extends Subject { + } + + interface ReplaySubjectStatic { + new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; + } + + export var ReplaySubject: ReplaySubjectStatic; + + interface ConnectableObservable extends Observable { + connect(): IDisposable; + refCount(): Observable; + } + + interface ConnectableObservableStatic { + new (): ConnectableObservable; + } + + export var ConnectableObservable: ConnectableObservableStatic; + + export interface Observable { + publish(): ConnectableObservable; + publish(selector: (item: T) => Observable): ConnectableObservable; + publishLast(): ConnectableObservable; + publishLast(selector: (item: T) => Observable): ConnectableObservable; + publishValue(initialValue: T): ConnectableObservable; + publishValue(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable; + + replay(selector?: (source: Observable) => ReplaySubject, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; + } +} diff --git a/rx.js/rx.coincidence.d.ts b/rx.js/rx.coincidence.d.ts new file mode 100644 index 000000000..2afa5cfe9 --- /dev/null +++ b/rx.js/rx.coincidence.d.ts @@ -0,0 +1,32 @@ +/// + +// Type definitions for RxJS-Coincidence package +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + interface Observable { + join( + right: Observable, + leftDurationSelector: (leftItem: T) => Observable, + rightDurationSelector: (rightItem: TRight) => Observable, + resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable; + + groupJoin( + right: Observable, + leftDurationSelector: (leftItem: T) => Observable, + rightDurationSelector: (rightItem: TRight) => Observable, + resultSelector: (leftItem: T, rightItem: Observable) => TResult): Observable; + + window(windowOpenings: Observable): Observable>; + window(windowClosingSelector: () => Observable): Observable>; + window(windowOpenings: Observable, windowClosingSelector: () => Observable): Observable>; + + buffer(bufferOpenings: Observable): Observable; + buffer(bufferClosingSelector: () => Observable): Observable; + buffer(bufferOpenings: Observable, bufferClosingSelector: () => Observable): Observable; + } +} diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts new file mode 100644 index 000000000..f055452e3 --- /dev/null +++ b/rx.js/rx.d.ts @@ -0,0 +1,356 @@ +// Type definitions for RxJS +// Project: http://rx.codeplex.com/ +// Definitions by: gsino +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export module Internals { + function isEqual(left: any, right: any): boolean; + function inherits(child: Function, parent: Function): Function; + function addProperties(obj: Object, ...sourcces: Object[]): void; + function addRef(xs: Observable, r: { getDisposable(): IDisposable; }): Observable; + + // Priority Queue for Scheduling + export class PriorityQueue { + constructor(capacity: number); + + length: number; + + isHigherPriority(left: number, right: number): boolean; + percolate(index: number): void; + heapify(index: number): void; + peek(): ScheduledItem; + removeAt(index: number): void; + dequeue(): ScheduledItem; + enqueue(item: ScheduledItem): void; + remove(item: ScheduledItem): boolean; + + static count: number; + } + + export class ScheduledItem { + constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number); + + scheduler: IScheduler; + state: TTime; + action: (scheduler: IScheduler, state: any) => IDisposable; + dueTime: TTime; + comparer: (x: TTime, y: TTime) => number; + disposable: SingleAssignmentDisposable; + + invoke(): void; + compareTo(other: ScheduledItem): number; + isCancelled(): boolean; + invokeCore(): IDisposable; + } + } + + export interface IDisposable { + dispose(): void; + } + + export class CompositeDisposable implements IDisposable { + constructor (...disposables: IDisposable[]); + constructor (disposables: IDisposable[]); + + isDisposed: boolean; + length: number; + + dispose(): void; + add(item: IDisposable): void; + remove(item: IDisposable): boolean; + clear(): void; + contains(item: IDisposable): boolean; + toArray(): IDisposable[]; + } + + export class Disposable implements IDisposable { + constructor(action: () => void); + + static create(action: () => void): IDisposable; + static empty: IDisposable; + + dispose(): void; + } + + // Single assignment + export class SingleAssignmentDisposable implements IDisposable { + constructor(); + + isDisposed: boolean; + current: IDisposable; + + dispose(): void ; + getDisposable(): IDisposable; + setDisposable(value: IDisposable): void ; + } + + // Multiple assignment disposable + export class SerialDisposable implements IDisposable { + constructor(); + + isDisposed: boolean; + + dispose(): void; + getDisposable(): IDisposable; + setDisposable(value: IDisposable): void; + } + + export class RefCountDisposable implements IDisposable { + constructor(disposable: IDisposable); + + dispose(): void; + + isDisposed: boolean; + getDisposable(): IDisposable; + } + + export interface IScheduler { + now(): number; + catch(handler: (exception: any) => boolean): IScheduler; + catchException(handler: (exception: any) => boolean): IScheduler; + + schedule(action: () => void): IDisposable; + scheduleWithState(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable; + scheduleWithAbsoluteAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable; + scheduleWithRelative(dueTime: number, action: () => void): IDisposable; + scheduleWithRelativeAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable; + + scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable; + scheduleRecursiveWithState(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable; + scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithAbsoluteAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable; + scheduleRecursiveWithRelativeAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable; + + schedulePeriodic(period: number, action: () => void): IDisposable; + schedulePeriodicWithState(state: TState, period: number, action: (state: TState) => TState): IDisposable; + } + + export class Scheduler implements IScheduler { + constructor( + now: () => number, + schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, + scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable, + scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable); + + static normalize(timeSpan: number): number; + + static immediate: IScheduler; + static currentThread: ICurrentThreadScheduler; + static timeout: IScheduler; + + now(): number; + catch(handler: (exception: any) => boolean): IScheduler; + catchException(handler: (exception: any) => boolean): IScheduler; + + schedule(action: () => void): IDisposable; + scheduleWithState(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable; + scheduleWithAbsoluteAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleWithRelative(dueTime: number, action: () => void): IDisposable; + scheduleWithRelativeAndState(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + + scheduleRecursive(action: (action: () => void) => void): IDisposable; + scheduleRecursiveWithState(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable; + scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithAbsoluteAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable; + scheduleRecursiveWithRelativeAndState(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable; + + schedulePeriodic(period: number, action: () => void): IDisposable; + schedulePeriodicWithState(state: TState, period: number, action: (state: TState) => TState): IDisposable; + } + + // Current Thread IScheduler + interface ICurrentThreadScheduler extends IScheduler { + scheduleRequired(): boolean; + ensureTrampoline(action: () =>IDisposable): IDisposable; + } + + // Notifications + export class Notification { + accept(observer: Observer): void; + accept(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult; + toObservable(scheduler?: IScheduler): Observable; + hasValue: boolean; + equals(other: Notification): boolean; + kind: string; + value: T; + exception: any; + + static createOnNext(value: T): Notification; + static createOnError(exception: any): Notification; + static createOnCompleted(): Notification; + } + + // Observer + export class Observer { + onNext(value: T): void; + onError(exception: any): void; + onCompleted(): void; + + toNotifier(): (notification: Notification) =>void; + asObserver(): Observer; + checked(): Observer; + + static create(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer; + static fromNotifier(handler: (notification: Notification) => void): Observer; + } + + export interface Observable { + subscribe(observer: Observer): IDisposable; + subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable; + + toArray(): Observable; + + observeOn(scheduler: IScheduler): Observable; + subscribeOn(scheduler: IScheduler): Observable; + + amb(rightSource: Observable): Observable; + catch(handler: (exception: any) => Observable): Observable; + catchException(handler: (exception: any) => Observable): Observable; // alias for catch + catch(second: Observable): Observable; + catchException(second: Observable): Observable; // alias for catch + combineLatest(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; + combineLatest(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; + combineLatest(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; + combineLatest(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; + combineLatest(souces: Observable[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable; + concat(...sources: Observable[]): Observable; + concat(sources: Observable[]): Observable; + concatAll(): T; + concatObservable(): T; // alias for concatAll + merge(maxConcurrent: number): Observable; + merge(other: Observable): Observable; + mergeAll(): T; + mergeObservable(): T; // alias for mergeAll + onErrorResumeNext(second: Observable): Observable; + skipUntil(other: Observable): Observable; + switchLatest(): T; + takeUntil(other: Observable): Observable; + zip(second: Observable, resultSelector: (v1: T, v2: T2) => TResult): Observable; + zip(second: Observable, third: Observable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable; + zip(second: Observable, third: Observable, fourth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable; + zip(second: Observable, third: Observable, fourth: Observable, fifth: Observable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable; + zip(second: Observable[], resultSelector: (left: T, right: Observable) => TResult): Observable; + asObservable(): Observable; + bufferWithCount(count: number, skip?: number): Observable; + dematerialize(): Observable; + distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable; + distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable; + do(observer: Observer): Observable; + doAction(observer: Observer): Observable; // alias for do + do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; + doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable; // alias for do + finally(action: () => void): Observable; + finallyAction(action: () => void): Observable; // alias for finally + ignoreElements(): Observable; + materialize(): Observable>; + repeat(repeatCount?: number): Observable; + retry(retryCount?: number): Observable; + scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable; + scan(accumulator: (acc: T, value: T) => T): Observable; + skipLast(count: number): Observable; + startWith(...values: T[]): Observable; + startWith(scheduler: IScheduler, ...values: T[]): Observable; + takeLast(count: number, scheduler?: IScheduler): Observable; + takeLastBuffer(count: number): Observable; + windowWithCount(count: number, skip?: number): Observable>; + defaultIfEmpty(defaultValue?: T): Observable; + distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable; + distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable; + groupBy(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable>; + groupBy(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable) => Observable, keySerializer?: (key: TKey) => string): Observable>; + select(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; + map(selector: (value: T, index: number, source: Observable) => TResult, thisArg?: any): Observable; // alias for select + selectMany(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; + selectMany(selector: (value: T) => Observable): Observable; + selectMany(other: Observable): Observable; + flatMap(selector: (value: T) => Observable, resultSelector: (item: T, other: TOther) => TResult): Observable; // alias for selectMany + flatMap(selector: (value: T) => Observable): Observable; // alias for selectMany + flatMap(other: Observable): Observable; // alias for selectMany + skip(count: number): Observable; + skipWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + take(count: number, scheduler?: IScheduler): Observable; + takeWhile(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + where(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; + filter(predicate: (value: T, index: number, source: Observable) => boolean, thisArg?: any): Observable; // alias for where + } + + interface ObservableStatic { + create(subscribe: (observer: Observer) => void): Observable; + create(subscribe: (observer: Observer) => () => void): Observable; + createWithDisposable(subscribe: (observer: Observer) => IDisposable): Observable; + defer(observableFactory: () => Observable): Observable; + empty(scheduler?: IScheduler): Observable; + fromArray(array: T[], scheduler?: IScheduler): Observable; + fromArray(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable; + generate(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable; + never(): Observable; + range(start: number, count: number, scheduler?: IScheduler): Observable; + repeat(value: T, repeatCount?: number, scheduler?: IScheduler): Observable; + return(value: T, scheduler?: IScheduler): Observable; + returnValue(value: T, scheduler?: IScheduler): Observable; // alias for return + throw(exception: Error, scheduler?: IScheduler): Observable; + throw(exception: any, scheduler?: IScheduler): Observable; + throwException(exception: Error, scheduler?: IScheduler): Observable; // alias for throw + throwException(exception: any, scheduler?: IScheduler): Observable; // alias for throw + using(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable): Observable; + amb(...sources: Observable[]): Observable; + amb(sources: Observable[]): Observable; + catch(sources: Observable[]): Observable; + catchException(sources: Observable[]): Observable; // alias for catch + catch(...sources: Observable[]): Observable; + catchException(...sources: Observable[]): Observable; // alias for catch + concat(...sources: Observable[]): Observable; + concat(sources: Observable[]): Observable; + merge(...sources: Observable[]): Observable; + merge(sources: Observable[]): Observable; + merge(scheduler: IScheduler, ...sources: Observable[]): Observable; + merge(scheduler: IScheduler, sources: Observable[]): Observable; + onErrorResumeNext(...sources: Observable[]): Observable; + onErrorResumeNext(sources: Observable[]): Observable; + zip(first: Observable, sources: Observable[], resultSelector: (item1: T1, right: Observable) => TResult): Observable; + zip(source1: Observable, source2: Observable, resultSelector: (item1: T1, item2: T2) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable; + zip(source1: Observable, source2: Observable, source3: Observable, source4: Observable, source5: Observable, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TResult): Observable; + zipArray(...sources: Observable[]): Observable; + zipArray(sources: Observable[]): Observable; + } + + export var Observable: ObservableStatic; + + interface GroupedObservable extends Observable { + key: TKey; + underlyingObservable: Observable; + } + + interface ISubject extends Observable, Observer, IDisposable { + hasObservers(): boolean; + } + + export interface Subject extends ISubject { + } + + interface SubjectStatic { + new (): Subject; + create(observer?: Observer, observable?: Observable): ISubject; + } + + export var Subject: SubjectStatic; + + export interface AsyncSubject extends Subject { + } + + interface AsyncSubjectStatic { + new (): AsyncSubject; + } + + export var AsyncSubject: AsyncSubjectStatic; +} diff --git a/rx.js/rx.js.experimental.d.ts b/rx.js/rx.experimental.d.ts similarity index 84% rename from rx.js/rx.js.experimental.d.ts rename to rx.js/rx.experimental.d.ts index a43788b87..db23df3fd 100644 --- a/rx.js/rx.js.experimental.d.ts +++ b/rx.js/rx.experimental.d.ts @@ -3,11 +3,11 @@ // Definitions by: Igor Oleinikov // Definitions: https://github.com/borisyankov/DefinitelyTyped -/// +/// declare module Rx { - interface IObservable { + interface Observable { /** * Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions. * This operator allows for a fluent style of writing queries that use the same sequence multiple times. @@ -15,7 +15,7 @@ declare module Rx { * @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence. * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. */ - let(selector: (source: IObservable) => IObservable): IObservable; + let(selector: (source: Observable) => Observable): Observable; /** * Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions. @@ -24,14 +24,14 @@ declare module Rx { * @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence. * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. */ - letBind(selector: (source: IObservable) => IObservable): IObservable; + letBind(selector: (source: Observable) => Observable): Observable; /** * Repeats source as long as condition holds emulating a do while loop. * @param condition The condition which determines if the source will be repeated. * @returns An observable sequence which is repeated as long as the condition holds. */ - doWhile(condition: () => boolean): IObservable; + doWhile(condition: () => boolean): Observable; /** * Expands an observable sequence by recursively invoking selector. @@ -40,7 +40,7 @@ declare module Rx { * @param [scheduler] Scheduler on which to perform the expansion. If not provided, this defaults to the current thread scheduler. * @returns An observable sequence containing all the elements produced by the recursive expansion. */ - expand(selector: (item: T) => IObservable, scheduler?: IScheduler): IObservable; + expand(selector: (item: T) => Observable, scheduler?: IScheduler): Observable; /** * Runs two observable sequences in parallel and combines their last elemenets. @@ -49,7 +49,7 @@ declare module Rx { * @param resultSelector Result selector function to invoke with the last elements of both sequences. * @returns An observable sequence with the result of calling the selector function with the last elements of both input sequences. */ - forkJoin(second: IObservable, resultSelector: (left: T, right: TSecond) => TResult): IObservable; + forkJoin(second: Observable, resultSelector: (left: T, right: TSecond) => TResult): Observable; /** * Comonadic bind operator. @@ -57,10 +57,10 @@ declare module Rx { * @param [scheduler] Scheduler used to execute the operation. If not specified, defaults to the ImmediateScheduler. * @returns An observable sequence which results from the comonadic bind operation. */ - manySelect(selector: (item: IObservable, index: number, source: IObservable) => TResult, scheduler?: IScheduler): IObservable; + manySelect(selector: (item: Observable, index: number, source: Observable) => TResult, scheduler?: IScheduler): Observable; } - interface Observable { + interface ObservableStatic { /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; + if(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, scheduler?: IScheduler): IObservable; + if(condition: () => boolean, thenSource: Observable, scheduler?: IScheduler): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; + ifThen(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; /** * Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers (condition: () => boolean, thenSource: IObservable, scheduler?: IScheduler): IObservable; + ifThen(condition: () => boolean, thenSource: Observable, scheduler?: IScheduler): Observable; /** * Concatenates the observable sequences obtained by running the specified result selector for each element in source. @@ -116,7 +116,7 @@ declare module Rx { * @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence. * @returns An observable sequence from the concatenated observable sequences. */ - for(sources: T[], resultSelector: (item: T) => IObservable): IObservable; + for(sources: T[], resultSelector: (item: T) => Observable): Observable; /** * Concatenates the observable sequences obtained by running the specified result selector for each element in source. @@ -125,7 +125,7 @@ declare module Rx { * @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence. * @returns An observable sequence from the concatenated observable sequences. */ - forIn(sources: T[], resultSelector: (item: T) => IObservable): IObservable; + forIn(sources: T[], resultSelector: (item: T) => Observable): Observable; /** * Repeats source as long as condition holds emulating a while loop. @@ -134,7 +134,7 @@ declare module Rx { * @param source The observable sequence that will be run if the condition function returns true. * @returns An observable sequence which is repeated as long as the condition holds. */ - while(condition: () => boolean, source: IObservable): IObservable; + while(condition: () => boolean, source: Observable): Observable; /** * Repeats source as long as condition holds emulating a while loop. @@ -143,7 +143,7 @@ declare module Rx { * @param source The observable sequence that will be run if the condition function returns true. * @returns An observable sequence which is repeated as long as the condition holds. */ - whileDo(condition: () => boolean, source: IObservable): IObservable; + whileDo(condition: () => boolean, source: Observable): Observable; /** * Uses selector to determine which source in sources to use. @@ -157,7 +157,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - case(selector: () => string, sources: { [key: string]: IObservable; }, elseSource: IObservable): IObservable; + case(selector: () => string, sources: { [key: string]: Observable; }, elseSource: Observable): Observable; /** * Uses selector to determine which source in sources to use. @@ -173,7 +173,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - case(selector: () => string, sources: { [key: string]: IObservable; }, scheduler?: IScheduler): IObservable; + case(selector: () => string, sources: { [key: string]: Observable; }, scheduler?: IScheduler): Observable; /** * Uses selector to determine which source in sources to use. @@ -187,7 +187,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - case(selector: () => number, sources: { [key: number]: IObservable; }, elseSource: IObservable): IObservable; + case(selector: () => number, sources: { [key: number]: Observable; }, elseSource: Observable): Observable; /** * Uses selector to determine which source in sources to use. @@ -203,7 +203,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - case(selector: () => number, sources: { [key: number]: IObservable; }, scheduler?: IScheduler): IObservable; + case(selector: () => number, sources: { [key: number]: Observable; }, scheduler?: IScheduler): Observable; /** * Uses selector to determine which source in sources to use. @@ -217,7 +217,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - switchCase(selector: () => string, sources: { [key: string]: IObservable; }, elseSource: IObservable): IObservable; + switchCase(selector: () => string, sources: { [key: string]: Observable; }, elseSource: Observable): Observable; /** * Uses selector to determine which source in sources to use. @@ -233,7 +233,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - switchCase(selector: () => string, sources: { [key: string]: IObservable; }, scheduler?: IScheduler): IObservable; + switchCase(selector: () => string, sources: { [key: string]: Observable; }, scheduler?: IScheduler): Observable; /** * Uses selector to determine which source in sources to use. @@ -247,7 +247,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - switchCase(selector: () => number, sources: { [key: number]: IObservable; }, elseSource: IObservable): IObservable; + switchCase(selector: () => number, sources: { [key: number]: Observable; }, elseSource: Observable): Observable; /** * Uses selector to determine which source in sources to use. @@ -263,7 +263,7 @@ declare module Rx { * * @returns An observable sequence which is determined by a case statement. */ - switchCase(selector: () => number, sources: { [key: number]: IObservable; }, scheduler?: IScheduler): IObservable; + switchCase(selector: () => number, sources: { [key: number]: Observable; }, scheduler?: IScheduler): Observable; /** * Runs all observable sequences in parallel and collect their last elements. @@ -273,7 +273,7 @@ declare module Rx { * @param sources Array of source sequences. * @returns An observable sequence with an array collecting the last elements of all the input sequences. */ - forkJoin(sources: IObservable[]): IObservable; + forkJoin(sources: Observable[]): Observable; /** * Runs all observable sequences in parallel and collect their last elements. @@ -283,6 +283,6 @@ declare module Rx { * @param args Source sequences. * @returns An observable sequence with an array collecting the last elements of all the input sequences. */ - forkJoin(...args: IObservable[]): IObservable; + forkJoin(...args: Observable[]): Observable; } } diff --git a/rx.js/rx.joinpatterns.d.ts b/rx.js/rx.joinpatterns.d.ts new file mode 100644 index 000000000..d23264f8e --- /dev/null +++ b/rx.js/rx.joinpatterns.d.ts @@ -0,0 +1,56 @@ +/// + +// Type definitions for RxJS-Join package +// Project: http://rx.codeplex.com/ +// Definitions by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + interface Pattern1 { + and(other: Observable): Pattern2; + then(selector: (item1: T1) => TR): Plan; + } + interface Pattern2 { + and(other: Observable): Pattern3; + then(selector: (item1: T1, item2: T2) => TR): Plan; + } + interface Pattern3 { + and(other: Observable): Pattern4; + then(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan; + } + interface Pattern4 { + and(other: Observable): Pattern5; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan; + } + interface Pattern5 { + and(other: Observable): Pattern6; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan; + } + interface Pattern6 { + and(other: Observable): Pattern7; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan; + } + interface Pattern7 { + and(other: Observable): Pattern8; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan; + } + interface Pattern8 { + and(other: Observable): Pattern9; + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan; + } + interface Pattern9 { + then(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan; + } + + interface Plan { } + + interface Observable { + and(other: Observable): Pattern2; + then(selector: (item1: T) => TR): Plan; + } + + interface ObservableStatic { + when(plan: Plan): Observable; + } +} diff --git a/rx.js/rx.jquery.d.ts b/rx.js/rx.jquery.d.ts new file mode 100644 index 000000000..fd9311ee4 --- /dev/null +++ b/rx.js/rx.jquery.d.ts @@ -0,0 +1,56 @@ +// Type definitions for bridging RxJS with jQuery. +// Project: https://github.com/Reactive-Extensions/RxJS-jQuery/ +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +/// +/// + +interface JQueryStatic { + ajaxAsObservable(settings: JQueryAjaxSettings): Rx.Observable; + getAsObservable(url: string, data: any, dataType: string): Rx.Observable; + getJSONAsObservable(url: string, data: any): Rx.Observable; + getScriptAsObservable(url: string, data: any): Rx.Observable; + postAsObservable(url: string, data: any, dataType: string): Rx.Observable; +} + +interface JQuery { + onAsObservable(events: string, selector?: string, eventData?: any): Rx.Observable; + bindAsObservable(eventType: string, eventData?: any): Rx.Observable; + delegateAsObservable(selector: string, eventType: string, eventData?: any): Rx.Observable; + //liveAsObservable(eventType: string, eventData?: any): Rx.Observable; // removed in jquery 1.9 + + changeAsObservable(eventData?: any): Rx.Observable; + clickAsObservable(eventData?: any): Rx.Observable; + dblclickAsObservable(eventData?: any): Rx.Observable; + focusAsObservable(eventData?: any): Rx.Observable; + focusinAsObservable(eventData?: any): Rx.Observable; + focusoutAsObservable(eventData?: any): Rx.Observable; + keydownAsObservable(eventData?: any): Rx.Observable; + keyupAsObservable(eventData?: any): Rx.Observable; + loadAsObservable(eventData?: any): Rx.Observable; + mousedownAsObservable(eventData?: any): Rx.Observable; + mouseenterAsObservable(eventData?: any): Rx.Observable; + mouseleaveAsObservable(eventData?: any): Rx.Observable; + mousemoveAsObservable(eventData?: any): Rx.Observable; + mouseoutAsObservable(eventData?: any): Rx.Observable; + mouseoverAsObservable(eventData?: any): Rx.Observable; + mouseupAsObservable(eventData?: any): Rx.Observable; + resizeAsObservable(eventData?: any): Rx.Observable; + scrollAsObservable(eventData?: any): Rx.Observable; + selectAsObservable(eventData?: any): Rx.Observable; + submitAsObservable(eventData?: any): Rx.Observable; + unloadAsObservable(eventData?: any): Rx.Observable; + hideAsObservable(duration: number): Rx.Observable; + showAsObservable(duration: number): Rx.Observable; + readyAsObservable(): Rx.Observable; + animateAsObservable(properties: any, duration: number, easing?: string): Rx.Observable; + fadeInAsObservable(duration: number, easing?: string): Rx.Observable; + fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.Observable; + fadeOutAsObservable(duration: number, easing?: string): Rx.Observable; + fadeToggleAsObservable(duration: number, easing?: string): Rx.Observable; + slideDownAsObservable(duration: number): Rx.Observable; + slideUpAsObservable(duration: number): Rx.Observable; + slideToggleAsObservable(duration: number): Rx.Observable; + toggleAsObservable(duration: number): Rx.Observable; +} diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts deleted file mode 100644 index 93a304db4..000000000 --- a/rx.js/rx.js.aggregates.d.ts +++ /dev/null @@ -1,53 +0,0 @@ -/// - -// Type definitions for RxJS-Aggregates package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.aggregates.js - -declare module Rx { - interface IObservable { - aggregate(accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - aggregate(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - - any(): IObservable; - any(selector: (item: T) => boolean): IObservable; - - isEmpty(predicate?: (value: T) => boolean): IObservable; - all(predicate?: (value: T) => boolean): IObservable; - contains(value: T, comparer?: (value1: T, value2: T) => boolean): IObservable; - count(predicate?: (item: T) => boolean): IObservable; - sum(keySelector?: (item: T) => number): IObservable; - minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable; - min(comparer?: (value1: T, value2: T) => number): IObservable; - maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable; - max(comparer?: (value1: T, value2: T) => number): IObservable; - average(keySelector?: (item: T) => number): IObservable; - - sequenceEqual(second: IObservable, comparer?: (value1: T, value2: T) => number): IObservable; - elementAt(index: number): IObservable; - elementAtOrDefault(index: number, defaultValue: T): IObservable; - - single(): IObservable; - single(predicate: (T) => boolean): IObservable; - singleOrDefault(): IObservable; - singleOrDefault(predicate: (T) => boolean): IObservable; - singleOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - - first(): IObservable; - first(predicate: (T) => boolean): IObservable; - firstOrDefault(): IObservable; - firstOrDefault(predicate: (T) => boolean): IObservable; - firstOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - - last(): IObservable; - last(predicate: (T) => boolean): IObservable; - lastOrDefault(): IObservable; - lastOrDefault(predicate: (T) => boolean): IObservable; - lastOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.aggregates.d.ts.tscparams b/rx.js/rx.js.aggregates.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.aggregates.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts deleted file mode 100644 index 98fb930f7..000000000 --- a/rx.js/rx.js.async.d.ts +++ /dev/null @@ -1,22 +0,0 @@ -/// - -// Type definitions for RxJS-Async package 2.2 -// Project: http://rx.codeplex.com/ -// Definitions by: zoetrope -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.async.js - -declare module Rx { - interface Observable { - start(func: () => T, scheduler?: IScheduler, context?: any): IObservable; - toAsync(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable; - fromCallback(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => IObservable; - fromNodeCallback(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => IObservable; - fromEvent(element: any, eventName: string, selector?: (...arguments: any[])=>T): IObservable; - fromEventPattern(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): IObservable; - fromPromise(promise: any): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.js.binding.d.ts deleted file mode 100644 index b1f7c687a..000000000 --- a/rx.js/rx.js.binding.d.ts +++ /dev/null @@ -1,54 +0,0 @@ -/// - -// Type definitions for RxJS-Binding package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.binding.js - -declare module Rx { - - interface ReplaySubject extends ISubject { - new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - var ReplaySubject: { - new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - interface BehaviorSubject extends ISubject { - new (initialValue: T): BehaviorSubject; - } - - var BehaviorSubject: { - new (initialValue: T): BehaviorSubject; - } - - interface ConnectableObservable extends IObservable{ - connect(): _IDisposable; - refCount(): IObservable; - } - - var ConnectableObservable: { - new (): ConnectableObservable; - } - - interface IObservable { - - publish(): ConnectableObservable; - publish(selector: (item: T) => IObservable): ConnectableObservable; - publishLast(): ConnectableObservable; - publishLast(selector: (item: T) => IObservable): ConnectableObservable; - publishValue(initialValue: T): ConnectableObservable; - publishValue(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable; - - replay(selector?: (source: IObservable) => ReplaySubject, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject; - } - - - interface Observable { - } -} diff --git a/rx.js/rx.js.binding.d.ts.tscparams b/rx.js/rx.js.binding.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.binding.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts deleted file mode 100644 index 138e99236..000000000 --- a/rx.js/rx.js.coincidence.d.ts +++ /dev/null @@ -1,40 +0,0 @@ -/// - -// Type definitions for RxJS-Coincidence package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.coincidence.js - -declare module Rx { - - interface IObservable { - join( - right: IObservable, - leftDurationSelector: (leftItem: T) => IObservable, - rightDurationSelector: (rightItem: T2) => IObservable, - resultSelector: (leftItem: T, rightItem: T2) => TResult): IObservable; - - groupJoin( - right: IObservable, - leftDurationSelector: (leftItem: T) => IObservable, - rightDurationSelector: (rightItem: T2) => IObservable, - resultSelector: (leftItem: T, rightItem: IObservable) => TResult): IObservable; - - - // lack of documentation to complete the followings... - - buffer(bufferOpenings: IObservable, - bufferClosingSelector: (opening: TBufferOpening) => IObservable): IObservable; - - window(bufferOpenings: IObservable, - bufferClosingSelector: (opening: TBufferOpening) => IObservable): IObservable; - } - - - interface Observable { - } -} diff --git a/rx.js/rx.js.coincidence.d.ts.tscparams b/rx.js/rx.js.coincidence.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.coincidence.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts deleted file mode 100644 index aeefce98f..000000000 --- a/rx.js/rx.js.d.ts +++ /dev/null @@ -1,433 +0,0 @@ -// Type definitions for RxJS -// Project: http://rx.codeplex.com/ -// Definitions by: gsino -// Definitions: https://github.com/borisyankov/DefinitelyTyped - - -declare module Rx { - export module Internals { - function inherits(child: Function, parent: Function): Function; - function addProperties(obj: Object, ...sourcces: Object[]): void; - function addRef(xs: IObservable, r: { getDisposable(): _IDisposable; }): IObservable; - } - - //Collections - interface IIndexedItem { - id: number; - value: IScheduledItem; - - compareTo(other: IIndexedItem): number; - } - - // Priority Queue for Scheduling - interface IPriorityQueue { - items: IIndexedItem[]; - length: number; - - isHigherPriority(left: number, right: number): boolean; - percolate(index: number): void; - heapify(index: number): void; - peek(): IIndexedItem; - removeAt(index: number): void; - dequeue(): IIndexedItem; - enqueue(item: IIndexedItem): void; - remove(item: IIndexedItem): boolean; - } - - interface _IDisposable { - dispose(): void; - } - - export class CompositeDisposable { - constructor (...disposables: _IDisposable[]); - - disposables: _IDisposable[]; - isDisposed: boolean; - length: number; - - dispose(): void; - add(item: _IDisposable): void; - remove(item: _IDisposable): boolean; - clear(): void; - contains(item: _IDisposable): boolean; - toArray(): _IDisposable[]; - } - - // Main disposable class - interface IDisposable { - isDisposed: boolean; - action: () =>void; - - dispose(): void; - } - - export interface Disposable { - new (action: () =>void ): IDisposable; - } - - var Disposable: { - create(action: () => void): _IDisposable; - empty: _IDisposable; - } - - // Single assignment - interface ISingleAssignmentDisposable { - isDisposed: boolean; - current: _IDisposable; - - dispose(): void; - disposable(value?: _IDisposable): _IDisposable; - getDisposable(): _IDisposable; - setDisposable(value: _IDisposable): void; - } - export interface SingleAssignmentDisposable { - (): ISingleAssignmentDisposable; - } - - // Multiple assignment disposable - export class SerialDisposable { - isDisposed: boolean; - current: _IDisposable; - - dispose(): void; - getDisposable(): _IDisposable; - setDisposable(value: _IDisposable): void; - disposable(value?: _IDisposable): _IDisposable; - } - - export class RefCountDisposable { - constructor(disposable: _IDisposable); - - underlyingDisposable: _IDisposable; - isDisposed: boolean; - isPrimaryDisposed: boolean; - count: number; - - dispose(): void; - getDisposable(): _IDisposable; - } - - interface IScheduledItem { - scheduler: IScheduler; - state: any; - action: (scheduler: IScheduler, state) => _IDisposable; - dueTime: number; - comparer: (x: number, y: number) =>number; - disposable: ISingleAssignmentDisposable; - - invoke(): void; - compareTo(other: IScheduledItem): number; - isCancelled(): boolean; - invokeCore(): _IDisposable; - } - - interface IScheduler { - _schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable; - _scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable; - _scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable; - - now(): number; - scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable; - scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable; - scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable; - - catchException(handler: (exception: any) =>boolean): ICatchScheduler; - schedulePeriodic(period: number, action: () =>void ): _IDisposable; - schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable} - schedule(action: () =>void ): _IDisposable; - scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable; - scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable; - scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable; - scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): _IDisposable; - scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable; - scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable; - scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable; - scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable; - } - - var Scheduler: { - //(now: () =>number, - // schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable, - // scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable, - // scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable - // ): IScheduler; - - now(): number; - normalize(timeSpan: number): number; - - immediate: IScheduler; - currentThread: ICurrentScheduler;//IScheduler; - timeout: IScheduler; - } - - // Current Thread IScheduler - interface ICurrentScheduler extends IScheduler { - scheduleRequired(): boolean; - ensureTrampoline(action: () =>_IDisposable): _IDisposable; - } - - - // CatchScheduler - interface ICatchScheduler extends IScheduler { } - - // Notifications - interface INotification { - accept(observer: IObserver): void; - accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void; - toObservable(scheduler?: IScheduler): IObservable; - hasValue: boolean; - equals(other: INotification): boolean; - kind: string; - value?: T; - exception?: any; - } - export interface Notification { - //abstract - //function new (): INotification; - - createOnNext(value: T): INotification;//ON - createOnError(exception): INotification;//OE - createOnCompleted(): INotification;//OC - } - - var Notification: Notification; - - export module Internals { - // Enumerator - interface IEnumerator { - moveNext(): boolean; - getCurrent(): T; - dispose(): void; - } - export interface Enumerator { - (moveNext: () =>boolean, getCurrent: () => T, dispose: () =>void ): IEnumerator; - - create(moveNext: () =>boolean, getCurrent: () => T, dispose?: () =>void ): IEnumerator; - } - - // Enumerable - interface IEnumerable { - getEnumerator(): IEnumerator; - - concat(): IObservable; - catchException(): IObservable; - } - export interface Enumerable { - (getEnumerator: () =>IEnumerator): IEnumerable; - - repeat(value: T, repeatCount?: number): IEnumerable; - forEach(source: T[], selector?: (element: T, index: number) => T2): IEnumerable; - forEach(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable; - } - } - - // Observer - interface IObserver { - onNext(value: T): void; - onError(exception: any): void; - onCompleted(): void; - - toNotifier(): (notification: INotification) =>void; - asObserver(): IObserver; - checked(): ICheckedObserver; - } - export module Observer { - //abstract - //function new (): IObserver; - - function create(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver; - function fromNotifier(handler: (notification: INotification) =>void ): IObserver; - } - - export module Internals { - // Abstract Observer - interface IAbstractObserver extends IObserver { - isStopped: boolean; - - dispose(): void; - next(value: T): void; - error(exception: any): void; - completed(): void; - fail(): boolean; - } - //export module AbstractObserver { - // //abstract - // function new (): IAbstractObserver; - //} - } - - export class AnonymousObserver { - constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void); - } - - interface ICheckedObserver extends IObserver { - _observer: IObserver; - _state: number; // 0 - idle, 1 - busy, 2 - done - checkAccess(): void; - } - - export module Internals { - interface IScheduledObserver extends IAbstractObserver { - scheduler: IScheduler; - observer: IObserver; - isAcquired: boolean; - hasFaulted: boolean; - //queue: { (value: any): void; (exception: any): void; (): void; }[]; - disposable: SerialDisposable; - - ensureActive(): void; - } - export interface ScheduledObserver { - (scheduler: IScheduler, observer: IObserver): IScheduledObserver; - } - } - - interface IObservable { - _subscribe: (observer: IObserver) =>_IDisposable; - - subscribe(observer: IObserver): _IDisposable; - - finalValue(): IObservable; - subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable; - toArray(): IObservable; - - observeOn(scheduler: IScheduler): IObservable; - subscribeOn(scheduler: IScheduler): IObservable; - - amb(rightSource: IObservable): IObservable; - catchException(handler: (exception: any) =>IObservable): IObservable; - catchException(second: IObservable): IObservable; - combineLatest(second: IObservable, resultSelector: (v1: T, v2: T2) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable; - combineLatest(second: IObservable, third: IObservable, fourth: IObservable, fifth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable; - combineLatest(...soucesAndResultSelector: any[]): IObservable; - concat(...sources: IObservable[]): IObservable; - concat(sources: IObservable[]): IObservable; - //concatIObservable(): IObservable; - merge(maxConcurrent: number): IObservable; - merge(other: IObservable): IObservable; - //mergeIObservable(): IObservable; - onErrorResumeNext(second: IObservable): IObservable; - skipUntil(other: IObservable): IObservable; - switchLatest(): IObservable; - takeUntil(other: IObservable): IObservable; - zip(second: IObservable, resultSelector: (v1: T, v2: T2) =>TResult): IObservable; - zip(second: IObservable, third: IObservable, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable; - zip(second: IObservable, third: IObservable, fourth: IObservable, fifth: IObservable, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - zip(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable; - asIObservable(): IObservable; - bufferWithCount(count: number, skip?: number): IObservable; - dematerialize(): IObservable; - distinctUntilChanged(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>boolean): IObservable; - doAction(observer: IObserver): IObservable; - doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable; - finallyAction(action: () =>void): IObservable; - ignoreElements(): IObservable; - materialize(): IObservable>; // IObservable> not supported by TypeScript 0.9.0 !! - repeat(repeatCount?: number): IObservable; - retry(retryCount?: number): IObservable; - scan(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - scan(accumulator: (acc: TAcc, value: T) => TAcc): IObservable; - skipLast(count: number): IObservable; - startWith(...values: T[]): IObservable; - startWith(scheduler: IScheduler, ...values: T[]): IObservable; - takeLast(count: number, scheduler?: IScheduler): IObservable; - takeLastBuffer(count: number): IObservable; - windowWithCount(count: number, skip?: number): IObservable; - defaultIfEmpty(defaultValue?: any): IObservable; - distinct(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable; - groupBy(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable; - groupByUntil(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable) => IObservable, keySerializer?: (key: TKey) => string): IGroupedObservable; - select(selector: (value: T, index: number) =>T2): IObservable; - selectMany(selector: (value: T) =>IObservable, resultSelector?: (x: any, y: any) =>any): IObservable; - selectMany(other: IObservable): IObservable; - skip(count: number): IObservable; - skipWhile(predicate: (value: T, index?: number) =>boolean): IObservable; - take(count: number, scheduler?: IScheduler): IObservable; - takeWhile(predicate: (value: T, index?: number) =>boolean): IObservable; - where(predicate: (value: T, index?: number) => boolean): IObservable; - } - - interface Observable { - (subscribe: (observer: IObserver) =>_IDisposable): IObservable; - - create(subscribe: (observer: IObserver) => void ): IObservable; - //create(subscribe: (observer: IObserver) => () => void ): IObservable; - createWithDisposable(subscribe: (observer: IObserver) =>_IDisposable): IObservable; - defer(observableFactory: () => IObservable): IObservable; - empty(scheduler?: IScheduler): IObservable; - fromArray(array: T[], scheduler?: IScheduler): IObservable; - fromArray(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable; - generate(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable; - never(): IObservable; - range(start: number, count: number, scheduler?: IScheduler): IObservable; - repeat(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable; - returnValue(value: T, scheduler?: IScheduler): IObservable; - throwException(exception: any, scheduler?: IScheduler): IObservable; - using(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable): IObservable; - amb(...sources: IObservable[]): IObservable; - catchException(sources: IObservable[]): IObservable; - catchException(...sources: IObservable[]): IObservable; - concat(...sources: IObservable[]): IObservable; - concat(sources: IObservable[]): IObservable; - merge(...sources: IObservable[]): IObservable; - merge(sources: IObservable[]): IObservable; - merge(scheduler: IScheduler, ...sources: IObservable[]): IObservable; - merge(scheduler: IScheduler, sources: IObservable[]): IObservable; - onErrorResumeNext(...sources: IObservable[]): IObservable; - onErrorResumeNext(sources: IObservable[]): IObservable; - zip(...soucesAndResultSelector: any[]): IObservable; - } - - var Observable: Observable; - - export module Internals { - interface IAnonymousObservable extends IObservable { } - export interface AnonymousObservable { - (subscribe: (observer: IObserver) =>_IDisposable): IAnonymousObservable; - } - } - - interface IGroupedObservable extends IObservable { - key: TKey; - underlyingObservable: IObservable; - } - - interface ISubject extends IObservable, IObserver { - isDisposed: boolean; - isStopped: boolean; - //observers: IObserver[]; - - dispose(): void; - } - - export interface Subject extends ISubject { - create(observer?: IObserver, observable?: IObservable): ISubject; - } - - var Subject: { - new (): Subject; - } - - interface IAsyncSubject extends IObservable, IObserver { - isDisposed: boolean; - value: T; - hasValue: boolean; - observers: IObserver[]; - exception: any; - - dispose(): void; - } - export interface AsyncSubject { - (): IAsyncSubject; - } - - interface IAnonymousSubject extends IObservable { - onNext(value: T): void; - onError(exception: any): void; - onCompleted(): void; - } -} diff --git a/rx.js/rx.js.d.ts.tscparams b/rx.js/rx.js.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.experimental.d.ts.tscparams b/rx.js/rx.js.experimental.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.experimental.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.js.joinpatterns.d.ts deleted file mode 100644 index a62b1914d..000000000 --- a/rx.js/rx.js.joinpatterns.d.ts +++ /dev/null @@ -1,20 +0,0 @@ -/// - -// Type definitions for RxJS-Join package -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.joinpatterns.js - -declare module Rx { - - //interface IObservable { - //} - - - //interface Observable { - //} -} diff --git a/rx.js/rx.js.joinpatterns.d.ts.tscparams b/rx.js/rx.js.joinpatterns.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.joinpatterns.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.jquery.d.ts b/rx.js/rx.js.jquery.d.ts deleted file mode 100644 index bfd514631..000000000 --- a/rx.js/rx.js.jquery.d.ts +++ /dev/null @@ -1,99 +0,0 @@ -/// -/// - -// Those are the definitions for bridging Rx with jQuery. -// -// Using the https://github.com/Reactive-Extensions/rxjs-jquery project -// -// Dependencies: -// -> rx.js -// -> rx.jquery.js -// -> jquery.js - -declare module JQueryResults { - - export interface eventBase{ - bubbles: boolean; - cancelable: boolean; - type: string; - preventDefault(): void; - isDefaultPrevented(): boolean; - stopPropagation(): void; - isPropagationStopped(): boolean; - data: any; - originalEvent: any; - eventPhase: number; - } - - export interface keyEvent extends eventBase { - key: number; - keyCode: number; - altKey: boolean; - ctrlKey: boolean; - shiftKey: boolean; - char: string; - metaKey: boolean; - } - - export interface uiEvent extends eventBase{ - target: any; - currentTarget: any; - } - - export interface mouseEvent extends keyEvent{ - clientX: number; - clientY: number; - screenX: number; - screenY: number; - offsetX: number; - offsetY: number; - pageX: number; - pageY: number; - which: number; - } -} - - -interface JQueryStatic { - ajaxAsObservable(settings: JQueryAjaxSettings): Rx.IObservable; - getAsObservable(url: string, data: any, dataType: string): Rx.IObservable; - getJSONAsObservable(url: string, data: any): Rx.IObservable; - getScriptAsObservable(url: string, data: any): Rx.IObservable; - postAsObservable(url: string, data: any, dataType: string): Rx.IObservable; -} - -interface JQuery { - changeAsObservable(eventData?: any): Rx.IObservable; - clickAsObservable(eventData?: any): Rx.IObservable; - dblclickAsObservable(eventData?: any): Rx.IObservable; - focusAsObservable(eventData?: any): Rx.IObservable; - focusinAsObservable(eventData?: any): Rx.IObservable; - focusoutAsObservable(eventData?: any): Rx.IObservable; - keydownAsObservable(eventData?: any): Rx.IObservable; - keyupAsObservable(eventData?: any): Rx.IObservable; - loadAsObservable(eventData?: any): Rx.IObservable; - mousedownAsObservable(eventData?: any): Rx.IObservable; - mouseenterAsObservable(eventData?: any): Rx.IObservable; - mouseleaveAsObservable(eventData?: any): Rx.IObservable; - mousemoveAsObservable(eventData?: any): Rx.IObservable; - mouseoutAsObservable(eventData?: any): Rx.IObservable; - mouseoverAsObservable(eventData?: any): Rx.IObservable; - mouseupAsObservable(eventData?: any): Rx.IObservable; - resizeAsObservable(eventData?: any): Rx.IObservable; - scrollAsObservable(eventData?: any): Rx.IObservable; - selectAsObservable(eventData?: any): Rx.IObservable; - submitAsObservable(eventData?: any): Rx.IObservable; - unloadAsObservable(eventData?: any): Rx.IObservable; - hideAsObservable(duration: number): Rx.IObservable; - showAsObservable(duration: number): Rx.IObservable; - readyAsObservable(): Rx.IObservable; - animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable; - fadeInAsObservable(duration: number, easing?: string): Rx.IObservable; - fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable; - fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable; - fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable; - slideDownAsObservable(duration: number): Rx.IObservable; - slideUpAsObservable(duration: number): Rx.IObservable; - slideToggleAsObservable(duration: number): Rx.IObservable; - toggleAsObservable(duration: number): Rx.IObservable; -} \ No newline at end of file diff --git a/rx.js/rx.js.jquery.d.ts.tscparams b/rx.js/rx.js.jquery.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.jquery.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts deleted file mode 100644 index f458dadc3..000000000 --- a/rx.js/rx.js.time.d.ts +++ /dev/null @@ -1,86 +0,0 @@ -/// - -// Type definitions for RxJS "Aggregates" -// Project: http://rx.codeplex.com/ -// Definitions by: Carl de Billy -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.time.js - -declare module Rx { - - interface ITimeInterval { - value: any; - interval: number; - } - - interface ITimestamp { - value: any; - interval: number; - } - - interface IObservable { - ifThen(condition: () => boolean, thenSource: IObservable): IObservable; - ifThen(condition: () => boolean, thenSource: IObservable, elseSource: IObservable): IObservable; - ifThen(condition: () => boolean, thenSource: IObservable, scheduler: IScheduler): IObservable; - - delay(dueTime: number, scheduler?: IScheduler): IObservable; - throttle(dueTime: number, scheduler?: IScheduler): IObservable; - windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable; - windowWithTime(timeSpan: number, scheduler?: IScheduler): IObservable; - windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable; - bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable; - bufferWithTime(timeSpan: number, scheduler?: IScheduler): IObservable; - bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable; - timeInterval(scheduler?: IScheduler): IObservable; - timestamp(scheduler?: IScheduler): IObservable; - sample(interval: number, scheduler?: IScheduler): IObservable; - sample(sampler: IObservable, scheduler?: IScheduler): IObservable; - timeout(dueTime: Date, other?: IObservable, scheduler?: IScheduler): IObservable; - timeout(dueTime: number, other?: IObservable, scheduler?: IScheduler): IObservable; - - delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable; - delayWithSelector(delayDurationSelector: (T) => number): IObservable; - delayWithSelector(subscriptionDelay: number, delayDurationSelector: (T) => number): IObservable; - - timeoutWithSelector(firstTimeout: IObservable, timeoutdurationSelector?: (T) => IObservable, other?: IObservable): IObservable; - throttleWithSelector(throttleDurationSelector: (T) => IObservable): IObservable; - - skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable; - takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable; - - takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable; - takeWithTime(duration: number, scheduler?: IScheduler): IObservable; - skipWithTime(duration: number, scheduler?: IScheduler): IObservable; - - skipUntilWithTime(startTime: Date, scheduler?: IScheduler): IObservable; - takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable; - } - - interface Observable { - interval(period: number, scheduler?: IScheduler): IObservable; - interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable; - timer(dueTime: Date, period: number, scheduler: IScheduler): IObservable; - timer(dueTime: Date, scheduler: IScheduler): IObservable; - timer(dueTime: number, period: number, scheduler: IScheduler): IObservable; - timer(dueTime: number, scheduler: IScheduler): IObservable; - - generateWithAbsoluteTime( - initialState: TState, - condition: (TState) => boolean, - iterate: (TState) => TState, - resultSelector: (TState) => TResult, - timeSelector: (TState) => Date, - scheduler?: IScheduler): IObservable; - - generateWithRelativeTime( - initialState: TState, - condition: (TState) => boolean, - iterate: (TState) => TState, - resultSelector: (TState) => TResult, - timeSelector: (TState) => number, - scheduler?: IScheduler): IObservable; - } -} \ No newline at end of file diff --git a/rx.js/rx.js.time.d.ts.tscparams b/rx.js/rx.js.time.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/rx.js/rx.js.time.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/rx.js/rx.js.virtualtime.d.ts b/rx.js/rx.js.virtualtime.d.ts deleted file mode 100644 index 24d40e601..000000000 --- a/rx.js/rx.js.virtualtime.d.ts +++ /dev/null @@ -1,37 +0,0 @@ -/// - -// Type definitions for RxJS-VirtualTime package 2.2 -// Project: http://rx.codeplex.com/ -// Definitions by: gsino -// Definitions: https://github.com/borisyankov/DefinitelyTyped -// -// Dependencies: -// -> rx.js -// -> rx.virtualtime.js - -declare module Rx { - // Virtual IScheduler - interface IVirtualTimeScheduler extends IScheduler { - toRelative(duetime): number; - toDateTimeOffset(duetime: number): number; - - clock: number; - comparer: (x: number, y: number) =>number; - isEnabled: boolean; - queue: IPriorityQueue; - scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable; - scheduleRelative(dueTime: number, action: () =>void ): _IDisposable; - start(): _IDisposable; - stop(): void; - advanceTo(time: number); - advanceBy(time: number); - sleep(time: number); - getNext(): IScheduledItem; - scheduleAbsolute(dueTime: number, action: () =>void ); - scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable; - } - //export module VirtualTimeScheduler { - // //absract - // function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler; - //} -} \ No newline at end of file diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts new file mode 100644 index 000000000..8a2dc35e5 --- /dev/null +++ b/rx.js/rx.testing.d.ts @@ -0,0 +1,53 @@ +/// +/// + +// Type definitions for RxJS-Testing +// Project: https://github.com/Reactive-Extensions/RxJS/ +// Definitions by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + export class TestScheduler extends VirtualTimeScheduler { + constructor(); + + createColdObservable(...records: Recorded[]): Observable; + createHotObservable(...records: Recorded[]): Observable; + createObserver(): MockObserver; + + startWithTiming(create: () => Observable, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver; + startWithDispose(create: () => Observable, disposedAt: number): MockObserver; + startWithCreate(create: () => Observable): MockObserver; + } + + export class Recorded { + constructor(time: number, value: any, equalityComparer?: (x: any, y: any) => boolean); + equals(other: Recorded): boolean; + toString(): string; + time: number; + value: any; + } + + export var ReactiveTest: { + created: number; + subscribed: number; + disposed: number; + + onNext(ticks: number, value: any): Recorded; + onNext(ticks: number, predicate: (value: any) => boolean): Recorded; + onError(ticks: number, exception: any): Recorded; + onError(ticks: number, predicate: (exception: any) => boolean): Recorded; + onCompleted(ticks: number): Recorded; + + subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription; + }; + + export class Subscription { + constructor(subscribeAt: number, unsubscribeAt?: number); + equals(other: Subscription): boolean; + } + + export class MockObserver extends Observer { + constructor(scheduler: IScheduler); + messages: Recorded[]; + } +} diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts new file mode 100644 index 000000000..2d5f1d14f --- /dev/null +++ b/rx.js/rx.time.d.ts @@ -0,0 +1,83 @@ +/// + +// Type definitions for RxJS "Aggregates" +// Project: http://rx.codeplex.com/ +// Definitions by: Carl de Billy +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + + export interface TimeInterval { + value: T; + interval: number; + } + + export interface Timestamp { + value: T; + timestamp: number; + } + + export interface Observable { + ifThen(condition: () => boolean, thenSource: Observable): Observable; + ifThen(condition: () => boolean, thenSource: Observable, elseSource: Observable): Observable; + ifThen(condition: () => boolean, thenSource: Observable, scheduler: IScheduler): Observable; + + delay(dueTime: number, scheduler?: IScheduler): Observable; + throttle(dueTime: number, scheduler?: IScheduler): Observable; + windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable; + windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable; + windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable; + bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable; + bufferWithTime(timeSpan: number, scheduler?: IScheduler): Observable; + bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable; + timeInterval(scheduler?: IScheduler): Observable>; + timestamp(scheduler?: IScheduler): Observable>; + sample(interval: number, scheduler?: IScheduler): Observable; + sample(sampler: Observable, scheduler?: IScheduler): Observable; + timeout(dueTime: Date, other?: Observable, scheduler?: IScheduler): Observable; + timeout(dueTime: number, other?: Observable, scheduler?: IScheduler): Observable; + + delaySubscription(dueTime: number, scheduler?: IScheduler): Observable; + delayWithSelector(delayDurationSelector: (item: T) => number): Observable; + delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable; + + timeoutWithSelector(firstTimeout: Observable, timeoutdurationSelector?: (item: T) => Observable, other?: Observable): Observable; + throttleWithSelector(throttleDurationSelector: (item: T) => Observable): Observable; + + skipLastWithTime(duration: number, scheduler?: IScheduler): Observable; + takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable; + + takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable; + takeWithTime(duration: number, scheduler?: IScheduler): Observable; + skipWithTime(duration: number, scheduler?: IScheduler): Observable; + + skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable; + takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable; + } + + interface ObservableStatic { + interval(period: number, scheduler?: IScheduler): Observable; + interval(dutTime: number, period: number, scheduler?: IScheduler): Observable; + timer(dueTime: Date, period: number, scheduler: IScheduler): Observable; + timer(dueTime: Date, scheduler: IScheduler): Observable; + timer(dueTime: number, period: number, scheduler: IScheduler): Observable; + timer(dueTime: number, scheduler: IScheduler): Observable; + + generateWithAbsoluteTime( + initialState: TState, + condition: (state: TState) => boolean, + iterate: (state: TState) => TState, + resultSelector: (state: TState) => TResult, + timeSelector: (state: TState) => Date, + scheduler?: IScheduler): Observable; + + generateWithRelativeTime( + initialState: TState, + condition: (state: TState) => boolean, + iterate: (state: TState) => TState, + resultSelector: (state: TState) => TResult, + timeSelector: (state: TState) => number, + scheduler?: IScheduler): Observable; + } +} \ No newline at end of file diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts new file mode 100644 index 000000000..293343fda --- /dev/null +++ b/rx.js/rx.virtualtime.d.ts @@ -0,0 +1,36 @@ +/// + +// Type definitions for RxJS-VirtualTime package 2.2 +// Project: http://rx.codeplex.com/ +// Definitions by: gsino +// Revision by: Igor Oleinikov +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module Rx { + // Virtual IScheduler + export /*abstract*/ class VirtualTimeScheduler extends Scheduler { + constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number); + + advanceBy(time: TRelative): void; + advanceTo(time: TAbsolute): void; + scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable; + scheduleAbsoluteWithState(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + scheduleRelative(dueTime: TRelative, action: () => void): IDisposable; + scheduleRelativeWithState(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable; + sleep(time: TRelative): void; + start(): IDisposable; + stop(): void; + + isEnabled: boolean; + + /* protected abstract */ add(from: TAbsolute, by: TRelative): TAbsolute; + /* protected abstract */ toDateTimeOffset(duetime: TAbsolute): number; + /* protected abstract */ toRelative(duetime: number): TRelative; + + /* protected */ getNext(): Internals.ScheduledItem; + } + + export class HistoricalScheduler extends VirtualTimeScheduler { + constructor(initialClock: number, comparer: (first: number, second: number) => number); + } +} diff --git a/sammyjs/sammyjs.d.ts b/sammyjs/sammyjs.d.ts index 1c9ca4877..b4fd40880 100644 --- a/sammyjs/sammyjs.d.ts +++ b/sammyjs/sammyjs.d.ts @@ -6,26 +6,20 @@ /// -interface SammyFunc { - (): Sammy.Application; - (selector: string): Sammy.Application; - (handler: Function): Sammy.Application; - (selector: string, handler: Function): Sammy.Application; -} - declare function Sammy(): Sammy.Application; declare function Sammy(selector: string): Sammy.Application; declare function Sammy(handler: Function): Sammy.Application; declare function Sammy(selector: string, handler: Function): Sammy.Application; -interface JQueryStatic { - sammy: SammyFunc; - log: Function; -} - declare module Sammy { + interface SammyFunc { + (): Sammy.Application; + (selector: string): Sammy.Application; + (handler: Function): Sammy.Application; + (selector: string, handler: Function): Sammy.Application; + } - export function Cache(app, options); + export function Cache(app, options); export function DataCacheProxy(initial, $element); export var DataLocationProxy:DataLocationProxy; export function DefaultLocationProxy(app, run_interval_every); @@ -279,5 +273,10 @@ declare module Sammy { SessionStorage(name, element); isAvailable(type); Template(app, method_alias); - } + } +} + +interface JQueryStatic { + sammy: Sammy.SammyFunc; + log: Function; } \ No newline at end of file diff --git a/select2/select2-tests.ts b/select2/select2-tests.ts index 665618daf..d3a21b188 100644 --- a/select2/select2-tests.ts +++ b/select2/select2-tests.ts @@ -144,15 +144,16 @@ $("#e11_2").select2({ data: [{ id: 0, text: 'story' }, { id: 1, text: 'bug' }, { id: 2, text: 'task' }] }); function log(e) { - var e = $("
  • " + e + "
    • "); - $("#events_11").append(e); - e.animate({ opacity: 1 }, 10000, 'linear', function () { e.animate({ opacity: 0 }, 2000, 'linear', function () { e.remove(); }); }); + var item = $("
  • " + e + "
    • "); + $("#events_11").append(item); + item.animate({ opacity: 1 }, 10000, 'linear', function () { item.animate({ opacity: 0 }, 2000, 'linear', function () { item.remove(); }); }); } $("#e11") - .on("change", function (e) { log(JSON.stringify({ val: e.val, added: e.added, removed: e.removed })); }) + // TS 0.9.5: correct overload not resolved https://typescript.codeplex.com/discussions/472172 + .on("change", function (e: Select2JQueryEventObject) { log(JSON.stringify({ val: e.val, added: e.added, removed: e.removed })); }) .on("open", function () { log("open"); }); $("#e11_2") - .on("change", function (e) { log(JSON.stringify({ val: e.val, added: e.added, removed: e.removed })); }) + .on("change", function (e: Select2JQueryEventObject) { log(JSON.stringify({ val: e.val, added: e.added, removed: e.removed })); }) .on("open", function () { log("open"); }); $("#e12").select2({ tags: ["red", "green", "blue"] }); $("#e20").select2({ diff --git a/rx.js/rx.js.virtualtime.d.ts.tscparams b/sencha_touch/SenchaTouch-Tests.ts.tscparams similarity index 100% rename from rx.js/rx.js.virtualtime.d.ts.tscparams rename to sencha_touch/SenchaTouch-Tests.ts.tscparams diff --git a/sencha_touch/SenchaTouch.d.ts b/sencha_touch/SenchaTouch.d.ts index 65ca14411..ba68b9bed 100644 --- a/sencha_touch/SenchaTouch.d.ts +++ b/sencha_touch/SenchaTouch.d.ts @@ -33504,7 +33504,7 @@ declare module Ext.form { * @returns Ext.data.Model */ getRecord?(): Ext.data.IModel; - /** [Method] Returns the value of standardSubmit + /** [Method] Returns the value of standardSubmit * @returns Boolean */ getStandardSubmit?(): boolean; @@ -33715,7 +33715,7 @@ declare module Ext.form { * @returns Ext.data.Model */ getRecord?(): Ext.data.IModel; - /** [Method] Returns the value of standardSubmit + /** [Method] Returns the value of standardSubmit * @returns Boolean */ getStandardSubmit?(): boolean; diff --git a/siesta/siesta.d.ts b/siesta/siesta.d.ts index 449bf262c..aaf6692bf 100644 --- a/siesta/siesta.d.ts +++ b/siesta/siesta.d.ts @@ -770,7 +770,7 @@ declare module Siesta { elementFromPoint(x: number, y: number, shallow?: boolean): HTMLElement; - firesAtLeastNTimes(observable: any, event: string, n: number, desc: string); + firesAtLeastNTimes(observable: any, event: string, n: number, desc: string): void; firesOk(options: any): void; diff --git a/signalr/signalr-tests.ts b/signalr/signalr-tests.ts index 4ac0752c1..8a96bf9a1 100644 --- a/signalr/signalr-tests.ts +++ b/signalr/signalr-tests.ts @@ -51,17 +51,17 @@ function test_connection() { } interface MyHubConnection extends HubConnection { - someState: string; - SomeFunction: Function; + someState: string; + SomeFunction: Function; - // My Hubs Client functions: - client: { - addMessage: (message: string) => void; - } - // My Hubs Server function: - server: { - send(message: string); - } + // My Hubs Client functions: + client: { + addMessage: (message: string) => void; + }; + // My Hubs Server function: + server: { + send(message: string); + }; } interface SignalR { @@ -110,7 +110,7 @@ function test_hubs() { .done(function (result) { console.log('The result is ' + result); }); - proxy.on('addMessage', function (msg) { + proxy.on('addMessage', function (msg?) { console.log(msg); }); var connection = $.hubConnection('http://localhost:8081/'); diff --git a/slickgrid/SlickGrid-tests.ts b/slickgrid/SlickGrid-tests.ts index a5fa63e03..1b41d1a0b 100644 --- a/slickgrid/SlickGrid-tests.ts +++ b/slickgrid/SlickGrid-tests.ts @@ -1,8 +1,6 @@ /// /// -declare var $: any; - interface MyData extends Slick.SlickData { title: string; duration: string; diff --git a/slickgrid/SlickGrid.d.ts b/slickgrid/SlickGrid.d.ts index 04af6eb33..481e6cb8d 100644 --- a/slickgrid/SlickGrid.d.ts +++ b/slickgrid/SlickGrid.d.ts @@ -1320,7 +1320,7 @@ declare module Slick { } // todo: merge with existing column definition - export interface Column { + export interface Column { sortCol?: string; sortAsc?: boolean; } diff --git a/state-machine/state-machine-tests.ts b/state-machine/state-machine-tests.ts index 98b6ccf7c..24321fc60 100644 --- a/state-machine/state-machine-tests.ts +++ b/state-machine/state-machine-tests.ts @@ -16,11 +16,11 @@ var fsm: StateMachineTest = StateMachine.create({ { name: 'clear', from: 'yellow', to: 'green' } ], callbacks: { - onpanic: function (event, from, to, msg) { alert('panic! ' + msg); }, - onclear: function (event, from, to, msg) { alert('thanks to ' + msg); }, - ongreen: function (event, from, to) { document.body.className = 'green'; }, - onyellow: function (event, from, to) { document.body.className = 'yellow'; }, - onred: function (event, from, to) { document.body.className = 'red'; }, + onpanic: function (event?, from?, to?, msg?) { alert('panic! ' + msg); }, + onclear: function (event?, from?, to?, msg?) { alert('thanks to ' + msg); }, + ongreen: function (event?, from?, to?) { document.body.className = 'green'; }, + onyellow: function (event?, from?, to?) { document.body.className = 'yellow'; }, + onred: function (event?, from?, to?) { document.body.className = 'red'; }, } }); diff --git a/swipeview/swipeview-tests.ts b/swipeview/swipeview-tests.ts index 52a5681ce..02564e11b 100644 --- a/swipeview/swipeview-tests.ts +++ b/swipeview/swipeview-tests.ts @@ -47,9 +47,9 @@ var i; for (i = 0; i < 3; i++) { - upcoming = gallery.masterPages[i].dataset.upcomingPageIndex; + upcoming = (gallery.masterPages[i].dataset).upcomingPageIndex; - if (upcoming != gallery.masterPages[i].dataset.pageIndex) { + if (upcoming != (gallery.masterPages[i].dataset).pageIndex) { el = gallery.masterPages[i].querySelector('img'); el.className = 'loading'; el.src = slides[upcoming].img; @@ -104,9 +104,9 @@ var carousel: SwipeView, i; for (i = 0; i < 3; i++) { - upcoming = carousel.masterPages[i].dataset.upcomingPageIndex; + upcoming = (carousel.masterPages[i].dataset).upcomingPageIndex; - if (upcoming != carousel.masterPages[i].dataset.pageIndex) { + if (upcoming != (carousel.masterPages[i].dataset).pageIndex) { el = carousel.masterPages[i].querySelector('span'); el.innerHTML = slides[upcoming]; } @@ -216,8 +216,8 @@ function demo3() { ereader.slider.removeChild(container); ereader.updatePageCount(pages.length); - ereader.masterPages[0].dataset.pageIndex = pages.length - 1; - ereader.masterPages[0].dataset.upcomingPageIndex = ereader.masterPages[0].dataset.pageIndex; + (ereader.masterPages[0].dataset).pageIndex = pages.length - 1; + (ereader.masterPages[0].dataset).upcomingPageIndex = (ereader.masterPages[0].dataset).pageIndex; // Load initial data for (i = 0; i < 3; i++) { @@ -240,9 +240,9 @@ function demo3() { i; for (i = 0; i < 3; i++) { - upcoming = ereader.masterPages[i].dataset.upcomingPageIndex; + upcoming = (ereader.masterPages[i].dataset).upcomingPageIndex; - if (upcoming != ereader.masterPages[i].dataset.pageIndex) { + if (upcoming != (ereader.masterPages[i].dataset).pageIndex) { el = ereader.masterPages[i].querySelector('div'); el.innerHTML = pages[upcoming]; } diff --git a/swipeview/swipeview.d.ts b/swipeview/swipeview.d.ts index 7ce476b83..8e079fa7d 100644 --- a/swipeview/swipeview.d.ts +++ b/swipeview/swipeview.d.ts @@ -16,13 +16,9 @@ interface SwipeViewOptions { loop?: boolean; } -interface PageHTMLElement extends HTMLElement { - dataset: any; -} - declare class SwipeView { - masterPages: PageHTMLElement[]; + masterPages: HTMLElement[]; currentMasterPage: number; wrapper: HTMLElement; slider: HTMLElement; diff --git a/threejs/three-r55.d.ts b/threejs/three-r55.d.ts deleted file mode 100644 index 45ed3945d..000000000 --- a/threejs/three-r55.d.ts +++ /dev/null @@ -1,5377 +0,0 @@ -/** - * three.d.ts (https://github.com/kontan/three.d.ts) - * - * Type definitions for three.js r55 (http://mrdoob.github.com/three.js/) - * - * Copyright (c) 2012- Kon (http://phyzkit.net/) - * - */ - -interface WebGLRenderingContext {} - -declare module THREE { - export var REVISION: string; - - // GL STATE CONSTANTS - - export enum CullFace { } - export var CullFaceNone: CullFace; - export var CullFaceBack: CullFace; - export var CullFaceFront: CullFace; - export var CullFaceFrontBack: CullFace; - - export enum FrontFaceDirection { } - export var FrontFaceDirectionCW: FrontFaceDirection; - export var FrontFaceDirectionCCW: FrontFaceDirection; - - // SHADOWING TYPES - - export enum ShadowMapType { } - export var BasicShadowMap: ShadowMapType; - export var PCFShadowMap: ShadowMapType; - export var PCFSoftShadowMap: ShadowMapType; - - // MATERIAL CONSTANTS - - // side - export enum Side { } - export var FrontSide: Side; - export var BackSide: Side; - export var DoubleSide: Side; - - // shading - export enum Shading { } - export var NoShading: Shading; - export var FlatShading: Shading; - export var SmoothShading: Shading; - - // colors - export enum Colors { } - export var NoColors: Colors; - export var FaceColors: Colors; - export var VertexColors: Colors; - - // blending modes - export enum Blending { } - export var NoBlending: Blending; - export var NormalBlending: Blending; - export var AdditiveBlending: Blending; - export var SubtractiveBlending: Blending; - export var MultiplyBlending: Blending; - export var CustomBlending: Blending; - - // custom blending equations - // (numbers start from 100 not to clash with other - // mappings to OpenGL constants defined in Texture.js) - export enum BlendingEquation { } - export var AddEquation: BlendingEquation; - export var SubtractEquation: BlendingEquation; - export var ReverseSubtractEquation: BlendingEquation; - - // custom blending destination factors - export enum BlendingDstFactor { } - export var ZeroFactor: BlendingDstFactor; - export var OneFactor: BlendingDstFactor; - export var SrcColorFactor: BlendingDstFactor; - export var OneMinusSrcColorFactor: BlendingDstFactor; - export var SrcAlphaFactor: BlendingDstFactor; - export var OneMinusSrcAlphaFactor: BlendingDstFactor; - export var DstAlphaFactor: BlendingDstFactor; - export var OneMinusDstAlphaFactor: BlendingDstFactor; - - // custom blending source factors - export enum BlendingSrcFactor { } - export var DstColorFactor: BlendingSrcFactor; - export var OneMinusDstColorFactor: BlendingSrcFactor; - export var SrcAlphaSaturateFactor: BlendingSrcFactor; - - // TEXTURE CONSTANTS - export enum Combine { } - export var MultiplyOperation: Combine; - export var MixOperation: Combine; - export var AddOperation: Combine; - - // Mapping modes - export enum Mapping { } - export var UVMapping: Mapping; - export var CubeReflectionMapping: Mapping; - export var CubeRefractionMapping: Mapping; - export var SphericalReflectionMapping: Mapping; - export var SphericalRefractionMapping: Mapping; - - // Wrapping modes - export enum Wrapping { } - export var RepeatWrapping: Wrapping; - export var ClampToEdgeWrapping: Wrapping; - export var MirroredRepeatWrapping: Wrapping; - - // Filters - export enum TextureFilter { } - export var NearestFilter: TextureFilter; - export var NearestMipMapNearestFilter: TextureFilter; - export var NearestMipMapLinearFilter: TextureFilter; - export var LinearFilter: TextureFilter; - export var LinearMipMapNearestFilter: TextureFilter; - export var LinearMipMapLinearFilter: TextureFilter; - - // Data types - export enum TextureDataType { } - export var UnsignedByteType: TextureDataType; - export var ByteType: TextureDataType; - export var ShortType: TextureDataType; - export var UnsignedShortType: TextureDataType; - export var IntType: TextureDataType; - export var UnsignedIntType: TextureDataType; - export var FloatType: TextureDataType; - - // Pixel types - export enum PixelType { } - // export var UnsignedByteType:number; - export var UnsignedShort4444Type: PixelType; - export var UnsignedShort5551Type: PixelType; - export var UnsignedShort565Type: PixelType; - - // Pixel formats - export enum PixelFormat { } - export var AlphaFormat: PixelFormat; - export var RGBFormat: PixelFormat; - export var RGBAFormat: PixelFormat; - export var LuminanceFormat: PixelFormat; - export var LuminanceAlphaFormat: PixelFormat; - - // Compressed texture formats - export enum CompressedPixelFormat { } - export var RGB_S3TC_DXT1_Format: CompressedPixelFormat; - export var RGBA_S3TC_DXT1_Format: CompressedPixelFormat; - export var RGBA_S3TC_DXT3_Format: CompressedPixelFormat; - export var RGBA_S3TC_DXT5_Format: CompressedPixelFormat; - - - // Potential future PVRTC compressed texture formats - // export enum CompressedTextureFormats {} - // export var RGB_PVRTC_4BPPV1_Format :CompressedTextureFormats; - // export var RGB_PVRTC_2BPPV1_Format :CompressedTextureFormats; - // export var RGBA_PVRTC_4BPPV1_Format:CompressedTextureFormats; - // export var RGBA_PVRTC_2BPPV1_Format:CompressedTextureFormats; - - - // Following enums don't be contained by three.js - - // export enum EulerOrder {} - // export var XYZ:EulerOrder; - // export var XZY:EulerOrder; - // export var YXZ:EulerOrder; - // export var YZX:EulerOrder; - // export var ZXY:EulerOrder; - // export var ZYX:EulerOrder; - - // enum UniformType {} - // i, // single integer - // f, // single float - // v2, // single THREE.Vector2 - // v3, // single THREE.Vector3 - // v4, // single THREE.Vector4 - // c, // single THREE.Color - // iv1, // flat array of integers (JS or typed array) - // iv, // flat array of integers with 3 x N size (JS or typed array) - // fv1, // flat array of floats (JS or typed array) - // fv, // flat array of floats with 3 x N size (JS or typed array) - // v2v, // array of THREE.Vector2 - // v3v, // array of THREE.Vector3 - // v4v, // array of THREE.Vector4 - // m4, // single THREE.Matrix4 - // m4v, // array of THREE.Matrix4 - // t, // single THREE.Texture (2d or cube) - // tv, // array of THREE.Texture (2d) - // } - - // Core /////////////////////////////////////////////////////////////////////////////////////////////// - - /** - * This is a superefficent class for geometries because it saves all data in buffers. - * It reduces memory costs and cpu cycles. But it is not as easy to work with because of all the nessecary buffer calculations. - * It is mainly interesting when working with static objects. - * - * @see src/core/BufferGeometry.js - */ - export class BufferGeometry { - /** - * This creates a new BufferGeometry. It also sets several properties to an default value. - */ - constructor(); - - /** - * Unique number of this buffergeometry instance - */ - id: number; - - /** - * This hashmap has as id the name of the attribute to be set and as value the buffer to set it to. - */ - attributes: { [name: string]: any; }; - - /** - * When set, it holds certain buffers in memory to have faster updates for this object. When unset, it deletes those buffers and saves memory. - */ - dynamic: boolean; - - /** - * Bounding box. - */ - boundingBox: BoundingBox3D; - - /** - * Bounding sphere. - */ - boundingSphere: BoundingSphere; - - hasTangents: boolean; - morphTargets: any[]; - - /** - * Bakes matrix transform directly into vertex coordinates. - */ - applyMatrix(matrix: Matrix4): void; - - verticesNeedUpdate: boolean; - - /** - * Computes bounding box of the geometry, updating Geometry.boundingBox attribute. - * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are null. - */ - computeBoundingBox(): void; - - /** - * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute. - * Bounding spheres aren't' computed by default. They need to be explicitly computed, otherwise they are null. - */ - computeBoundingSphere(): void; - - /** - * Computes vertex normals by averaging face normals. - */ - computeVertexNormals(): void; - - normalizeNormals(): void; - - /** - * Computes vertex tangents. - * Based on http://www.terathon.com/code/tangent.html - * Geometry must have vertex UVs (layer 0 will be used). - */ - computeTangents(): void; - - /** - * Disposes the object from memory. - * You need to call this when you want the bufferGeometry removed while the application is running. - */ - dispose(): void; - } - - /** - * Object for keeping track of time. - * - * @see src/core/Clock.js - */ - export class Clock { - /** - * @param autoStart Automatically start the clock. - */ - constructor(autoStart?: boolean); - - /** - * If set, starts the clock automatically when the first update is called. - */ - autoStart: boolean; - - /** - * When the clock is running, It holds the starttime of the clock. - * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC. - */ - startTime: number; - - /** - * When the clock is running, It holds the previous time from a update. - * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC. - */ - oldTime: number; - - /** - * When the clock is running, It holds the time elapsed btween the start of the clock to the previous update. - * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC. - */ - elapsedTime: number; - - /** - * This property keeps track whether the clock is running or not. - */ - running: boolean; - - /** - * Starts clock. - */ - start(): void; - - /** - * Stops clock. - */ - stop(): void; - - /** - * Get milliseconds passed since the clock started. - */ - getElapsedTime(): number; - - /** - * Get the milliseconds passed since the last call to this method. - */ - getDelta(): number; - } - - export interface HSV { - h: number; - s: number; - v: number; - } - - /** - * Represents a color. See also {@link ColorUtils}. - * - * @example - * var color = new THREE.Color( 0xff0000 ); - * - * @see src/math/Color.js - */ - export class Color { - constructor(hex?: string); - - /** - * @param hex initial color in hexadecimal - */ - constructor(hex?: number); - - /** - * Red channel value between 0 and 1. Default is 1. - */ - r: number; - - /** - * Green channel value between 0 and 1. Default is 1. - */ - g: number; - - /** - * Blue channel value between 0 and 1. Default is 1. - */ - b: number; - set (value: number): void; - set (value: string): void; - setHex(hex: number): Color; - - /** - * Sets this color from RGB values. - * @param r Red channel value between 0 and 1. - * @param g Green channel value between 0 and 1. - * @param b Blue channel value between 0 and 1. - */ - setRGB(r: number, g: number, b: number): Color; - - /** - * Sets this color from HSV values. - * Based on MochiKit implementation by Bob Ippolito. - * - * @param h Hue channel value between 0 and 1. - * @param s Saturation value channel between 0 and 1. - * @param v Value channel value between 0 and 1. - */ - setHSV(h: number, s: number, v: number): Color; - - /** - * Sets this color from a CSS context style string. - * @param contextStyle Color in CSS context style format. - */ - setStyle(style: string): Color; - - /** - * Copies given color. - * @param color Color to copy. - */ - copy(color: Color): Color; - - /** - * Copies given color making conversion from gamma to linear space. - * @param color Color to copy. - */ - copyGammaToLinear(color: Color): Color; - - /** - * Copies given color making conversion from linear to gamma space. - * @param color Color to copy. - */ - copyLinearToGamma(color: Color): Color; - - /** - * Converts this color from gamma to linear space. - */ - convertGammaToLinear(): Color; - - /** - * Converts this color from linear to gamma space. - */ - convertLinearToGamma(): Color; - - /** - * Returns the hexadecimal value of this color. - */ - getHex(): number; - - /** - * Returns the string formated hexadecimal value of this color. - */ - getHexString(): string; - - /** - * Returns the value of this color in CSS context style. - * Example: rgb(r, g, b) - */ - getStyle(): string; - - getHSV(hsv?: HSV): HSV; - add(color: Color): Color; - addColors(color1: Color, color2: Color): Color; - addScalar(s: number): Color; - multiply(color: Color): Color; - multiplyScalar(s: number): Color; - lerp(color: Color, alpha: number): Color; - - /** - * Clones this color. - */ - clone(): Color; - } - - var ColorKeywords: { - [name: string]: number; - aliceblue: number; - antiquewhite: number; - aqua: number; - aquamarine: number; - azure: number; - beige: number; - bisque: number; - black: number; - blanchedalmond: number; - blue: number; - blueviolet: number; - brown: number; - burlywood: number; - cadetblue: number; - chartreuse: number; - chocolate: number; - coral: number; - cornflowerblue: number; - cornsilk: number; - crimson: number; - cyan: number; - darkblue: number; - darkcyan: number; - darkgoldenrod: number; - darkgray: number; - darkgreen: number; - darkgrey: number; - darkkhaki: number; - darkmagenta: number; - darkolivegreen: number; - darkorange: number; - darkorchid: number; - darkred: number; - darksalmon: number; - darkseagreen: number; - darkslateblue: number; - darkslategray: number; - darkslategrey: number; - darkturquoise: number; - darkviolet: number; - deeppink: number; - deepskyblue: number; - dimgray: number; - dimgrey: number; - dodgerblue: number; - firebrick: number; - floralwhite: number; - forestgreen: number; - fuchsia: number; - gainsboro: number; - ghostwhite: number; - gold: number; - goldenrod: number; - gray: number; - green: number; - greenyellow: number; - grey: number; - honeydew: number; - hotpink: number; - indianred: number; - indigo: number; - ivory: number; - khaki: number; - lavender: number; - lavenderblush: number; - lawngreen: number; - lemonchiffon: number; - lightblue: number; - lightcoral: number; - lightcyan: number; - lightgoldenrodyellow: number; - lightgray: number; - lightgreen: number; - lightgrey: number; - lightpink: number; - lightsalmon: number; - lightseagreen: number; - lightskyblue: number; - lightslategray: number; - lightslategrey: number; - lightsteelblue: number; - lightyellow: number; - lime: number; - limegreen: number; - linen: number; - magenta: number; - maroon: number; - mediumaquamarine: number; - mediumblue: number; - mediumorchid: number; - mediumpurple: number; - mediumseagreen: number; - mediumslateblue: number; - mediumspringgreen: number; - mediumturquoise: number; - mediumvioletred: number; - midnightblue: number; - mintcream: number; - mistyrose: number; - moccasin: number; - navajowhite: number; - navy: number; - oldlace: number; - olive: number; - olivedrab: number; - orange: number; - orangered: number; - orchid: number; - palegoldenrod: number; - palegreen: number; - paleturquoise: number; - palevioletred: number; - papayawhip: number; - peachpuff: number; - peru: number; - pink: number; - plum: number; - powderblue: number; - purple: number; - red: number; - rosybrown: number; - royalblue: number; - saddlebrown: number; - salmon: number; - sandybrown: number; - seagreen: number; - seashell: number; - sienna: number; - silver: number; - skyblue: number; - slateblue: number; - slategray: number; - slategrey: number; - snow: number; - springgreen: number; - steelblue: number; - tan: number; - teal: number; - thistle: number; - tomato: number; - turquoise: number; - violet: number; - wheat: number; - white: number; - whitesmoke: number; - yellow: number; - yellowgreen: number; - }; - - export class EventDispatcher { - constructor(); - addEventListener(type: string, listener: (event: any) => void ): void; - dispatchEvent(event: { type:string; target: any; }): void; - removeEventListener(type: string, listener: (event: any) => void ): void; - } - - export interface Face { - /** - * Face normal. - */ - normal: Vector3; - - /** - * Face color. - */ - color: Color; - - /** - * Array of 4 vertex normals. - */ - vertexNormals: Vector3[]; - - /** - * Array of 4 vertex normals. - */ - vertexColors: Color[]; - - /** - * Array of 4 vertex tangets. - */ - vertexTangents: number[]; - - /** - * Material index (points to {@link Geometry.materials}). - */ - materialIndex: number; - - /** - * Face centroid. - */ - centroid: Vector3; - - clone(): Face; - } - - /** - * Triangle face. - * - * @example - * var normal = new THREE.Vector3( 0, 1, 0 ); - * var color = new THREE.Color( 0xffaa00 ); - * var face = new THREE.Face3( 0, 1, 2, normal, color, 0 ); - * - * @see src/core/Face3.js - */ - export class Face3 implements Face { - /** - * @param a Vertex A index. - * @param b Vertex B index. - * @param c Vertex C index. - * @param normal Face normal or array of vertex normals. - * @param color Face color or array of vertex colors. - * @param materialIndex Material index. - */ - constructor(a: number, b: number, c: number, normal?: Vector3, color?: Color, materialIndex?: number); - constructor(a: number, b: number, c: number, normal?: Vector3, vertexColors?: Color[], materialIndex?: number); - constructor(a: number, b: number, c: number, vertexNormals?: Vector3[], color?: Color, materialIndex?: number); - constructor(a: number, b: number, c: number, vertexNormals?: Vector3[], vertexColors?: Color[], materialIndex?: number); - - /** - * Vertex A index. - */ - a: number; - - /** - * Vertex B index. - */ - b: number; - - /** - * Vertex C index. - */ - c: number; - - clone(): Face3; - - // properties inherits from Face /////////////////////////////////// - - /** - * Face normal. - */ - normal: Vector3; - - /** - * Face color. - */ - color: Color; - - /** - * Array of 4 vertex normals. - */ - vertexNormals: Vector3[]; - - /** - * Array of 4 vertex normals. - */ - vertexColors: Color[]; - - /** - * Array of 4 vertex tangets. - */ - vertexTangents: number[]; - - /** - * Material index (points to {@link Geometry.materials}). - */ - materialIndex: number; - - /** - * Face centroid. - */ - centroid: Vector3; - } - - /** - * Quad face. - * - * @example - * var normal = new THREE.Vector3( 0, 1, 0 ); - * var color = new THREE.Color( 0xffaa00 ); - * var face = new THREE.Face4( 0, 1, 2, 3, normal, color, 0 ); - * - * @see src/core/Face4.js - */ - export class Face4 implements Face { - /** - * @param a Vertex A index. - * @param b Vertex B index. - * @param c Vertex C index. - * @param d Vertex D index. - * @param normal Face normal or array of vertex normals. - * @param color Face color or array of vertex colors. - * @param materialIndex Material index. - */ - constructor(a: number, b: number, c: number, d: number, normal?: Vector3, color?: Color, materialIndex?: number); - constructor(a: number, b: number, c: number, d: number, normal?: Vector3, vertexColors?: Color[], materialIndex?: number); - constructor(a: number, b: number, c: number, d: number, vertexNormals?: Vector3[], color?: Color, materialIndex?: number); - constructor(a: number, b: number, c: number, d: number, vertexNormals?: Vector3[], vertexColors?: Color[], materialIndex?: number); - - /** - * Vertex A index. - */ - a: number; - - /** - * Vertex B index. - */ - b: number; - - /** - * Vertex C index. - */ - c: number; - - /** - * Vertex D index. - */ - d: number; - - clone(): Face4; - - - - // properties inherits from Face /////////////////////////////////// - - /** - * Face normal. - */ - normal: Vector3; - - /** - * Face color. - */ - color: Color; - - /** - * Array of 4 vertex normals. - */ - vertexNormals: Vector3[]; - - /** - * Array of 4 vertex normals. - */ - vertexColors: Color[]; - - /** - * Array of 4 vertex tangets. - */ - vertexTangents: number[]; - - /** - * Material index (points to {@link Geometry.materials}). - */ - materialIndex: number; - - /** - * Face centroid. - */ - centroid: Vector3; - } - - /** - * Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process. - */ - export class Frustum { - constructor(p0?: number, p1?: number, p2?: number, p3?: number, p4?: number, p5?: number); - - /** - * Array of 6 vectors. - */ - planes: Plane[]; - - set (p0?: number, p1?: number, p2?: number, p3?: number, p4?: number, p5?: number): Frustum; - copy(frustum: Frustum): Frustum; - setFromMatrix(m: Matrix4): Frustum; - - /** - * Checks whether the object is inside the Frustum. - */ - intersectsObject(object: Object3D): boolean; - - intersectsSphere(sphere: Sphere): boolean; - containsPoint(point: Vector3): boolean; - clone(): Frustum; - } - - export class Plane { - constructor(normal?: Vector3, constant?: number); - normal: Vector3; - constant: number; - set (normal: Vector3, constant: number): Plane; - setComponents(x: number, y: number, z: number, w: number): Plane; - setFromNormalAndCoplanarPoint(normal: Vector3, point: Vector3): Plane; - setFromCoplanarPoints(a: Vector3, b: Vector3, c: Vector3): Plane; - copy(plane: Plane): Plane; - normalize(): Plane; - negate(): Plane; - distanceToPoint(point: Vector3): number; - distanceToSphere(sphere: Sphere): number; - projectPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - orthoPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - isIntersectionLine(startPoint: Vector3, endPoint: Vector3): boolean; - coplanarPoint(optionalTarget?: boolean): Vector3; - transform(matrix: Matrix3, optionalNormalMatrix?: Matrix3): Plane; - translate(offset: Vector3): Plane; - equals(plane: Plane): boolean; - clone(): Plane; - } - - export class Sphere { - constructor(center?: Vector3, radius?: number); - center: Vector3; - radius: number; - set (center: Vector3, radius: number): Sphere; - setFromCenterAndPoints(center: Vector3, points: Vector3[]): Sphere; - copy(sphere: Sphere): Sphere; - empty(): boolean; - containsPoint(point: Vector3): boolean; - distanceToPoint(point: Vector3): number; - intersectsSphere(sphere: Sphere): boolean; - clampPoint(point: Vector3, optionalTarget?: Vector3): Sphere; - getBoundingBox(optionalTarget: Box3): Box3; - transform(matrix: Matrix): Sphere; - translate(offset: Vector3): Sphere; - equals(sphere: Sphere): boolean; - clone(): Sphere; - } - - - export interface MorphTarget { - name: string; - vertices: Vector3[]; - } - - export interface MorphColor { - name: string; - color: Color[]; - } - - export interface BoundingBox3D { - min: Vector3; - max: Vector3; - } - - export interface BoundingSphere { - radius: number; - } - - - /** - * Base class for geometries - * - * @example - * var geometry = new THREE.Geometry(); - * geometry.vertices.push( new THREE.Vector3( -10, 10, 0 ) ); - * geometry.vertices.push( new THREE.Vector3( -10, -10, 0 ) ); - * geometry.vertices.push( new THREE.Vector3( 10, -10, 0 ) ); - * geometry.faces.push( new THREE.Face3( 0, 1, 2 ) ); - * geometry.computeBoundingSphere(); - * - * @see src/core/Geometry.js - */ - export class Geometry { - constructor(); - id: number; - name: string; - vertices: Vector3[]; - colors: Color[]; - materials: Material[]; - faces: Face[]; - faceUvs: Vector2[]; - faceVertexUvs: Vector2[][]; - morphTargets: MorphTarget[]; - morphColors: MorphColor[]; - skinWeights: number[]; - skinIndices: number[]; - boundingBox: BoundingBox3D; - boundingSphere: BoundingSphere; - hasTangents: boolean; - dynamic: boolean; - verticesNeedUpdate: boolean; - elementsNeedUpdate: boolean; - uvsNeedUpdate: boolean; - normalsNeedUpdate: boolean; - tangentsNeedUpdate: boolean; - colorsNeedUpdate: boolean; - lineDistancesNeedUpdate: boolean; - buffersNeedUpdate: boolean; - animation: AnimationData; - - /** - * Bakes matrix transform directly into vertex coordinates. - */ - applyMatrix(matrix: Matrix4): void; - - /** - * Computes centroids for all faces. - */ - computeCentroids(): void; - - /** - * Computes face normals. - */ - computeFaceNormals(): void; - - /** - * Computes vertex normals by averaging face normals. - * Face normals must be existing / computed beforehand. - */ - computeVertexNormals(areaWeighted?: boolean): void; - - computeMorphNormals(): void; - - /** - * Computes vertex tangents. - * Based on http://www.terathon.com/code/tangent.html - * Geometry must have vertex UVs (layer 0 will be used). - */ - computeTangents(): void; - - computeLineDistances(): void; - - /** - * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute. - */ - computeBoundingBox(): void; - - /** - * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute. - * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null. - */ - computeBoundingSphere(): void; - - /** - * Checks for duplicate vertices using hashmap. - * Duplicated vertices are removed and faces' vertices are updated. - */ - mergeVertices(): number; - - clone(): Geometry; - - dispose(): void; - } - - var GeometryIdCount: number; - var GeometryLibrary: Geometry[]; - - /** - * - * @see src/math/Math.js - */ - export var Math: { - /** - * Clamps the x to be between a and b. - * - * @param x Value to be clamped. - * @param a Minimum value - * @param b Maximum value. - */ - clamp(x: number, a: number, b: number): number; - - /** - * Clamps the x to be larger than a. - * - * @param x — Value to be clamped. - * @param a — Minimum value - */ - clampBottom(x: number, a: number): number; - - /** - * Linear mapping of x from range [a1, a2] to range [b1, b2]. - * - * @param x Value to be mapped. - * @param a1 Minimum value for range A. - * @param a2 Maximum value for range A. - * @param b1 Minimum value for range B. - * @param b2 Maximum value for range B. - */ - mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number; - - /** - * Random float from 0 to 1 with 16 bits of randomness. - * Standard Math.random() creates repetitive patterns when applied over larger space. - */ - random16(): number; - - /** - * Random integer from low to high interval. - */ - randInt(low: number, high: number): number; - - /** - * Random float from low to high interval. - */ - randFloat(low: number, high: number): number; - - /** - * Random float from - range / 2 to range / 2 interval. - */ - randFloatSpread(range: number): number; - - /** - * Returns -1 if x is less than 0, 1 if x is greater than 0, and 0 if x is zero. - */ - sign(x: number): number; - }; - - /** - * A 3x3 matrix. - * - * ( interface Matrix ) - */ - export interface Matrix { - /** - * Float32Array with matrix values. - */ - elements: Float32Array; - - /** - * identity():T; - */ - identity(): Matrix; - - /** - * copy(m:T):T; - */ - copy(m: Matrix): Matrix; - - multiplyVector3Array(a: number[]): number[]; - - /** - * multiplyScalar(s:number):T; - */ - multiplyScalar(s: number): Matrix; - - determinant(): number; - - /** - * getInverse(matrix:T, throwOnInvertible?:boolean):T; - */ - getInverse(matrix: Matrix, throwOnInvertible?: boolean): Matrix; - - /** - * transpose():T; - */ - transpose(): Matrix; - - /** - * clone():T; - */ - clone(): Matrix; - } - - /** - * ( class Matrix3 implements Matrix ) - */ - export class Matrix3 implements Matrix { - constructor(n11?: number, n12?: number, n13?: number, n21?: number, n22?: number, n23?: number, n31?: number, n32?: number, n33?: number); - - /** - * Float32Array with matrix values. - */ - elements: Float32Array; - - set (n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): Matrix3; - identity(): Matrix3; - copy(m: Matrix3): Matrix3; - multiplyVector3Array(a: number[]): number[]; - multiplyScalar(s: number): Matrix3; - determinant(): number; - getInverse(matrix: Matrix3, throwOnInvertible?: boolean): Matrix3; - - /** - * Transposes this matrix in place. - */ - transpose(): Matrix3; - - /** - * Transposes this matrix into the supplied array r, and returns itself. - */ - transposeIntoArray(r: number[]): number[]; - - clone(): Matrix3; - } - - /** - * A 4x4 Matrix. - * - * @example - * // Simple rig for rotating around 3 axes - * var m = new THREE.Matrix4(); - * var m1 = new THREE.Matrix4(); - * var m2 = new THREE.Matrix4(); - * var m3 = new THREE.Matrix4(); - * var alpha = 0; - * var beta = Math.PI; - * var gamma = Math.PI/2; - * m1.makeRotationX( alpha ); - * m2.makeRotationY( beta ); - * m3.makeRotationZ( gamma ); - * m.multiplyMatrices( m1, m2 ); - * m.multiply( m3 ); - */ - export class Matrix4 implements Matrix { - - /** - * Initialises the matrix with the supplied n11..n44 values, or just creates an identity matrix if no values are passed. - */ - constructor(n11?: number, n12?: number, n13?: number, n14?: number, n21?: number, n22?: number, n23?: number, n24?: number, n31?: number, n32?: number, n33?: number, n34?: number, n41?: number, n42?: number, n43?: number, n44?: number); - - /** - * Float32Array with matrix values. - */ - elements: Float32Array; - - /** - * Sets all fields of this matrix. - */ - set (n11: number, n12: number, n13: number, n14: number, n21: number, n22: number, n23: number, n24: number, n31: number, n32: number, n33: number, n34: number, n41: number, n42: number, n43: number, n44: number): Matrix4; - - /** - * Resets this matrix to identity. - */ - identity(): Matrix4; - - /** - * Copies a matrix m into this matrix. - */ - copy(m: Matrix4): Matrix4; - - /** - * Sets the rotation submatrix of this matrix to the rotation specified by Euler angles. - * Default order is "XYZ". - * - * @param v Rotation vector. order — The order of rotations. Eg. "XYZ". - */ - setRotationFromEuler(v: Vector3, order: string): Matrix4; - - /** - * Sets the rotation submatrix of this matrix to the rotation specified by q. - */ - setRotationFromQuaternion(q: Quaternion): Matrix4; - - /** - * Constructs a rotation matrix, looking from eye towards center with defined up vector. - */ - lookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix4; - - /** - * Multiplies this matrix by m. - */ - multiply(m: Matrix4): Matrix4; - - /** - * Sets this matrix to a x b. - */ - multiplyMatrices(a: Matrix4, b: Matrix4): Matrix4; - - /** - * Sets this matrix to a x b and stores the result into the flat array r. - * r can be either a regular Array or a TypedArray. - */ - multiplyToArray(a: Matrix4, b: Matrix4, r: number[]): Matrix4; - - /** - * Multiplies this matrix by s. - */ - multiplyScalar(s: number): Matrix4; - - multiplyVector3Array(a: number[]): number[]; - - rotateAxis(v: Vector3): Vector3; - - /** - * Computes the cross product between this matrix and the Vector4 parameter a. - */ - crossVector(a: Vector3): Vector4; - - /** - * Computes determinant of this matrix. - * Based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm - */ - determinant(): number; - - /** - * Transposes this matrix. - */ - transpose(): Matrix4; - - /** - * Flattens this matrix into supplied flat array. - */ - flattenToArray(flat: number[]): number[]; - - /** - * Flattens this matrix into supplied flat array starting from offset position in the array. - */ - flattenToArrayOffset(flat: number[], offset: number): number[]; - - /** - * Returns position component from this matrix. - * Note: this method returns a reference to the internal class vector, make a copy or clone it if you don't use it right away. - */ - getPosition(): Vector3; - - /** - * Sets the position component for this matrix from vector v. - */ - setPosition(v: Vector3): Vector3; - - /** - * Returns x column component from this matrix. - * Note: this method returns a reference to the internal class vector, make a copy or clone it if you don't use it right away. - */ - getColumnX(): Vector3; - - /** - * Returns y column component from this matrix. - * Note: this method returns a reference to the internal class vector, make a copy or clone it if you don't use it right away. - */ - getColumnY(): Vector3; - - /** - * Returns z column component from this matrix. - * Note: this method returns a reference to the internal class vector, make a copy or clone it if you don't use it right away. - */ - getColumnZ(): Vector3; - - /** - * Sets this matrix to the inverse of matrix m. - * Based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm. - */ - getInverse(m: Matrix4, throwOnInvertible?: boolean): Matrix4; - - /** - * Sets this matrix to the transformation composed of translation, rotation and scale. - */ - compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4; - - /** - * Decomposes this matrix into the translation, rotation and scale components. - * If parameters are not passed, new instances will be created. - */ - decompose(translation?: Vector3, rotation?: Quaternion, scale?: Vector3): Object[]; // [Vector3, Quaternion, Vector3] - - /** - * Copies the translation component of the supplied matrix m into this matrix translation component. - */ - extractPosition(m: Matrix4): Matrix4; - - /** - * Copies the rotation component of the supplied matrix m into this matrix rotation component. - */ - extractRotation(m: Matrix4): Matrix4; - - /** - * Translates this matrix by vector v. - */ - translate(v: Vector3): Matrix4; - - /** - * Rotates this matrix around the x axis by angle. - */ - rotateX(angle: number): Matrix4; - - /** - * Rotates this matrix around the y axis by angle. - */ - rotateY(angle: number): Matrix4; - - /** - * Rotates this matrix around the z axis by angle. - */ - rotateZ(angle: number): Matrix4; - - /** - * Rotates this matrix around the supplied axis by angle. - */ - rotateByAxis(axis: Vector3, angle: number): Matrix4; - - /** - * Multiplies the columns of this matrix by vector v. - */ - scale(v: Vector3): Matrix4; - - getMaxScaleOnAxis(): number; - - /** - * Sets this matrix as translation transform. - */ - makeTranslation(x: number, y: number, z: number): Matrix4; - - /** - * Sets this matrix as rotation transform around x axis by theta radians. - * - * @param theta Rotation angle in radians. - */ - makeRotationX(theta: number): Matrix4; - - /** - * Sets this matrix as rotation transform around y axis by theta radians. - * - * @param theta Rotation angle in radians. - */ - makeRotationY(theta: number): Matrix4; - - /** - * Sets this matrix as rotation transform around z axis by theta radians. - * - * @param theta Rotation angle in radians. - */ - makeRotationZ(theta: number): Matrix4; - - /** - * Sets this matrix as rotation transform around axis by angle radians. - * Based on http://www.gamedev.net/reference/articles/article1199.asp. - * - * @param axis Rotation axis. - * @param theta Rotation angle in radians. - */ - makeRotationAxis(axis: Vector3, angle: number): Matrix4; - - /** - * Sets this matrix as scale transform. - */ - makeScale(x: number, y: number, z: number): Matrix4; - - /** - * Creates a frustum matrix. - */ - makeFrustum(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4; - - /** - * Creates a perspective projection matrix. - */ - makePerspective(fov: number, aspect: number, near: number, far: number): Matrix4; - - /** - * Creates an orthographic projection matrix. - */ - makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4; - - /** - * Clones this matrix. - */ - clone(): Matrix4; - } - - export class Ray { - constructor(origin?: Vector3, direction?: Vector3); - origin: Vector3; - direction: Vector3; - set (origin: Vector3, direction: Vector3): Ray; - copy(ray: Ray): Ray; - at(t: number, optionalTarget?: Vector3): Vector3; - recastSelf(t: number): Ray; - closestPointToPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - distanceToPoint(point: Vector3): number; - isIntersectionSphere(sphere: Sphere): boolean; - isIntersectionPlane(plane: Plane): boolean; - distanceToPlane(plane: Plane): number; - intersectPlane(plane: Plane, optionalTarget?: Vector3): Vector3; - transform(matrix4: Matrix4): Ray; - equals(ray: Ray): boolean; - clone(): Ray; - } - - - /** - * Base class for scene graph objects - */ - export class Object3D { - constructor(); - - /** - * Unique number of this object instance. - */ - id: number; - - /** - * Optional name of the object (doesn't need to be unique). - */ - name: string; - - properties: any; - - /** - * Object's parent in the scene graph. - */ - parent: Object3D; - - /** - * Array with object's children. - */ - children: Object3D[]; - - /** - * Object's local position. - */ - position: Vector3; - - /** - * Object's local rotation (Euler angles), in radians. - */ - rotation: Vector3; - - /** - * Order of axis for Euler angles. - */ - eulerOrder: string; - // eulerOrder:EulerOrder; - - /** - * Object's local scale. - */ - scale: Vector3; - - /** - * Up direction. - */ - up: Vector3; - - /** - * Local transform. - */ - matrix: Matrix4; - - /** - * Global rotation. - */ - matrixRotationWorld: Matrix4; - - /** - * Global rotation. - */ - quaternion: Quaternion; - - /** - * Use quaternion instead of Euler angles for specifying local rotation. - */ - useQuaternion: boolean; - - /** - * Default is 0.0. - */ - boundRadius: number; - - /** - * Maximum scale from x, y, z scale components. - */ - boundRadiusScale: number; - - /** - * Override depth-sorting order if non null. - */ - renderDepth: number; - - /** - * Object gets rendered if true. - */ - visible: boolean; - - /** - * Gets rendered into shadow map. - */ - castShadow: boolean; - - /** - * Material gets baked in shadow receiving. - */ - receiveShadow: boolean; - - frustumCulled: boolean; - matrixAutoUpdate: boolean; - matrixWorldNeedsUpdate: boolean; - rotationAutoUpdate: boolean; - applyMatrix(matrix: Matrix4): void; - translate(distance: number, axis: Vector3): void; - translateX(distance: number): void; - translateY(distance: number): void; - translateZ(distance: number): void; - localToWorld(vector: Vector3): Vector3; - worldToLocal(vector: Vector3): Vector3; - lookAt(vector: Vector3): void; - - /** - * Adds object as child of this object. - */ - add(object: Object3D): void; - - /** - * Removes object as child of this object. - */ - remove(object: Object3D): void; - - /** - * Translates object along arbitrary axis by distance. - * @param distance Distance. - * @param axis Translation direction. - */ - traverse(callback: (object: Object3D) => any): void; - - /** - * Gets first child with name matching the argument. Searches whole subgraph recursively if recursive is true. - * @param name Object name. - * @param recursive Whether check in the objects's children. - */ - getChildByName(name: string, recursive: boolean): Object3D; - - /** - * Searches whole subgraph recursively to add all objects in the array. - * @param array optional argument that returns the the array with descendants. - */ - getDescendants(array?: Object3D[]): Object3D[]; - - /** - * Updates local transform. - */ - updateMatrix(): void; - - /** - * Updates global transform of the object and its children. - */ - updateMatrixWorld(force: boolean): void; - clone(object?: Object3D): Object3D; - deallocate(): void; - - static defaultEulerOrder: string; - // static defaultEulerOrder:EulerOrder; - } - - var Object3DIdCount: number; - var Object3DLibrary: Object3D[]; - - /** - * Projects points between spaces. - */ - export class Projector { - - constructor(); - - projectVector(vector: Vector3, camera: Camera): Vector3; - - unprojectVector(vector: Vector3, camera: Camera): Vector3; - - /** - * Translates a 2D point from NDC (Normalized Device Coordinates) to a Raycaster that can be used for picking. NDC range from [-1..1] in x (left to right) and [1.0 .. -1.0] in y (top to bottom). - */ - pickingRay(vector: Vector3, camera: Camera): Raycaster; - - /** - * Transforms a 3D scene object into 2D render data that can be rendered in a screen with your renderer of choice, projecting and clipping things out according to the used camera. - * If the scene were a real scene, this method would be the equivalent of taking a picture with the camera (and developing the film would be the next step, using a Renderer). - * - * @param scene scene to project. - * @param camera camera to use in the projection. - * @param sort select whether to sort elements using the Painter's algorithm. - */ - projectScene(scene: Scene, camera: Camera, sortObjects: boolean, sortElements?: boolean): { - objects: Object3D[]; // Mesh, Line or other object - sprites: Object3D[]; // Sprite or Particle - lights: Light[]; - elements: Face[]; // Line, Particle, Face3 or Face4 - }; - } - - /** - * Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages. - * - * @example - * var quaternion = new THREE.Quaternion(); - * quaternion.setFromAxisAngle( new THREE.Vector3( 0, 1, 0 ), Math.PI / 2 ); - * var vector = new THREE.Vector3( 1, 0, 0 ); - * vector.applyQuaternion( quaternion ); - */ - export class Quaternion { - /** - * @param x x coordinate - * @param y y coordinate - * @param z z coordinate - * @param w w coordinate - */ - constructor(x?: number, y?: number, z?: number, w?: number); - - x: number; - y: number; - z: number; - w: number; - - /** - * Sets values of this quaternion. - */ - set (x: number, y: number, z: number, w: number): Quaternion; - - /** - * Copies values of q to this quaternion. - */ - copy(q: Quaternion): Quaternion; - - /** - * Sets this quaternion from rotation specified by Euler angles. - */ - setFromEuler(v: Vector3, order: string): Quaternion; - - /** - * Sets this quaternion from rotation specified by axis and angle. - * Adapted from http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm. - * Axis have to be normalized, angle is in radians. - */ - setFromAxisAngle(axis: Vector3, angle: number): Quaternion; - - /** - * Sets this quaternion from rotation component of m. Adapted from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm. - */ - setFromRotationMatrix(m: Matrix4): Quaternion; - - /** - * Inverts this quaternion. - */ - inverse(): Quaternion; - - conjugate(): Quaternion; - - lengthSq(): number; - - /** - * Computes length of this quaternion. - */ - length(): number; - - /** - * Normalizes this quaternion. - */ - normalize(): Quaternion; - - /** - * Multiplies this quaternion by b. - */ - multiply(q: Quaternion): Quaternion; - - /** - * Sets this quaternion to a x b - * Adapted from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm. - */ - multiplyQuaternions(a: Quaternion, b: Quaternion): Quaternion; - - slerp(qb: Quaternion, t: number): Quaternion; - - equals(v: Quaternion): boolean; - - /** - * Clones this quaternion. - */ - clone(): Quaternion; - - /** - * Adapted from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/. - */ - static slerp(qa: Quaternion, qb: Quaternion, qm: Quaternion, t: number): Quaternion; - } - - export interface Intersection { - distance: number; - point: Vector3; - face: Face; - object: Object3D; - } - - export class Raycaster { - constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number); - origin: Vector3; - direction: Vector3; - near: number; - far: number; - precision: number; - set (origin: Vector3, direction: Vector3): void; - intersectObject(object: Object3D, recursive?: boolean): Intersection[]; - intersectObjects(objects: Object3D[], recursive?: boolean): Intersection[]; - } - - export interface SplineControlPoint { - x: number; - y: number; - z: number; - } - - /** - * Represents a spline. - * - * @see src/math/Spline.js - */ - export class Spline { - /** - * Initialises the spline with points, which are the places through which the spline will go. - */ - constructor(points: SplineControlPoint[]); - - points: SplineControlPoint[]; - - /** - * Initialises using the data in the array as a series of points. Each value in a must be another array with three values, where a[n] is v, the value for the nth point, and v[0], v[1] and v[2] are the x, y and z coordinates of that point n, respectively. - * - * @param a array of triplets containing x, y, z coordinates - */ - initFromArray(a: number[][]): void; - - /** - * Return the interpolated point at k. - * - * @param k point index - */ - getPoint(k: number): SplineControlPoint; - - /** - * Returns an array with triplets of x, y, z coordinates that correspond to the current control points. - */ - getControlPointsArray(): number[][]; - - /** - * Returns the length of the spline when using nSubDivisions. - * @param nSubDivisions number of subdivisions between control points. Default is 100. - */ - getLength(nSubDivisions?: number): { chunks: number[]; total: number; }; - - /** - * Modifies the spline so that it looks similar to the original but has its points distributed in such way that moving along the spline it's done at a more or less constant speed. The points should also appear more uniformly spread along the curve. - * This is done by resampling the original spline, with the density of sampling controlled by samplingCoef. Here it's interesting to note that denser sampling is not necessarily better: if sampling is too high, you may get weird kinks in curvature. - * - * @param samplingCoef how many intermediate values to use between spline points - */ - reparametrizeByArcLength(samplingCoef: number): void; - } - - - /** - * ( interface Vector ) - * - * Abstruct interface of Vector2, Vector3 and Vector4. - * Currently the members of Vector is NOT type safe because it accepts different typed vectors. - * Those definitions will be changed when TypeScript innovocates Generics to be type safe. - * - * @example - * var v:THREE.Vector = new THREE.Vector3(); - * v.addVectors(new THREE.Vector2(0, 1), new THREE.Vector2(2, 3)); // invalid but compiled successfully - */ - export interface Vector { - /** - * copy(v:T):T; - */ - copy(v: Vector): Vector; - - /** - * add(v:T):T; - */ - add(v: Vector): Vector; - - /** - * addVectors(a:T, b:T):T; - */ - addVectors(a: Vector, b: Vector): Vector; - - /** - * sub(v:T):T; - */ - sub(v: Vector): Vector; - - /** - * subVectors(a:T, b:T):T; - */ - subVectors(a: Vector, b: Vector): Vector; - - /** - * multiplyScalar(s:number):T; - */ - multiplyScalar(s: number): Vector; - - /** - * divideScalar(s:number):T; - */ - divideScalar(s: number): Vector; - - /** - * negate():T; - */ - negate(): Vector; - - /** - * dot(v:T):T; - */ - dot(v: Vector): number; - - /** - * lengthSq():number; - */ - lengthSq(): number; - - /** - * length():number; - */ - length(): number; - - /** - * normalize():T; - */ - normalize(): Vector; - - /** - * NOTE: Vector4 doesn't have the property. - * - * distanceTo(v:T):number; - */ - distanceTo(v: Vector): number; - - /** - * NOTE: Vector4 doesn't have the property. - * - * distanceToSquared(v:T):number; - */ - distanceToSquared(v: Vector): number; - - /** - * setLength(l:number):T; - */ - setLength(l: number): Vector; - - /** - * lerp(v:T, alpha:number):T; - */ - lerp(v: Vector, alpha: number): Vector; - - /** - * equals(v:T):boolean; - */ - equals(v: Vector): boolean; - - /** - * clone():T; - */ - clone(): Vector; - } - - /** - * 2D vector. - * - * ( class Vector2 implements Vector ) - */ - export class Vector2 implements Vector { - - constructor(x?: number, y?: number); - - x: number; - - y: number; - - /** - * Sets value of this vector. - */ - set (x: number, y: number): Vector2; - - /** - * Copies value of v to this vector. - */ - copy(v: Vector2): Vector2; - - /** - * Adds v to this vector. - */ - add(v: Vector2): Vector2; - - /** - * Sets this vector to a + b. - */ - addVectors(a: Vector2, b: Vector2): Vector2; - - /** - * Subtracts v from this vector. - */ - sub(v: Vector2): Vector2; - - /** - * Sets this vector to a - b. - */ - subVectors(a: Vector2, b: Vector2): Vector2; - - /** - * Multiplies this vector by scalar s. - */ - multiplyScalar(s: number): Vector2; - - /** - * Divides this vector by scalar s. - * Set vector to ( 0, 0 ) if s == 0. - */ - divideScalar(s: number): Vector2; - - /** - * Inverts this vector. - */ - negate(): Vector2; - - /** - * Computes dot product of this vector and v. - */ - dot(v: Vector2): number; - - /** - * Computes squared length of this vector. - */ - lengthSq(): number; - - /** - * Computes length of this vector. - */ - length(): number; - - /** - * Normalizes this vector. - */ - normalize(): Vector2; - - /** - * Computes distance of this vector to v. - */ - distanceTo(v: Vector2): number; - - /** - * Computes squared distance of this vector to v. - */ - distanceToSquared(v: Vector2): number; - - /** - * Normalizes this vector and multiplies it by l. - */ - setLength(l: number): Vector2; - - lerp(v: Vector2, alpha: number): Vector2; - - /** - * Checks for strict equality of this vector and v. - */ - equals(v: Vector2): boolean; - - /** - * Clones this vector. - */ - clone(): Vector2; - } - - /** - * 3D vector. - * - * @example - * var a = new THREE.Vector3( 1, 0, 0 ); - * var b = new THREE.Vector3( 0, 1, 0 ); - * var c = new THREE.Vector3(); - * c.crossVectors( a, b ); - * - * @see src/math/Vector3.js - * - * ( class Vector3 implements Vector ) - */ - export class Vector3 implements Vector { - - constructor(x?: number, y?: number, z?: number); - - x: number; - - y: number; - - z: number; - - /** - * Sets value of this vector. - */ - set (x: number, y: number, z: number): Vector3; - - /** - * Sets x value of this vector. - */ - setX(x: number): Vector3; - - /** - * Sets y value of this vector. - */ - setY(y: number): Vector3; - - /** - * Sets z value of this vector. - */ - setZ(z: number): Vector3; - - setComponent(index: number, value: number): void; - - getComponent(index: number): number; - - /** - * Copies value of v to this vector. - */ - copy(v: Vector3): Vector3; - - /** - * Adds v to this vector. - */ - add(a: Object): Vector3; - - addScalar(s: number): Vector3; - - /** - * Sets this vector to a + b. - */ - addVectors(a: Vector3, b: Vector3): Vector3; - - /** - * Subtracts v from this vector. - */ - sub(a: Vector3): Vector3; - - /** - * Sets this vector to a - b. - */ - subVectors(a: Vector3, b: Vector3): Vector3; - - multiply(v: Vector3): Vector3; - - /** - * Multiplies this vector by scalar s. - */ - multiplyScalar(s: number): Vector3; - - multiplyVectors(a: Vector3, b: Vector3): Vector3; - applyMatrix3(m: Matrix3): Vector3; - applyMatrix4(m: Matrix4): Vector3; - applyProjection(m: Matrix4): Vector3; - applyQuaternion(q: Quaternion): Vector3; - - // applyEuler(v:Vector3, eulerOrder:EulerOrder):Vector3; - applyEuler(v: Vector3, eulerOrder: string): Vector3; - - applyAxisAngle(axis: Vector3, angle: number): Vector3; - projectPoint(m: Matrix4): Vector3; - divide(v: Vector3): Vector3; - - /** - * Divides this vector by scalar s. - * Set vector to ( 0, 0, 0 ) if s == 0. - */ - divideScalar(s: number): Vector3; - - min(v: Vector3): Vector3; - max(v: Vector3): Vector3; - - clamp(min: Vector3, max: Vector3): Vector3; - - /** - * Inverts this vector. - */ - negate(): Vector3; - - /** - * Computes dot product of this vector and v. - */ - dot(v: Vector3): number; - - /** - * Computes squared length of this vector. - */ - lengthSq(): number; - - /** - * Computes length of this vector. - */ - length(): number; - - /** - * Computes Manhattan length of this vector. - * http://en.wikipedia.org/wiki/Taxicab_geometry - */ - lengthManhattan(): number; - - /** - * Normalizes this vector. - */ - normalize(): Vector3; - - /** - * Normalizes this vector and multiplies it by l. - */ - setLength(l: number): Vector3; - - lerp(v: Vector3, alpha: number): Vector3; - - /** - * Sets this vector to cross product of itself and v. - */ - cross(a: Vector3): Vector3; - - /** - * Sets this vector to cross product of a and b. - */ - crossVectors(a: Vector3, b: Vector3): Vector3; - - angleTo(v: Vector3): number; - - /** - * Computes distance of this vector to v. - */ - distanceTo(v: Vector3): number; - - /** - * Computes squared distance of this vector to v. - */ - distanceToSquared(v: Vector3): number; - - /** - * Sets this vector extracting position from matrix transform. - */ - getPositionFromMatrix(m: Matrix4): Vector3; - - setEulerFromRotationMatrix(m: Matrix4, order: string): Vector3; - - setEulerFromQuaternion(q: Quaternion, order: string): Vector3; - - /** - * Sets this vector extracting scale from matrix transform. - */ - getScaleFromMatrix(m: Matrix4): Vector3; - - /** - * Checks for strict equality of this vector and v. - */ - equals(v: Vector3): boolean; - - /** - * Clones this vector. - */ - clone(): Vector3; - } - - /** - * 4D vector. - * - * ( class Vector4 implements Vector ) - */ - export class Vector4 implements Vector { - constructor(x?: number, y?: number, z?: number, w?: number); - x: number; - y: number; - z: number; - w: number; - - /** - * Sets value of this vector. - */ - set (x: number, y: number, z: number, w: number): Vector4; - - /** - * Copies value of v to this vector. - */ - copy(v: Vector4): Vector4; - - /** - * Adds v to this vector. - */ - add(v: Vector4): Vector4; - - /** - * Sets this vector to a + b. - */ - addVectors(a: Vector4, b: Vector4): Vector4; - - /** - * Subtracts v from this vector. - */ - sub(v: Vector4): Vector4; - - /** - * Sets this vector to a - b. - */ - subVectors(a: Vector4, b: Vector4): Vector4; - - /** - * Multiplies this vector by scalar s. - */ - multiplyScalar(s: number): Vector4; - - /** - * Divides this vector by scalar s. - * Set vector to ( 0, 0, 0 ) if s == 0. - */ - divideScalar(s: number): Vector4; - - /** - * Inverts this vector. - */ - negate(): Vector4; - - /** - * Computes dot product of this vector and v. - */ - dot(v: Vector4): number; - - /** - * Computes squared length of this vector. - */ - lengthSq(): number; - - /** - * Computes length of this vector. - */ - length(): number; - - lengthManhattan(): number; - - /** - * Normalizes this vector. - */ - normalize(): Vector4; - - /** - * NOTE: Vector4 doesn't have the property. - * Computes distance of this vector to v. - */ - distanceTo(v: Vector3): number; - - /** - * NOTE: Vector4 doesn't have the property. - * Computes squared distance of this vector to v. - */ - distanceToSquared(v: Vector3): number; - - - /** - * Normalizes this vector and multiplies it by l. - */ - setLength(l: number): Vector4; - - /** - * Linearly interpolate between this vector and v with alpha factor. - */ - lerp(v: Vector4, alpha: number): Vector4; - - /** - * Checks for strict equality of this vector and v. - */ - equals(v: Vector4): boolean; - - /** - * Clones this vector. - */ - clone(): Vector4; - - /** - * http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm - * @param q is assumed to be normalized - */ - setAxisAngleFromQuaternion(q: Quaternion): Vector4; - - /** - * http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm - * @param m assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) - */ - setAxisAngleFromRotationMatrix(m: Matrix3): Vector4; - } - - export class Box2 { - constructor(min?: Vector2, max?: Vector2); - set (min: Vector2, max: Vector2): Box2; - setFromPoints(points: Vector2[]): Box2; - setFromCenterAndSize(center: Vector2, size: number): Box2; - copy(box: Box2): Box2; - makeEmpty(): Box2; - empty(): boolean; - center(optionalTarget?: Vector2): Vector2; - size(optionalTarget?: Vector2): Vector2; - expandByPoint(point: Vector2): Box2; - expandByVector(vector: Vector2): Box2; - expandByScalar(scalar: number): Box2; - containsPoint(point: Vector2): boolean; - containsBox(box: Box2): boolean; - getParameter(point: Vector2): Vector2; - isIntersectionBox(box: Box2): boolean; - clampPoint(point: Vector2, optionalTarget?: Vector2): Vector2; - distanceToPoint(point: Vector2): Vector2; - intersect(box: Box2): Box2; - union(box: Box2): Box2; - translate(offset: Vector2): Box2; - equals(box: Box2): boolean; - clone(): Box2; - } - - export class Box3 { - constructor(min?: Vector3, max?: Vector3); - set (min: Vector3, max: Vector3): Box3; - setFromPoints(points: Vector3[]): Box3; - setFromCenterAndSize(center: Vector3, size: number): Box3; - copy(box: Box3): Box3; - makeEmpty(): Box3; - empty(): boolean; - center(optionalTarget?: Vector3): Vector3; - size(optionalTarget?: Vector3): Vector3; - expandByPoint(point: Vector3): Box3; - expandByVector(vector: Vector3): Box3; - expandByScalar(scalar: number): Box3; - containsPoint(point: Vector3): boolean; - containsBox(box: Box3): boolean; - getParameter(point: Vector3): Vector3; - isIntersectionBox(box: Box3): boolean; - clampPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - distanceToPoint(point: Vector3): Vector3; - intersect(box: Box3): Box3; - union(box: Box3): Box3; - transform(matrix: Matrix4): Box3; - translate(offset: Vector3): Box3; - equals(box: Box3): boolean; - clone(): Box3; - } - - // Cameras //////////////////////////////////////////////////////////////////////////////////////// - - /** - * Abstract base class for cameras. This class should always be inherited when you build a new camera. - */ - export class Camera extends Object3D { - - /** - * This constructor sets following properties to the correct type: matrixWorldInverse, projectionMatrix and projectionMatrixInverse. - */ - constructor(); - - /** - * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera. - */ - matrixWorldInverse: Matrix4; - - /** - * This is the matrix which contains the projection. - */ - projectionMatrix: Matrix4; - - /** - * This is the inverse of projectionMatrix. - */ - projectionMatrixInverse: Matrix4; - - /** - * This make the camera look at the vector position in local space. - * @param vector point to look at - */ - lookAt(vector: Vector3): void; - } - - /** - * Camera with orthographic projection - * - * @example - * var camera = new THREE.OrthographicCamera( width / - 2, width / 2, height / 2, height / - 2, 1, 1000 ); - * scene.add( camera ); - * - * @see src/cameras/OrthographicCamera.js - */ - export class OrthographicCamera extends Camera { - /** - * @param left Camera frustum left plane. - * @param right Camera frustum right plane. - * @param top Camera frustum top plane. - * @param bottom Camera frustum bottom plane. - * @param near Camera frustum near plane. - * @param far Camera frustum far plane. - */ - constructor(left: number, right: number, top: number, bottom: number, near?: number, far?: number); - - /** - * Camera frustum left plane. - */ - left: number; - - /** - * Camera frustum right plane. - */ - right: number; - - /** - * Camera frustum top plane. - */ - top: number; - - /** - * Camera frustum bottom plane. - */ - bottom: number; - - /** - * Camera frustum near plane. - */ - near: number; - - /** - * Camera frustum far plane. - */ - far: number; - - /** - * Updates the camera projection matrix. Must be called after change of parameters. - */ - updateProjectionMatrix(): void; - } - - /** - * Camera with perspective projection. - * - * @example - * var camera = new THREE.PerspectiveCamera( 45, width / height, 1, 1000 ); - * scene.add( camera ); - * - * @see src/cameras/PerspectiveCamera.js - */ - export class PerspectiveCamera extends Camera { - constructor(fov?: number, aspect?: number, near?: number, far?: number); - fov: number; - aspect: number; - near: number; - far: number; - setLens(focalLength: number, frameHeight?: number): void; - setViewOffset(fullWidth: number, fullHeight: number, x: number, y: number, width: number, height: number): void; - updateProjectionMatrix(): void; - } - - // Lights ////////////////////////////////////////////////////////////////////////////////// - - /** - * Abstract base class for lights. - */ - export class Light extends Object3D { - constructor(hex?: number); - color: Color; - } - - /** - * This light's color gets applied to all the objects in the scene globally. - * - * @example - * var light = new THREE.AmbientLight( 0x404040 ); // soft white light - * scene.add( light ); - * - * @see src/lights/AmbientLight.js - */ - export class AmbientLight extends Light { - constructor(hex?: number); - } - - export class RenderTarget { - } - - /** - * Affects objects using MeshLambertMaterial or MeshPhongMaterial. - * - * @example - * // White directional light at half intensity shining from the top. - * var directionalLight = new THREE.DirectionalLight( 0xffffff, 0.5 ); - * directionalLight.position.set( 0, 1, 0 ); - * scene.add( directionalLight ); - * - * @see src/lights/DirectionalLight.js - */ - export class DirectionalLight extends Light { - - constructor(hex?: number, intensity?: number); - - /** - * Direction of the light is normalized vector from position to (0,0,0). - * Default — new THREE.Vector3(). - */ - position: Vector3; - - /** - * Target used for shadow camera orientation. - */ - target: Object3D; - - /** - * Light's intensity. - * Default — 1.0. - */ - intensity: number; - - /** - * If set to true light will cast dynamic shadows. Warning: This is expensive and requires tweaking to get shadows looking right. - * Default — false. - */ - castShadow: boolean; - - /** - * If set to true light will only cast shadow but not contribute any lighting (as if intensity was 0 but cheaper to compute). - * Default — false. - */ - onlyShadow: boolean; - - /** - * Orthographic shadow camera frustum parameter. - * Default — 50. - */ - shadowCameraNear: number; - - /** - * Orthographic shadow camera frustum parameter. - * Default — 5000. - */ - shadowCameraFar: number; - - /** - * Orthographic shadow camera frustum parameter. - * Default — -500. - */ - shadowCameraLeft: number; - - /** - * Orthographic shadow camera frustum parameter. - * Default — 500. - */ - shadowCameraRight: number; - - /** - * Orthographic shadow camera frustum parameter. - * Default — 500. - */ - shadowCameraTop: number; - - /** - * Orthographic shadow camera frustum parameter. - * Default — -500. - */ - shadowCameraBottom: number; - - /** - * Show debug shadow camera frustum. - * Default — false. - */ - shadowCameraVisible: boolean; - - /** - * Shadow map bias. - * Default — 0. - */ - shadowBias: number; - - /** - * Darkness of shadow casted by this light (from 0 to 1). - * Default — 0.5. - */ - shadowDarkness: number; - - /** - * Shadow map texture width in pixels. - * Default — 512. - */ - shadowMapWidth: number; - - /** - * Shadow map texture height in pixels. - * Default — 512. - */ - shadowMapHeight: number; - - /** - * Default — false. - */ - shadowCascade: boolean; - - /** - * Three.Vector3( 0, 0, -1000 ). - */ - shadowCascadeOffset: Vector3; - - /** - * Default — 2. - */ - shadowCascadeCount: number; - - /** - * Default — [ 0, 0, 0 ]. - */ - shadowCascadeBias: number[]; - - /** - * Default — [ 512, 512, 512 ]. - */ - shadowCascadeWidth: number[]; - - /** - * Default — [ 512, 512, 512 ]. - */ - shadowCascadeHeight: number[]; - - /** - * Default — [ -1.000, 0.990, 0.998 ]. - */ - shadowCascadeNearZ: number[]; - - /** - * Default — [ 0.990, 0.998, 1.000 ]. - */ - shadowCascadeFarZ: number[]; - - /** - * Default — [ ]. - */ - shadowCascadeArray: DirectionalLight[]; - - /** - * Default — null. - */ - shadowMap: RenderTarget; - - /** - * Default — null. - */ - shadowMapSize: number; - - /** - * Default — null. - */ - shadowCamera: Camera; - - /** - * Default — null. - */ - shadowMatrix: Matrix4; - } - - export class HemisphereLight extends Light { - constructor(skyColorHex?: number, groundColorHex?: number, intensity?: number); - groundColor: Color; - position: Vector3; - intensity: number; - } - - /** - * Affects objects using {@link MeshLambertMaterial} or {@link MeshPhongMaterial}. - * - * @example - * var light = new THREE.PointLight( 0xff0000, 1, 100 ); - * light.position.set( 50, 50, 50 ); - * scene.add( light ); - */ - export class PointLight extends Light { - constructor(hex?: number, intensity?: number, distance?: number); - - /** - * Light's position. - * Default — new THREE.Vector3(). - */ - position: Vector3; - - /* - * Light's intensity. - * Default - 1.0. - */ - intensity: number; - - /** - * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance. - * Default — 0.0. - */ - distance: number; - } - - /** - * A point light that can cast shadow in one direction. - * - * @example - * // white spotlight shining from the side, casting shadow - * var spotLight = new THREE.SpotLight( 0xffffff ); - * spotLight.position.set( 100, 1000, 100 ); - * spotLight.castShadow = true; - * spotLight.shadowMapWidth = 1024; - * spotLight.shadowMapHeight = 1024; - * spotLight.shadowCameraNear = 500; - * spotLight.shadowCameraFar = 4000; - * spotLight.shadowCameraFov = 30; - * scene.add( spotLight ); - */ - export class SpotLight extends Light { - constructor(hex?: number, intensity?: number, distance?: number, angle?: number, exponent?: number); - - /** - * Light's position. - * Default — new THREE.Vector3(). - */ - position: Vector3; - - /** - * Spotlight focus points at target.position. - * Default position — (0,0,0). - */ - target: Object3D; - - /** - * Light's intensity. - * Default — 1.0. - */ - intensity: number; - - /** - * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance. - * Default — 0.0. - */ - distance: number; - - /* - * Maximum extent of the spotlight, in radians, from its direction. - * Default — Math.PI/2. - */ - angle: number; - - /** - * Rapidity of the falloff of light from its target direction. - * Default — 10.0. - */ - exponent: number; - - /** - * If set to true light will cast dynamic shadows. Warning: This is expensive and requires tweaking to get shadows looking right. - * Default — false. - */ - castShadow: boolean; - - /** - * If set to true light will only cast shadow but not contribute any lighting (as if intensity was 0 but cheaper to compute). - * Default — false. - */ - onlyShadow: boolean; - - /** - * Perspective shadow camera frustum near parameter. - * Default — 50. - */ - shadowCameraNear: number; - - /** - * Perspective shadow camera frustum far parameter. - * Default — 5000. - */ - shadowCameraFar: number; - - /** - * Perspective shadow camera frustum field of view parameter. - * Default — 50. - */ - shadowCameraFov: number; - - /** - * Show debug shadow camera frustum. - * Default — false. - */ - shadowCameraVisible: boolean; - - /** - * Shadow map bias. - * Default — 0. - */ - shadowBias: number; - - /** - * Darkness of shadow casted by this light (from 0 to 1). - * Default — 0.5. - */ - shadowDarkness: number; - - /** - * Shadow map texture width in pixels. - * Default — 512. - */ - shadowMapWidth: number; - - /** - * Shadow map texture height in pixels. - * Default — 512. - */ - shadowMapHeight: number; - - shadowMap: RenderTarget; - shadowMapSize: Vector2; - shadowCamera: Camera; - shadowMatrix: Matrix4; - } - - // Loaders ////////////////////////////////////////////////////////////////////////////////// - - export interface Progress { - total: number; - loaded: number; - } - - /** - * Base class for implementing loaders. - * - * Events: - * load - * Dispatched when the image has completed loading - * content — loaded image - * - * error - * - * Dispatched when the image can't be loaded - * message — error message - */ - export class Loader { - constructor(showStatus?: boolean); - - /** - * If true, show loading status in the statusDomElement. - */ - showStatus: boolean; - - /** - * This is the recipient of status messages. - */ - statusDomElement: HTMLElement; - - /** - * Will be called when load starts. - * The default is a function with empty body. - */ - onLoadStart: () => void; - - /** - * Will be called while load progresses. - * The default is a function with empty body. - */ - onLoadProgress: () => void; - - /** - * Will be called when load completes. - * The default is a function with empty body. - */ - onLoadComplete: () => void; - - /** - * default — null. - * If set, assigns the crossOrigin attribute of the image to the value of crossOrigin, prior to starting the load. - */ - crossOrigin: string; - addStatusElement(): HTMLElement; - updateProgress(progress: Progress): void; - extractUrlBase(url: string): string; - initMaterials(materials: Material[], texturePath: string): Material[]; - needsTangents(materials: Material[]): boolean; - createMaterial(m: Material, texturePath: string): boolean; - } - - /** - * A loader for loading an image. - * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object. - */ - export class ImageLoader extends EventDispatcher { - constructor(); - crossOrigin: string; - - /** - * Begin loading from url - * @param url - */ - load(url: string, image?: HTMLImageElement): void; - } - - - /** - * A loader for loading objects in JSON format. - */ - export class JSONLoader extends Loader { - constructor(showStatus?: boolean); - withCredentials: boolean; - - /** - * @param url - * @param callback. This function will be called with the loaded model as an instance of geometry when the load is completed. - * @param texturePath If not specified, textures will be assumed to be in the same folder as the Javascript model file. - */ - load(url: string, callback: (geometry: Geometry, materials: Material[]) => void , texturePath?: string): void; - - loadAjaxJSON(context: JSONLoader, url: string, callback: (geometry: Geometry, materials: Material[]) => void , texturePath?: string, callbackProgress?: (progress: Progress) => void ): void; - createModel(json: any, callback: (geometry: Geometry, materials: Material[]) => void , texturePath?: string): void; - } - - export class LoadingMonitor extends EventDispatcher { - constructor(); - add(loader: Loader): void; - } - - /** - * A loader for loading a complete scene out of a JSON file. - */ - export class SceneLoader { - constructor(); - - /** - * Will be called when load starts. - * The default is a function with empty body. - */ - onLoadStart: () => void; - - /** - * Will be called while load progresses. - * The default is a function with empty body. - */ - onLoadProgress: () => void; - - /** - * Will be called when each element in the scene completes loading. - * The default is a function with empty body. - */ - onLoadComplete: () => void; - - /** - * Will be called when load completes. - * The default is a function with empty body. - */ - callbackSync: () => void; - - /** - * Will be called as load progresses. - * The default is a function with empty body. - */ - callbackProgress: () => void; - - /** - * @param url - * @param callbackFinished This function will be called with the loaded model as an instance of scene when the load is completed. - */ - load(url: string, callbackFinished: (scene: Scene) => void ): void; - } - - /** - * Class for loading a texture. - * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object. - */ - export class TextureLoader extends EventDispatcher { - constructor(); - - /** - * Begin loading from url - * - * @param url - */ - load(url: string): void; - } - - // Materials ////////////////////////////////////////////////////////////////////////////////// - - /** - * Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer. - */ - export class Material { - constructor(); - - /** - * Unique number of this material instance. - */ - id: number; - - /** - * Material name. Default is an empty string. - */ - name: string; - - /** - * Opacity. Default is 1. - */ - opacity: number; - - /** - * Defines whether this material is transparent. This has an effect on rendering, as transparent objects need an special treatment, and are rendered after the opaque (i.e. non transparent) objects. For a working example of this behaviour, check the {@link WebGLRenderer} code. - * Default is false. - */ - transparent: boolean; - - /** - * Which blending to use when displaying objects with this material. Default is {@link NormalBlending}. - */ - blending: Blending; - - /** - * Blending source. It's one of the blending mode constants defined in Three.js. Default is {@link SrcAlphaFactor}. - */ - blendSrc: BlendingDstFactor; - - /** - * Blending destination. It's one of the blending mode constants defined in Three.js. Default is {@link OneMinusSrcAlphaFactor}. - */ - blendDst: BlendingSrcFactor; - - /** - * Blending equation to use when applying blending. It's one of the constants defined in Three.js. Default is AddEquation. - */ - blendEquation: BlendingEquation; - - /** - * Whether to have depth test enabled when rendering this material. Default is true. - */ - depthTest: boolean; - - /** - * Whether rendering this material has any effect on the depth buffer. Default is true. - * When drawing 2D overlays it can be useful to disable the depth writing in order to layer several things together without creating z-index artifacts. - */ - depthWrite: boolean; - - /** - * Whether to use polygon offset. Default is false. This corresponds to the POLYGON_OFFSET_FILL WebGL feature. - */ - polygonOffset: boolean; - - /** - * Sets the polygon offset factor. Default is 0. - */ - polygonOffsetFactor: number; - - /** - * Sets the polygon offset units. Default is 0. - */ - polygonOffsetUnits: number; - - /** - * Sets the alpha value to be used when running an alpha test. Default is 0. - */ - alphaTest: number; - - /** - * Enables/disables overdraw. If enabled, polygons are drawn slightly bigger in order to fix antialiasing gaps when using the CanvasRenderer. Default is false. - */ - overdraw: boolean; - - /** - * Defines whether this material is visible. Default is true. - */ - visible: boolean; - - /** - * Defines which of the face sides will be rendered - front, back or both. - * Default is THREE.FrontSide. Other options are THREE.BackSide and THREE.DoubleSide. - */ - side: Side; - - /** - * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL. - * This property is automatically set to true when instancing a new material. - */ - needsUpdate: boolean; - - clone(): Material; - - dispose(): void; - } - - var MaterialLibrary: Material[]; - var MaterialIdCount: number; - - export interface LineBasicMaterialParameters { - color?: number; - opacity?: number; - blending?: Blending; - depthTest?: boolean; - linewidth?: number; - linecap?: string; - linejoin?: string; - vertexColors?: boolean; - fog?: boolean; - } - - export class LineBasicMaterial extends Material { - constructor(parameters?: LineBasicMaterialParameters); - color: Color; - linewidth: number; - linecap: string; - linejoin: string; - vertexColors: boolean; - fog: boolean; - clone(): LineBasicMaterial; - } - - export interface LineDashedMaterialParameters { - color?: number; - opacity?: number; - blending?: Blending; - depthTest?: boolean; - linewidth?: number; - scale?: number; - dashSize?: number; - gapSize?: number; - vertexColors?: number; - fog?: boolean; - } - - export class LineDashedMaterial extends Material { - constructor(parameters?: LineDashedMaterialParameters); - color: Color; - linewidth: number; - scale: number; - dashSize: number; - gapSize: number; - vertexColors: boolean; - fog: boolean; - clone(): LineDashedMaterial; - } - - - /** - * parameters is an object with one or more properties defining the material's appearance. - */ - export interface MeshBasicMaterialParameters { - /** - * geometry color in hexadecimal. Default is 0xffffff. - */ - color?: number; - opacity?: number; - map?: Texture; - /** - * Default is null. - */ - lightMap?: Texture; - /** - * Default is null. - */ - specularMap?: Texture; - /** - * Default is null. - */ - envMap?: Texture; - combine?: Combine; - reflectivity?: number; - refractionRatio?: number; - /** - * Define shading type. Default is THREE.SmoothShading. - */ - shading?: Shading; - blending?: Blending; - depthTest?: boolean; - /** - * render geometry as wireframe. Default is false. - */ - wireframe?: boolean; - /** - * Line thickness. Default is 1. - */ - wireframeLinewidth?: number; - /** - * Define whether the material uses vertex colors, or not. Default is false. - */ - vertexColors?: Colors; - /** - * Default is false. - */ - skinning?: boolean; - /** - * Default is false. - */ - morphTargets?: boolean; - /** - * Define whether the material color is affected by global fog settings. Default is true. - */ - fog?: boolean; - } - - export class MeshBasicMaterial extends Material { - constructor(parameters?: MeshBasicMaterialParameters); - color: Color; - map: Texture; - lightMap: Texture; - specularMap: Texture; - envMap: Texture; - combine: Combine; - reflectivity: number; - refractionRatio: number; - fog: boolean; - shading: Shading; - wireframe: boolean; - wireframeLinewidth: number; - wireframeLinecap: string; - wireframeLinejoin: string; - vertexColors: Colors; - skinning: boolean; - morphTargets: boolean; - clone(): MeshBasicMaterial; - } - - export interface MeshDepthMaterialParameters { - opacity?: number; - blending?: Blending; - depthTest?: boolean; - wireframe?: boolean; - wireframeLinewidth?: number; - } - - export class MeshDepthMaterial extends Material { - constructor(parameters?: MeshDepthMaterialParameters); - wireframe: boolean; - wireframeLinewidth: number; - clone(): MeshDepthMaterial; - } - - export class MeshFaceMaterial extends Material { - constructor(materials?: Material[]); - materials: Material[]; - clone(): MeshFaceMaterial; - } - - export interface MeshLambertMaterialParameters { - color?: number; - ambient?: number; - emissive?: number; - opacity?: number; - map?: Texture; - lightMap?: Texture; - specularMap?: Texture; - envMap?: Texture; - combine?: Combine; - reflectivity?: number; - refractionRatio?: number; - shading?: Shading; - blending?: Blending; - depthTest?: boolean; - wireframe?: boolean; - wireframeLinewidth?: number; - vertexColors?: Colors; - skinning?: boolean; - morphTargets?: boolean; - morphNormals?: boolean; - fog?: boolean; - } - - export class MeshLambertMaterial extends Material { - constructor(parameters?: MeshLambertMaterialParameters); - color: Color; - ambient: Color; - emissive: Color; - wrapAround: boolean; - wrapRGB: Vector3; - map: Texture; - lightMap: Texture; - specularMap: Texture; - envMap: Texture; - combine: Combine; - reflectivity: number; - refractionRatio: number; - fog: boolean; - shading: Shading; - wireframe: boolean; - wireframeLinewidth: number; - wireframeLinecap: string; - wireframeLinejoin: string; - vertexColors: Colors; - skinning: boolean; - morphTargets: boolean; - morphNormals: boolean; - clone(): MeshLambertMaterial; - } - - export interface MeshNormalMaterialParameters { - opacity?: number; - shading?: Shading; - blending?: Blending; - depthTest?: boolean; - wireframe?: boolean; - wireframeLinewidth?: number; - } - - export class MeshNormalMaterial extends Material { - constructor(parameters?: MeshNormalMaterialParameters); - shading: Shading; - wireframe: boolean; - wireframeLinewidth: number; - clone(): MeshNormalMaterial; - } - - export interface MeshPhongMaterialParameters { - color?: number; - ambient?: number; - emissive?: number; - specular?: number; - shininess?: number; - opacity?: number; - map?: Texture; - lightMap?: Texture; - bumpMap?: Texture; - bumpScale?: number; - normalMap?: Texture; - normalScale?: Vector2; - specularMap?: Texture; - envMap?: Texture; - combine?: Combine; - reflectivity?: number; - refractionRatio?: number; - shading?: Shading; - blending?: Blending; - depthTest?: boolean; - wireframe?: boolean; - wireframeLinewidth?: number; - vertexColors?: Colors; - skinning?: boolean; - morphTargets?: boolean; - morphNormals?: boolean; - fog?: boolean; - } - - export class MeshPhongMaterial extends Material { - constructor(parameters?: MeshPhongMaterialParameters); - color: Color; // diffuse - ambient: Color; - emissive: Color; - specular: Color; - shininess: number; - metal: boolean; - perPixel: boolean; - wrapAround: boolean; - wrapRGB: Vector3; - map: Texture; - lightMap: Texture; - bumpMap: Texture; - bumpScale: number; - normalMap: Texture; - normalScale: Vector2; - specularMap: Texture; - envMap: Texture; - combine: Combine; - reflectivity: number; - refractionRatio: number; - fog: boolean; - shading: Shading; - wireframe: boolean; - wireframeLinewidth: number; - wireframeLinecap: string; - wireframeLinejoin: string; - vertexColors: Colors; - skinning: boolean; - morphTargets: boolean; - morphNormals: boolean; - clone(): MeshPhongMaterial; - } - - export interface ParticleBasicMaterialParameters { - color?: number; - opacity?: number; - map?: Texture; - size?: number; - blending?: Blending; - depthTest?: boolean; - vertexColors?: boolean; - fog?: boolean; - } - - export class ParticleBasicMaterial extends Material { - constructor(parameters?: ParticleBasicMaterialParameters); - color: Color; - map: Texture; - size: number; - sizeAttenuation: boolean; - vertexColors: boolean; - fog: boolean; - clone(): ParticleBasicMaterial; - } - - export interface ParticleCanvasMaterialParameters { - color?: number; - program?: (context: CanvasRenderingContext2D, color: Color) => void; - opacity?: number; - blending?: Blending; - } - - export class ParticleCanvasMaterial extends Material { - constructor(parameters?: ParticleCanvasMaterialParameters); - color: Color; - program: (context: CanvasRenderingContext2D, color: Color) => void; - clone(): ParticleCanvasMaterial; - } - - export class ParticleDOMMaterial extends Material { - constructor(element: HTMLElement); - clone(): ParticleDOMMaterial; - } - - - - - export interface Uniforms { - [name: string]: { type: string; value: Object; }; - //[name:string]:{type:UniformType;value:Object;}; - } - - export interface ShaderMaterialParameters { - fragmentShader?: string; - vertexShader?: string; - uniforms?: Uniforms; - defines?: { [label: string]: string; }; - shading?: Shading; - blending?: Blending; - depthTest?: boolean; - wireframe?: boolean; - wireframeLinewidth?: number; - lights?: boolean; - vertexColors?: Colors; - skinning?: boolean; - morphTargets?: boolean; - morphNormals?: boolean; - fog?: boolean; - } - - export class ShaderMaterial extends Material { - constructor(parameters?: ShaderMaterialParameters); - fragmentShader: string; - vertexShader: string; - uniforms: Uniforms; - defines: { [label: string]: string; }; - attributes: { [name: string]: Object; }; - shading: Shading; - wireframe: boolean; - wireframeLinewidth: number; - fog: boolean; - lights: boolean; - vertexColors: Colors; - skinning: boolean; - morphTargets: boolean; - morphNormals: boolean; - clone(): ShaderMaterial; - } - - // Objects ////////////////////////////////////////////////////////////////////////////////// - - export class Bone extends Object3D { - constructor(belongsToSkin: SkinnedMesh); - skin: SkinnedMesh; - skinMatrix: Matrix4; - update(parentSkinMatrix?: Matrix4, forceUpdate?: boolean): void; - } - - export class Line extends Object3D { - constructor(geometry?: Geometry, material?: LineDashedMaterial, type?: number); - constructor(geometry?: Geometry, material?: LineBasicMaterial, type?: number); - constructor(geometry?: Geometry, material?: ShaderMaterial, type?: number); - geometry: Geometry; - material: Material; - type: number; - clone(object?: Line): Line; - } - - export class LOD extends Object3D { - constructor(); - LODs: Object3D[]; - addLevel(object3D: Object3D, visibleAtDistance?: number): void; - update(camera: Camera): void; - clone(): LOD; - } - - export class Mesh extends Object3D { - constructor(geometry?: Geometry, material?: MeshBasicMaterial); - constructor(geometry?: Geometry, material?: MeshDepthMaterial); - constructor(geometry?: Geometry, material?: MeshFaceMaterial); - constructor(geometry?: Geometry, material?: MeshLambertMaterial); - constructor(geometry?: Geometry, material?: MeshNormalMaterial); - constructor(geometry?: Geometry, material?: MeshPhongMaterial); - constructor(geometry?: Geometry, material?: ShaderMaterial); - geometry: Geometry; - material: Material; - morphTargetBase: number; - morphTargetForcedOrder: number; - morphTargetInfluences: number[]; - morphTargetDictionary: { [key: string]: number; }; - updateMorphTargets(): void; - getMorphTargetIndexByName(name: string): number; - clone(object?: Mesh): Mesh; - } - - export class MorphAnimMesh extends Mesh { - constructor(geometry?: Geometry, material?: MeshBasicMaterial); - constructor(geometry?: Geometry, material?: MeshDepthMaterial); - constructor(geometry?: Geometry, material?: MeshFaceMaterial); - constructor(geometry?: Geometry, material?: MeshLambertMaterial); - constructor(geometry?: Geometry, material?: MeshNormalMaterial); - constructor(geometry?: Geometry, material?: MeshPhongMaterial); - constructor(geometry?: Geometry, material?: ShaderMaterial); - duration: number; // milliseconds - mirroredLoop: boolean; - time: number; - lastKeyframe: number; - currentKeyframe: number; - direction: number; - directionBackwards: boolean; - setFrameRange(start: number, end: number): void; - setDirectionForward(): void; - setDirectionBackward(): void; - parseAnimations(): void; - setAnimationLabel(label: string, start: number, end: number): void; - playAnimation(label: string, fps: number): void; - updateAnimation(delta: number): void; - clone(object?: MorphAnimMesh): MorphAnimMesh; - } - - export class Particle extends Object3D { - constructor(material: Material); - clone(object?: Particle): Particle; - } - - /** - * A class for displaying particles in the form of variable size points. For example, if using the WebGLRenderer, the particles are displayed using GL_POINTS. - * - * @see src/objects/ParticleSystem.js - */ - export class ParticleSystem extends Object3D { - - /** - * @param geometry An instance of Geometry. - * @param material An instance of Material (optional). - */ - constructor(geometry: Geometry, material?: ParticleBasicMaterial); - constructor(geometry: Geometry, material?: ParticleCanvasMaterial); - constructor(geometry: Geometry, material?: ParticleDOMMaterial); - constructor(geometry: Geometry, material?: ShaderMaterial); - - /** - * An instance of Geometry, where each vertex designates the position of a particle in the system. - */ - geometry: Geometry; - - /** - * An instance of Material, defining the object's appearance. Default is a ParticleBasicMaterial with randomised colour. - */ - material: Material; - - /** - * Specifies whether the particle system will be culled if it's outside the camera's frustum. By default this is set to false. - */ - sortParticles: boolean; - - clone(object?: ParticleSystem): ParticleSystem; - } - - export class Ribbon extends Object3D { - constructor(geometry: Geometry, material: Material); - geometry: Geometry; - material: Material; - clone(object?: Ribbon): Ribbon; - } - - export class SkinnedMesh extends Mesh { - constructor(geometry?: Geometry, material?: MeshBasicMaterial); - constructor(geometry?: Geometry, material?: MeshDepthMaterial); - constructor(geometry?: Geometry, material?: MeshFaceMaterial); - constructor(geometry?: Geometry, material?: MeshLambertMaterial); - constructor(geometry?: Geometry, material?: MeshNormalMaterial); - constructor(geometry?: Geometry, material?: MeshPhongMaterial); - constructor(geometry?: Geometry, material?: ShaderMaterial); - useVertexTexture: boolean; - identityMatrix: Matrix4; - bones: Bone[]; - boneMatrices: Float32Array; - boneTextureWidth: number; - boneTextureHeight: number; - boneTexture: DataTexture; - addBone(bone?: Bone): Bone; - updateMatrixWorld(force?: boolean): void; - pose(): void; - clone(object?: SkinnedMesh): SkinnedMesh; - static offsetMatrix: Matrix4; - } - - export interface SpriteParameters { - color?: Color; - map?: Texture; - blending?: Blending; - blendSrc?: BlendingSrcFactor; - blendDst?: BlendingDstFactor; - blendEquation?: BlendingEquation; - useScreenCoordinates?: boolean; - mergeWith3D?: boolean; - affectedByDistance?: boolean; - alignment?: Vector2; - fog?: boolean; - uvOffset?: Vector2; - uvScale?: Vector2; - depthTest?: boolean; - sizeAttenuation?: boolean; - scaleByViewport?: boolean; - } - - export class SpriteMaterial extends Material { - constructor(parameters?: SpriteParameters); - color: Color; - map: Texture; - blending: Blending; - blendEquation: BlendingEquation; - useScreenCoordinates: boolean; - scaleByViewport: boolean; - alignment: Vector2; - fog: boolean; - uvOffset: Vector2; - uvScale: Vector2; - depthTest: boolean; - sizeAttenuation: boolean; - clone(): SpriteMaterial; - } - - export class Sprite extends Object3D { - constructor(material?: SpriteMaterial); - updateMatrix(): void; - clone(object?: Sprite): Sprite; - } - export class SpriteAlignment { - static topLeft: Vector2; - static topCenter: Vector2; - static topRight: Vector2; - static centerLeft: Vector2; - static center: Vector2; - static centerRight: Vector2; - static bottomLeft: Vector2; - static bottomCenter: Vector2; - static bottomRight: Vector2; - } - - // Renderers ////////////////////////////////////////////////////////////////////////////////// - - export interface Renderer { - render(scene: Scene, camera: Camera): void; - } - - export interface CanvasRendererParameters { - canvas?: HTMLCanvasElement; - devicePixelRatio?: number; - } - - export class CanvasRenderer implements Renderer { - constructor(parameters?: CanvasRendererParameters); - domElement: HTMLCanvasElement; - autoClear: boolean; - sortObjects: boolean; - sortElements: boolean; - devicePixelRatio: number; - info: { render: { vertices: number; faces: number; }; }; - setSize(width: number, height: number): void; - setClearColor(color: Color, opacity?: number): void; - setClearColorHex(hex: number, opacity?: number): void; - getMaxAnisotropy(): number; - clear(): void; - render(scene: Scene, camera: Camera): void; - } - - export interface ShaderChunk { - [name: string]: string; - fog_pars_fragment: string; - fog_fragment: string; - envmap_pars_fragment: string; - envmap_fragment: string; - envmap_pars_vertex: string; - worldpos_vertex: string; - envmap_vertex: string; - map_particle_pars_fragment: string; - map_particle_fragment: string; - map_pars_vertex: string; - map_pars_fragment: string; - map_vertex: string; - map_fragment: string; - lightmap_pars_fragment: string; - lightmap_pars_vertex: string; - lightmap_fragment: string; - lightmap_vertex: string; - bumpmap_pars_fragment: string; - normalmap_pars_fragment: string; - specularmap_pars_fragment: string; - specularmap_fragment: string; - lights_lambert_pars_vertex: string; - lights_lambert_vertex: string; - lights_phong_pars_vertex: string; - lights_phong_vertex: string; - lights_phong_pars_fragment: string; - lights_phong_fragment: string; - color_pars_fragment: string; - color_fragment: string; - color_pars_vertex: string; - color_vertex: string; - skinning_pars_vertex: string; - skinbase_vertex: string; - skinning_vertex: string; - morphtarget_pars_vertex: string; - morphtarget_vertex: string; - default_vertex: string; - morphnormal_vertex: string; - skinnormal_vertex: string; - defaultnormal_vertex: string; - shadowmap_pars_fragment: string; - shadowmap_fragment: string; - shadowmap_pars_vertex: string; - shadowmap_vertex: string; - alphatest_fragment: string; - linear_to_gamma_fragment: string; - } - - export var ShaderChunk: ShaderChunk; - - export interface RendererPlugin { - init(renderer: WebGLRenderer): void; - render(scene: Scene, camera: Camera, currentWidth: number, currentHeight: number): void; - } - - export interface WebGLRendererParameters { - /** - * A Canvas where the renderer draws its output. - */ - canvas?: HTMLCanvasElement; - - /** - * shader precision. Can be "highp", "mediump" or "lowp". - */ - precision?: string; - - /** - * default is true. - */ - alpha?: boolean; - - /** - * default is true. - */ - premultipliedAlpha?: boolean; - - /** - * default is false. - */ - antialias?: boolean; - - /** - * default is true. - */ - stencil?: boolean; - - /** - * default is false. - */ - preserveDrawingBuffer?: boolean; - - /** - * default is 0x000000. - */ - clearColor?: number; - - /** - * default is 0. - */ - clearAlpha?: number; - - devicePixelRatio?: number; - } - - - /** - * The WebGL renderer displays your beautifully crafted scenes using WebGL, if your device supports it. - * This renderer has way better performance than CanvasRenderer. - * - * @see src/renderers/WebGLRenderer.js - */ - export class WebGLRenderer implements Renderer { - /** - * parameters is an optional object with properties defining the renderer's behaviour. The constructor also accepts no parameters at all. In all cases, it will assume sane defaults when parameters are missing. - */ - constructor(parameters?: WebGLRendererParameters); - - /** - * A Canvas where the renderer draws its output. - * This is automatically created by the renderer in the constructor (if not provided already); you just need to add it to your page. - */ - domElement: HTMLCanvasElement; - - /** - * The HTML5 Canvas's 'webgl' context obtained from the canvas where the renderer will draw. - */ - // If you are using three.d.ts with other complete definitions of webgl, context:WebGLRenderingContext is suitable. - //context:WebGLRenderingContext; - context: any; - - /** - * Defines whether the renderer should automatically clear its output before rendering. - */ - autoClear: boolean; - - /** - * If autoClear is true, defines whether the renderer should clear the color buffer. Default is true. - */ - autoClearColor: boolean; - - /** - * If autoClear is true, defines whether the renderer should clear the depth buffer. Default is true. - */ - autoClearDepth: boolean; - - /** - * If autoClear is true, defines whether the renderer should clear the stencil buffer. Default is true. - */ - autoClearStencil: boolean; - - /** - * Defines whether the renderer should sort objects. Default is true. - */ - sortObjects: boolean; - - /** - * Defines whether the renderer should auto update objects. Default is true. - */ - autoUpdateObjects: boolean; - - /** - * Defines whether the renderer should auto update the scene. Default is true. - */ - autoUpdateScene: boolean; - - /** - * Default is false. - */ - gammaInput: boolean; - - /** - * Default is false. - */ - gammaOutput: boolean; - - /** - * Default is false. - */ - physicallyBasedShading: boolean; - - /** - * Default is false. - */ - shadowMapEnabled: boolean; - - /** - * Default is true. - */ - shadowMapAutoUpdate: boolean; - - /** - * Defines shadow map type (unfiltered, percentage close filtering, percentage close filtering with bilinear filtering in shader) - * Options are THREE.BasicShadowMap, THREE.PCFShadowMap, THREE.PCFSoftShadowMap. Default is THREE.PCFShadowMap. - */ - shadowMapType: ShadowMapType; - - shadowMapSoft: boolean; - - /** - * Default is true - */ - shadowMapCullFace: CullFace; - - /** - * Default is false. - */ - shadowMapDebug: boolean; - - /** - * Default is false. - */ - shadowMapCascade: boolean; - - /** - * Default is 8. - */ - maxMorphTargets: number; - - /** - * Default is 4. - */ - maxMorphNormals: number; - - /** - * Default is true. - */ - autoScaleCubemaps: boolean; - - /** - * An array with render plugins to be applied before rendering. - * Default is an empty array, or []. - */ - renderPluginsPre: RendererPlugin[]; - - /** - * An array with render plugins to be applied after rendering. - * Default is an empty array, or []. - */ - renderPluginsPost: RendererPlugin[]; - - devicePixelRatio: number; - - /** - * An object with a series of statistical information about the graphics board memory and the rendering process. Useful for debugging or just for the sake of curiosity. The object contains the following fields: - */ - info: { - memory: { - programs: number; - geometries: number; - textures: number; - }; - render: { - calls: number; - vertices: number; - faces: number; - points: number; - }; - }; - - /** - * Return the WebGL context. - */ - getContext(): WebGLRenderingContext; - - /** - * Return a Boolean true if the context supports vertex textures. - */ - supportsVertexTextures(): boolean; - - getMaxAnisotropy(): number; - - /** - * Resizes the output canvas to (width, height), and also sets the viewport to fit that size, starting in (0, 0). - */ - setSize(width: number, height: number): void; - - /** - * Sets the viewport to render from (x, y) to (x + width, y + height). - */ - setViewport(x?: number, y?: number, width?: number, height?: number): void; - - /** - * Sets the scissor area from (x, y) to (x + width, y + height). - */ - setScissor(x: number, y: number, width: number, height: number): void; - - /** - * Enable the scissor test. When this is enabled, only the pixels within the defined scissor area will be affected by further renderer actions. - */ - enableScissorTest(enable: boolean): void; - - /** - * Sets the clear color, using hex for the color and alpha for the opacity. - * - * @example - * // Creates a renderer with black background - * var renderer = new THREE.WebGLRenderer(); - * renderer.setSize(200, 100); - * renderer.setClearColorHex(0x000000, 1); - */ - setClearColorHex(hex: number, alpha: number): void; - - /** - * Sets the clear color, using color for the color and alpha for the opacity. - */ - setClearColor(color: Color, alpha: number): void; - - /** - * Returns a THREE.Color instance with the current clear color. - */ - getClearColor(): Color; - - /** - * Returns a float with the current clear alpha. Ranges from 0 to 1. - */ - getClearAlpha(): number; - - /** - * Tells the renderer to clear its color, depth or stencil drawing buffer(s). - * If no parameters are passed, no buffer will be cleared. - */ - clear(color?: boolean, depth?: boolean, stencil?: boolean): void; - - /** - * Initialises the postprocessing plugin, and adds it to the renderPluginsPost array. - */ - addPostPlugin(plugin: RendererPlugin): void; - - /** - * Initialises the preprocessing plugin, and adds it to the renderPluginsPre array. - */ - addPrePlugin(plugin: RendererPlugin): void; - - deallocateObject(object: Object3D): void; - - deallocateTexture(texture: Texture): void; - - deallocateRenderTarget(renderTarget: RenderTarget): void; - - /** - * Tells the shadow map plugin to update using the passed scene and camera parameters. - * - * @param scene an instance of Scene - * @param camera — an instance of Camera - */ - updateShadowMap(scene: Scene, camera: Camera): void; - - renderBufferImmediate(object: Object3D, program: Object, material: Material): void; - - renderBufferDirect(camera: Camera, lights: Light[], fog: Fog, material: Material, geometryGroup: any, object: Object3D): void; - - renderBuffer(camera: Camera, lights: Light[], fog: Fog, material: Material, geometryGroup: any, object: Object3D): void; - - /** - * Render a scene using a camera. - * The render is done to the renderTarget (if specified) or to the canvas as usual. - * If forceClear is true, the canvas will be cleared before rendering, even if the renderer's autoClear property is false. - */ - render(scene: Scene, camera: Camera, renderTarget?: RenderTarget, forceClear?: boolean): void; - renderImmediateObject(camera: Camera, lights: Light[], fog: Fog, material: Material, object: Object3D): void; - initWebGLObjects(scene: Scene): void; - initMaterial(material: Material, lights: Light[], fog: Fog, object: Object3D): void; - - /** - * Used for setting the gl frontFace, cullFace states in the GPU, thus enabling/disabling face culling when rendering. - * If cullFace is false, culling will be disabled. - * @param cullFace "back", "front", "front_and_back", or false. - * @param frontFace "ccw" or "cw - */ - setFaceCulling(cullFace?: string, frontFace?: FrontFaceDirection): void; - setMaterialFaces(material: Material): void; - setDepthTest(depthTest: boolean): void; - setDepthWrite(depthWrite: boolean): void; - setBlending(blending: Blending, blendEquation: BlendingEquation, blendSrc: BlendingSrcFactor, blendDst: BlendingDstFactor): void; - setTexture(texture: Texture, slot: number): void; - setRenderTarget(renderTarget: RenderTarget): void; - } - - export class WebGLRenderer2 implements Renderer { - constructor(parameters?: WebGLRendererParameters); - domElement: HTMLCanvasElement; - context: WebGLRenderingContext; - autoClear: boolean; - autoClearColor: boolean; - autoClearDepth: boolean; - autoClearStencil: boolean; - sortObjects: boolean; - autoUpdateObjects: boolean; - autoUpdateScene: boolean; - gammaInput: boolean; - gammaOutput: boolean; - physicallyBasedShading: boolean; - shadowMapEnabled: boolean; - shadowMapAutoUpdate: boolean; - shadowMapType: ShadowMapType; - shadowMapSoft: boolean; - shadowMapCullFace: CullFace; - shadowMapDebug: boolean; - shadowMapCascade: boolean; - maxMorphTargets: number; - maxMorphNormals: number; - autoScaleCubemaps: boolean; - renderPluginsPre: RendererPlugin[]; - renderPluginsPost: RendererPlugin[]; - devicePixelRatio: number; - info: { - memory: { - programs: number; - geometries: number; - textures: number; - }; - render: { - calls: number; - vertices: number; - faces: number; - points: number; - }; - }; - getContext(): WebGLRenderingContext; - supportsVertexTextures(): boolean; - getMaxAnisotropy(): number; - setSize(width: number, height: number): void; - setViewport(x?: number, y?: number, width?: number, height?: number): void; - setScissor(x: number, y: number, width: number, height: number): void; - enableScissorTest(enable: boolean): void; - setClearColorHex(hex: number, alpha: number): void; - setClearColor(color: Color, alpha: number): void; - getClearColor(): Color; - getClearAlpha(): number; - clear(color?: boolean, depth?: boolean, stencil?: boolean): void; - addPostPlugin(plugin: RendererPlugin): void; - addPrePlugin(plugin: RendererPlugin): void; - deallocateObject(object: Object3D): void; - deallocateTexture(texture: Texture): void; - deallocateRenderTarget(renderTarget: RenderTarget): void; - updateShadowMap(scene: Scene, camera: Camera): void; - renderBufferImmediate(object: Object3D, program: Object, material: Material): void; - renderBufferDirect(camera: Camera, lights: Light[], fog: Fog, material: Material, geometryGroup: any, object: Object3D): void; - renderBuffer(camera: Camera, lights: Light[], fog: Fog, material: Material, geometryGroup: any, object: Object3D): void; - render(scene: Scene, camera: Camera, renderTarget?: RenderTarget, forceClear?: boolean): void; - renderImmediateObject(camera: Camera, lights: Light[], fog: Fog, material: Material, object: Object3D): void; - initWebGLObjects(scene: Scene): void; - initMaterial(material: Material, lights: Light[], fog: Fog, object: Object3D): void; - setFaceCulling(cullFace?: string, frontFace?: FrontFaceDirection): void; - setMaterialFaces(material: Material): void; - setDepthTest(depthTest: boolean): void; - setDepthWrite(depthWrite: boolean): void; - setBlending(blending: Blending, blendEquation: BlendingEquation, blendSrc: BlendingSrcFactor, blendDst: BlendingDstFactor): void; - setTexture(texture: Texture, slot: number): void; - setRenderTarget(renderTarget: RenderTarget): void; - } - - export interface WebGLRenderTargetOptions { - wrapS?: Wrapping; - wrapT?: Wrapping; - magFilter?: TextureFilter; - minFilter?: TextureFilter; - anisotropy?: number; // 1; - format?: number; // RGBAFormat; - type?: TextureDataType; // UnsignedByteType; - depthBuffer?: boolean; // true; - stencilBuffer?: boolean; // true; - } - - export class WebGLRenderTarget extends RenderTarget { - constructor(width: number, height: number, options?: WebGLRenderTargetOptions); - width: number; - height: number; - wrapS: Wrapping; - wrapT: Wrapping; - magFilter: TextureFilter; - minFilter: TextureFilter; - anisotropy: number; - offset: Vector2; - repeat: Vector2; - format: number; - type: number; - depthBuffer: boolean; - stencilBuffer: boolean; - generateMipmaps: boolean; - clone(): WebGLRenderTarget; - dispose(): void; - } - - export class WebGLRenderTargetCube extends WebGLRenderTarget { - constructor(width: number, height: number, options?: WebGLRenderTargetOptions); - activeCubeFace: number; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5 - } - - // Renderers / Renderables ///////////////////////////////////////////////////////////////////// - - export class RenderableFace3 { - constructor(); - v1: RenderableVertex; - v2: RenderableVertex; - v3: RenderableVertex; - centroidWorld: Vector3; - centroidScreen: Vector3; - normalWorld: Vector3; - vertexNormalsWorld: Vector3[]; - vertexNormalsLength: number; - color: number; - material: Material; - uvs: Vector2[][]; - z: number; - } - - export class RenderableFace4 { - constructor(); - v1: RenderableVertex; - v2: RenderableVertex; - v3: RenderableVertex; - v4: RenderableVertex; - centroidWorld: Vector3; - centroidScreen: Vector3; - normalWorld: Vector3; - vertexNormalsWorld: Vector3[]; - vertexNormalsLength: number; - color: number; - material: Material; - uvs: Vector2[][]; - z: number; - } - - export class RenderableLine { - constructor(); - z: number; - v1: RenderableVertex; - v2: RenderableVertex; - material: Material; - } - - export class RenderableObject { - constructor(); - object: Object; - z: number; - } - - export class RenderableParticle { - constructor(); - object: Object; - x: number; - y: number; - z: number; - rotation: number; - scale: Vector2; - material: Material; - } - - export class RenderableVertex { - constructor(); - positionWorld: Vector3; - positionScreen: Vector4; - visible: boolean; - copy(vertex: RenderableVertex): void; - } - - // Scenes ///////////////////////////////////////////////////////////////////// - - export interface IFog { - name:string; - color: Color; - clone():IFog; - } - - - /** - * This class contains the parameters that define linear fog, i.e., that grows linearly denser with the distance. - */ - export class Fog implements IFog { - constructor(hex: number, near?: number, far?: number); - name:string; - color: Color; - - /** - * The minimum distance to start applying fog. Objects that are less than 'near' units from the active camera won't be affected by fog. - */ - near: number; - - /** - * The maximum distance at which fog stops being calculated and applied. Objects that are more than 'far' units away from the active camera won't be affected by fog. - * Default is 1000. - */ - far: number; - - clone(): Fog; - } - - /** - * This class contains the parameters that define linear fog, i.e., that grows exponentially denser with the distance. - */ - export class FogExp2 implements IFog { - constructor(hex: number, density?: number); - name: string; - color: Color; - - /** - * Defines how fast the fog will grow dense. - * Default is 0.00025. - */ - density: number; - - clone(): FogExp2; - } - - /** - * Scenes allow you to set up what and where is to be rendered by three.js. This is where you place objects, lights and cameras. - */ - export class Scene extends Object3D { - - /** - * A fog instance defining the type of fog that affects everything rendered in the scene. Default is null. - */ - fog: IFog; - - /** - * If not null, it will force everything in the scene to be rendered with that material. Default is null. - */ - overrideMaterial: Material; - - /** - * Default is false. - */ - matrixAutoUpdate: boolean; - - constructor(); - } - - // Textures ///////////////////////////////////////////////////////////////////// - - export class Texture { - constructor( - image: HTMLImageElement, - mapping?: Mapping, - wrapS?: Wrapping, - wrapT?: Wrapping, - magFilter?: TextureFilter, - minFilter?: TextureFilter, - format?: PixelFormat, - type?: TextureDataType, - anisotropy?: number - ); - id: number; - name: string; - image: Object; // HTMLImageElement or ImageData ; - mapping: Mapping; - wrapS: Wrapping; - wrapT: Wrapping; - magFilter: TextureFilter; - minFilter: TextureFilter; - anisotropy: number; - format: PixelFormat; - type: TextureDataType; - offset: Vector2; - repeat: Vector2; - generateMipmaps: boolean; - premultiplyAlpha: boolean; - flipY: boolean; - needsUpdate: boolean; - onUpdate: () => void; - clone(): Texture; - dispose(): void; - } - var TextureIdCount: number; - var TextureLibrary: Texture[]; - - - export class CompressedTexture extends Texture { - constructor(mipmaps: ImageData[], width: number, height: number, format?: PixelFormat, type?: TextureDataType, mapping?: Mapping, wrapS?: Wrapping, wrapT?: Wrapping, magFilter?: TextureFilter, minFilter?: TextureFilter); - mipmaps: ImageData[]; - clone(): CompressedTexture; - } - - export class DataTexture extends Texture { - constructor(data: ImageData, width: number, height: number, format: PixelFormat, type: TextureDataType, mapping: Mapping, wrapS: Wrapping, wrapT: Wrapping, magFilter: TextureFilter, minFilter: TextureFilter); - clone(): DataTexture; - } - - // Extras ///////////////////////////////////////////////////////////////////// - export var ColorUtils: { - /** - * Taking a color as input, converts it to HSV, and applies the h, s, v parameters in place, i.e. no new color is returned but the original object is modified. - * - * @param color source color to be adjusted - * @param h hue change amount - * @param s saturation change amount - * @param v value change amount - */ - adjustHSV(color: Color, h: number, s: number, v: number): void; - }; - - export interface TypefaceData { - familyName: string; - cssFontWeight: string; - cssFontStyle: string; - } - - export var FontUtils: { - faces: { [weight: string]: { [style: string]: Face; }; }; - face: string; - weight: string; - style: string; - size: number; - divisions: number; - getFace(): Face; - loadFace(data: TypefaceData): TypefaceData; - drawText(text: string): { paths: Path[]; offset: number; }; - extractGlyphPoints(c: string, face: Face, scale: number, offset: number, path: Path): { offset: number; path: Path; }; - generateShapes(text: string, parameters?: { size?: number; curveSegments?: number; font?: string; weight?: string; style?: string; }): Shape[]; - Triangulate: { - (contour: Vector2[], indices: boolean): Vector2[]; - area(contour: Vector2[]): number; - }; - }; - - export var GeometryUtils: { - merge(geometry1: Geometry, object2: Mesh): void; - merge(geometry1: Geometry, object2: Geometry): void; - removeMaterials(geometry: Geometry, materialIndexArray: number[]): void; - randomPointInTriangle(vectorA: Vector3, vectorB: Vector3, vectorC: Vector3): Vector3; - randomPointInFace(face: Face, geometry: Geometry, useCachedAreas: boolean): Vector3; - randomPointsInGeometry(geometry: Geometry, n: number): Vector3; - triangleArea(vectorA: Vector3, vectorB: Vector3, vectorC: Vector3): number; - center(geometry: Geometry): Vector3; - normalizeUVs(geometry: Geometry): void; - triangulateQuads(geometry: Geometry): void; - setMaterialIndex(geometry: Geometry, index: number, startFace?: number, endFace?: number); - }; - - export var ImageUtils: { - crossOrigin: string; - loadTexture(url: string, mapping?: Mapping, onLoad?: (texture: Texture) => void , onError?: (message: string) => void ): Texture; - loadCompressedTexture(url: string, mapping?: Mapping, onLoad?: (texture: Texture) => void , onError?: (message: string) => void ): Texture; - loadTextureCube(array: string[], mapping?: Mapping, onLoad?: () => void , onError?: (message: string) => void ): Texture; - loadCompressedTextureCube(array: string[], mapping?: Mapping, onLoad?: () => void , onError?: (message: string) => void ): Texture; - parseDDS(buffer: ArrayBuffer, loadMipmaps: boolean): { mipmaps: { data: Uint8Array; width: number; height: number; }[]; width: number; height: number; format: number; mipmapCount: number; }; - getNormalMap(image: HTMLImageElement, depth?: number): HTMLCanvasElement; - generateDataTexture(width: number, height: number, color: Color): DataTexture; - }; - - export var SceneUtils: { - createMultiMaterialObject(geometry: Geometry, materials: Material[]): Object3D; - detach(child: Object3D, parent: Object3D, scene: Scene): void; - attach(child: Object3D, scene: Scene, parent: Object3D): void; - }; - - // Extras / Animation ///////////////////////////////////////////////////////////////////// - - export interface KeyFrame { - pos: number[]; - rot: number[]; - scl: number[]; - time: number; - } - - export interface KeyFrames { - keys: KeyFrame[]; - parent: number; - } - - export interface AnimationData { - JIT: number; - fps: number; - hierarchy: KeyFrames[]; - length: number; - name: string; - } - - export class Animation { - constructor(root: Mesh, name: string, interpolationType?: AnimationInterpolation); - - interpolateCatmullRom(points: Vector3[], scale: number): Vector3[]; - interpolate(p0: number, p1: number, p2: number, p3: number, t: number, t2: number, t3: number): number; - - root: Mesh; - data: AnimationData; - hierarchy: Bone[]; - currentTime: number; - timeScale: number; - isPlaying: boolean; - isPaused: boolean; - loop: boolean; - interpolationType: AnimationInterpolation; - points: Vector3[]; - target: Vector3; - play(loop?: boolean, startTimeMS?: number): void; - pause(): void; - stop(): void; - update(deltaTimeMS: number): void; - - getNextKeyWith(type: string, h: number, key: number): KeyFrame; // ???? - getPrevKeyWith(type: string, h: number, key: number): KeyFrame; - } - - export class AnimationInterpolation { } - - export var AnimationHandler: { - update(deltaTimeMS: number): void; - addToUpdate(animation: Animation): void; - removeFromUpdate(animation: Animation): void; - add(data: AnimationData): void; - get (name: string): AnimationData; - parse(root: SkinnedMesh): Object3D[]; - - LINEAR: AnimationInterpolation; - CATMULLROM: AnimationInterpolation; - CATMULLROM_FORWARD: AnimationInterpolation; - }; - - export class AnimationMorphTarget { - constructor(root: Bone, data: any); - influence: number; - - root: Bone; - data: Object; - hierarchy: KeyFrames[]; - currentTime: number; - timeScale: number; - isPlaying: boolean; - isPaused: boolean; - loop: boolean; - play(loop?: boolean, startTimeMS?: number): void; - pause(): void; - stop(): void; - update(deltaTimeMS: number): void; - } - - export class KeyFrameAnimation { - constructor(root: Mesh, data: any, JITCompile?: boolean); - JITCompile: number; - - root: Mesh; - data: Object; - hierarchy: KeyFrames[]; - currentTime: number; - timeScale: number; - isPlaying: number; - isPaused: number; - loop: number; - play(loop?: number, startTimeMS?: number): void; - pause(): void; - stop(): void; - update(deltaTimeMS: number): void; - - getNextKeyWith(type: string, h: number, key: number): KeyFrame; // ???? - getPrevKeyWith(type: string, h: number, key: number): KeyFrame; - } - - // Extras / Cameras ///////////////////////////////////////////////////////////////////// - - export class CombinedCamera extends Camera { - constructor(width: number, height: number, fov: number, near: number, far: number, orthoNear: number, orthoFar: number); - fov: number; - left: number; - right: number; - top: number; - bottom: number; - cameraO: OrthographicCamera; - cameraP: PerspectiveCamera; - zoom: number; - near: number; - far: number; - inPerspectiveMode: boolean; - inOrthographicMode: boolean; - toPerspective(): void; - toOrthographic(): void; - setSize(width: number, height: number): void; - setFov(fov: number): void; - updateProjectionMatrix(): void; - setLens(focalLength: number, frameHeight?: number): number; - setZoom(zoom: number): void; - toFrontView(): void; - toBackView(): void; - toLeftView(): void; - toRightView(): void; - toTopView(): void; - toBottomView(): void; - } - - export class CubeCamera extends Object3D { - constructor(near: number, far: number, cubeResolution: number); - renderTarget: WebGLRenderTargetCube; - updateCubeMap(renderer: Renderer, scene: Scene): void; - } - - // Extras / Core ///////////////////////////////////////////////////////////////////// - - /** - * An extensible curve object which contains methods for interpolation - * class Curve - */ - export class Curve { - constructor(); - - /** - * Returns a vector for point t of the curve where t is between 0 and 1 - * getPoint(t: number): T; - */ - getPoint(t: number): Vector; - - /** - * Returns a vector for point at relative position in curve according to arc length - * getPointAt(u: number): T; - */ - getPointAt(u: number): Vector; - - /** - * Get sequence of points using getPoint( t ) - * getPoints(divisions?: number): T[]; - */ - getPoints(divisions?: number): Vector[]; - - /** - * Get sequence of equi-spaced points using getPointAt( u ) - * getSpacedPoints(divisions?: number): T[]; - */ - getSpacedPoints(divisions?: number): Vector[]; - - /** - * Get total curve arc length - */ - getLength(): number; - - /** - * Get list of cumulative segment lengths - */ - getLengths(divisions?: number): number[]; - - needsUpdate: boolean; - - /** - * Update the cumlative segment distance cache - */ - updateArcLengths(): void; - - /** - * Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equi distance - */ - getUtoTmapping(u: number, distance: number): number; - - /** - * getNormalVector(t: number): T; - */ - getNormalVector(t: number): Vector; - - /** - * Returns a unit vector tangent at t. If the subclassed curve do not implement its tangent derivation, 2 points a small delta apart will be used to find its gradient which seems to give a reasonable approximation - * getTangent(t: number): T; - */ - getTangent(t: number): Vector; - - /** - * Returns tangent at equidistance point u on the curve - * getTangentAt(u: number): T; - */ - getTangentAt(u: number): Vector; - - static Utils: { - tangentQuadraticBezier(t: number, p0: number, p1: number, p2: number): number; - tangentCubicBezier(t: number, p0: number, p1: number, p2: number, p3: number): number; - tangentSpline(t: number, p0: number, p1: number, p2: number, p3: number): number; - interpolate(p0: number, p1: number, p2: number, p3: number, t: number): number; - }; - - static create(constructorFunc: Function, getPointFunc: Function): Function; - } - - /** - * class LineCurve extends Curve - */ - export class LineCurve extends Curve { - constructor(v1: Vector2, v2: Vector2); - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - - /** - * class QuadraticBezierCurve extends Curve - */ - export class QuadraticBezierCurve extends Curve { - constructor(v0: Vector2, v1: Vector2, v2: Vector2); - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - /** - * class CubicBezierCurve extends Curve - */ - export class CubicBezierCurve extends Curve { - constructor(v0: number, v1: number, v2: number, v3: number); - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - /** - * class SplineCurve extends Curve - */ - export class SplineCurve extends Curve { - constructor(points?: Vector2[]); - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - /** - * class EllipseCurve extends Curve - */ - export class EllipseCurve extends Curve { - constructor(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean); - aX: number; - aY: number; - xRadius: number; - yRadius: number; - aStartAngle: number; - aEndAngle: number; - aClockwise: boolean; - - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - /** - * class ArcCurve extends EllipseCurve - */ - export class ArcCurve extends EllipseCurve { - constructor(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean); - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getPoints(divisions?: number): Vector2[]; - getSpacedPoints(divisions?: number): Vector2[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector2; - getTangent(t: number): Vector2; - getTangentAt(u: number): Vector2; - } - - /** - * class LineCurve3 extends Curve - */ - export class LineCurve3 extends Curve { - constructor(v1: Vector3, v2: Vector3); - getPoint(t: number): Vector3; - getPointAt(u: number): Vector3; - getPoints(divisions?: number): Vector3[]; - getSpacedPoints(divisions?: number): Vector3[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector3; - getTangent(t: number): Vector3; - getTangentAt(u: number): Vector3; - } - - /** - * class QuadraticBezierCurve3 extends Curve - */ - export class QuadraticBezierCurve3 extends Curve { - constructor(v0: Vector3, v1: Vector3, v2: Vector3); - getPoint(t: number): Vector3; - getPointAt(u: number): Vector3; - getPoints(divisions?: number): Vector3[]; - getSpacedPoints(divisions?: number): Vector3[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector3; - getTangent(t: number): Vector3; - getTangentAt(u: number): Vector3; - } - - /** - * class CubicBezierCurve3 extends Curve - */ - export class CubicBezierCurve3 extends Curve { - constructor(v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3); - getPoint(t: number): Vector3; - getPointAt(u: number): Vector3; - getPoints(divisions?: number): Vector3[]; - getSpacedPoints(divisions?: number): Vector3[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector3; - getTangent(t: number): Vector3; - getTangentAt(u: number): Vector3; - } - - /** - * class SplineCurve3 extends Curve - */ - export class SplineCurve3 extends Curve { - constructor(points?: Vector3[]); - points: Vector3[]; - getPoint(t: number): Vector3; - getPointAt(u: number): Vector3; - getPoints(divisions?: number): Vector3[]; - getSpacedPoints(divisions?: number): Vector3[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector3; - getTangent(t: number): Vector3; - getTangentAt(u: number): Vector3; - } - - /** - * class ClosedSplineCurve3 extends Curve - */ - export class ClosedSplineCurve3 extends Curve { - constructor(points?: Vector3[]); - points: Vector3[]; - getPoint(t: number): Vector3; - getPointAt(u: number): Vector3; - getPoints(divisions?: number): Vector3[]; - getSpacedPoints(divisions?: number): Vector3[]; - getLength(): number; - getLengths(divisions?: number): number[]; - needsUpdate: boolean; - updateArcLengths(): void; - getUtoTmapping(u: number, distance: number): number; - getNormalVector(t: number): Vector3; - getTangent(t: number): Vector3; - getTangentAt(u: number): Vector3; - } - - export interface BoundingBox { - minX: number; - minY: number; - maxX: number; - maxY: number; - centroid: Vector; - } - - export class CurvePath extends Curve { - constructor(); - curves: Curve[]; - bends: Path[]; - autoClose: boolean; - add(curve: Curve): void; - checkConnection(): boolean; - closePath(): void; - getBoundingBox(): BoundingBox; - createPointsGeometry(divisions: number): Geometry; - createSpacedPointsGeometry(divisions: number): Geometry; - createGeometry(points: Vector2[]): Geometry; - addWrapPath(bendpath: Path): void; - getTransformedPoints(segments: number, bends?: Path): Vector2[]; - getTransformedSpacedPoints(segments: number, bends?: Path[]): Vector2[]; - getWrapPoints(oldPts: Vector2[], path: Path): Vector2[]; - } - - export enum PathActions { - MOVE_TO, - LINE_TO, - QUADRATIC_CURVE_TO, // Bezier quadratic curve - BEZIER_CURVE_TO, // Bezier cubic curve - CSPLINE_THRU, // Catmull-rom spline - ARC, // Circle - ELLIPSE, - } - - /** - * a 2d path representation, comprising of points, lines, and cubes, similar to the html5 2d canvas api. It extends CurvePath. - */ - export class Path extends CurvePath { - constructor(points?: Vector2); - actions: PathActions[]; - fromPoints(vectors: Vector2[]): void; - moveTo(x: number, y: number): void; - lineTo(x: number, y: number): void; - quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void; - bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): void; - splineThru(pts: Vector2[]): void; - arc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; - absarc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; - ellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; - absellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; - toShapes(): Shape[]; - } - - export class Gyroscope extends Object3D { - constructor(); - updateMatrixWorld(force?: boolean): void; - translationWorld: Vector3; - translationObject: Vector3; - rotationWorld: Quaternion; - rotationObject: Quaternion; - scaleWorld: Vector3; - scaleObject: Vector3; - } - - /** - * Defines a 2d shape plane using paths. - */ - export class Shape extends Path { - constructor(); - holes: Vector2[][]; - extrude(options?: any): ExtrudeGeometry; - makeGeometry(options?: any): ShapeGeometry; - getPointsHoles(divisions: number): Vector2[][]; - getSpacedPointsHoles(divisions: number): Vector2[][]; - extractAllPoints(divisions: number): { - shape: Vector2[]; - holes: Vector2[][]; - }; - useSpacedPoints: boolean; - extractPoints(divisions: number): Vector2[]; - extractAllSpacedPoints(divisions: Vector2): { - shape: Vector2[]; - holes: Vector2[][]; - }; - - static Utils: { - removeHoles(contour: Vector2[], holes: Vector2[][]): { - shape: Shape; - isolatedPts: Vector2[]; - allpoints: Vector2[]; - }; - triangulateShape(contour: Vector2[], holes: Vector2[][]): Vector2[]; - isClockWise(pts: Vector2[]): boolean; - b2p0(t: number, p: number): number; - b2p1(t: number, p: number): number; - b2p2(t: number, p: number): number; - b2(t: number, p0: number, p1: number, p2: number): number; - b3p0(t: number, p: number): number; - b3p1(t: number, p: number): number; - b3p2(t: number, p: number): number; - b3p3(t: number, p: number): number; - b3(t: number, p0: number, p1: number, p2: number, p3: number): number; - }; - } - - - - // Extras / Geomerties ///////////////////////////////////////////////////////////////////// - - export class AsteriskGeometry extends Geometry { - constructor(innerRadius: number, outerRadius: number); - } - - export class CircleGeometry extends Geometry { - constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number); - } - - export class ConvexGeometry extends Geometry { - constructor(vertices: Vector3); - } - - /** - * CubeGeometry is the quadrilateral primitive geometry class. It is typically used for creating a cube or irregular quadrilateral of the dimensions provided within the (optional) 'width', 'height', & 'depth' constructor arguments. - */ - export class CubeGeometry extends Geometry { - /** - * @param width — Width of the sides on the X axis. - * @param height — Height of the sides on the Y axis. - * @param depth — Depth of the sides on the Z axis. - * @param widthSegments — Number of segmented faces along the width of the sides. - * @param heightSegments — Number of segmented faces along the height of the sides. - * @param depthSegments — Number of segmented faces along the depth of the sides. - */ - constructor(width: number, height: number, depth: number, widthSegments?: number, heightSegments?: number, depthSegments?: number); - } - - export class CylinderGeometry extends Geometry { - /** - * @param radiusTop — Radius of the cylinder at the top. - * @param radiusBottom — Radius of the cylinder at the bottom. - * @param height — Height of the cylinder. - * @param radiusSegments — Number of segmented faces around the circumference of the cylinder. - * @param heightSegments — Number of rows of faces along the height of the cylinder. - * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder. - */ - constructor(radiusTop?: number, radiusBottom?: number, height?: number, radiusSegments?: number, heightSegments?: number, openEnded?: boolean); - } - - export class ExtrudeGeometry extends Geometry { - constructor(shape?: Shape, options?: any); - constructor(shapes?: Shape[], options?: any); - shapebb: BoundingBox; - addShapeList(shapes: Shape[], options?: any): void; - addShape(shape: Shape, options?: any): void; - static WorldUVGenerator: { - generateTopUV(geometry: Geometry, extrudedShape: Shape, extrudeOptions: Object, indexA: number, indexB: number, indexC: number): Vector2[]; - generateBottomUV(geometry: Geometry, extrudedShape: Shape, extrudeOptions: Object, indexA: number, indexB: number, indexC: number): Vector2[]; - generateSideWallUV(geometry: Geometry, extrudedShape: Shape, wallContour: Object, extrudeOptions: Object, - indexA: number, indexB: number, indexC: number, indexD: number, stepIndex: number, stepsLength: number, - contourIndex1: number, contourIndex2: number): Vector2[]; - }; - } - - export class IcosahedronGeometry extends PolyhedronGeometry { - constructor(radius: number, detail: number); - } - - export class LatheGeometry extends Geometry { - constructor(points: Vector3[], steps?: number, angle?: number); - } - - export class OctahedronGeometry extends PolyhedronGeometry { - constructor(radius: number, detail: number); - } - - export class ParametricGeometry extends Geometry { - constructor(func: (u: number, v: number) => Vector3, slices: number, stacks: number, useTris?: boolean); - } - - export class PlaneGeometry extends Geometry { - constructor(width: number, height: number, widthSegments?: number, heightSegments?: number); - width: number; - height: number; - widthSegments: number; - heightSegments: number; - } - - export class PolyhedronGeometry extends Geometry { - constructor(vertices: Vector3[], faces: Face[], radius?: number, detail?: number); - } - - export class ShapeGeometry extends Geometry { - constructor(shape: Shape, options: any); - constructor(shapes: Shape[], options: any); - shapebb: BoundingBox; - addShapeList(shapes: Shape[], options: any): ShapeGeometry; - addShape(shape: Shape, options?: any): void; - } - - /** - * A class for generating sphere geometries - */ - export class SphereGeometry extends Geometry { - /** - * The geometry is created by sweeping and calculating vertexes around the Y axis (horizontal sweep) and the Z axis (vertical sweep). Thus, incomplete spheres (akin to 'sphere slices') can be created through the use of different values of phiStart, phiLength, thetaStart and thetaLength, in order to define the points in which we start (or end) calculating those vertices. - * - * @param radius — sphere radius. Default is 50. - * @param segmentsWidth — number of horizontal segments. Minimum value is 3, and the default is 8. - * @param segmentsHeight — number of vertical segments. Minimum value is 2, and the default is 6. - * @param phiStart — specify horizontal starting angle. Default is 0. - * @param phiLength — specify horizontal sweep angle size. Default is Math.PI * 2. - * @param thetaStart — specify vertical starting angle. Default is 0. - * @param thetaLength — specify vertical sweep angle size. Default is Math.PI. - */ - constructor(radius: number, widthSegments?: number, heightSegments?: number, phiStart?: number, phiLength?: number, thetaStart?: number, thetaLength?: number); - radius: number; - widthSegments: number; - heightSegments: number; - phiStart: number; - phiLength: number; - thetaStart: number; - thetaLength: number; - } - - export class TetrahedronGeometry extends PolyhedronGeometry { - constructor(radius?: number, detail?: number); - } - - export interface TextGeometryParameters { - size?: number; // size of the text - height?: number; // thickness to extrude text - curveSegments?: number; // number of points on the curves - font?: string; // font name - weight?: string; // font weight (normal, bold) - style?: string; // font style (normal, italics) - bevelEnabled?: boolean; // turn on bevel - bevelThickness?: number; // how deep into text bevel goes - bevelSize?: number; // how far from text outline is bevel - } - - export class TextGeometry extends ExtrudeGeometry { - constructor(text: string, TextGeometryParameters?: TextGeometryParameters); - } - - export class TorusGeometry extends Geometry { - constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number); - radius: number; - tube: number; - radialSegments: number; - tubularSegments: number; - arc: number; - } - - export class TorusKnotGeometry extends Geometry { - constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, heightScale?: number); - radius: number; - tube: number; - radialSegments: number; - tubularSegments: number; - p: number; - q: number; - heightScale: number; - grid: number[][]; - } - - export class TubeGeometry extends Geometry { - constructor(path: Path, segments?: number, radius?: number, radiusSegments?: number, closed?: boolean, debug?: ArrowHelper[]); - path: Path; - segments: number; - radius: number; - radiusSegments: number; - closed: boolean; - grid: number[][]; - tangents: Vector3[]; - normals: Vector3[]; - binormals: Vector3[]; - FrenetFrames(path: Path, segments: number, closed: boolean): void; - } - - // Extras / Helpers ///////////////////////////////////////////////////////////////////// - - export class AxisHelper extends Line { - constructor(size: number); - } - - export class ArrowHelper extends Object3D { - constructor(dir: Vector3, origin?: Vector3, length?: number, hex?: number); - line: Line; - cone: Mesh; - setDirection(dir: Vector3): void; - setLength(length: number): void; - setColor(hex: number): void; - } - - export class CameraHelper extends Line { - constructor(camera: Camera); - pointMap: { [id: string]: number[]; }; - camera: Camera; - } - - export class DirectionalLightHelper extends Object3D { - constructor(light: Light, sphereSize: number, arrowLength: number); - light: Light; - direction: Vector3; - color: Color; - lightArrow: ArrowHelper; - lightSphere: Mesh; - lightRays: Line; - targetSphere: Mesh; - targetLine: Line; - } - - export class HemisphereLightHelper extends Object3D { - constructor(light: Light, sphereSize: number, arrowLength: number, domeSize: number); - light: Light; - color: Color; - groundColor: Color; - lightSphere: Mesh; - lightArrow: ArrowHelper; - lightArrowGround: ArrowHelper; - target: Vector3; - } - - export class PointLightHelper extends Object3D { - constructor(light: Light, sphereSize: number); - light: Light; - color: Color; - lightSphere: Mesh; - lightRays: Line; - lightDistance: Mesh; - } - - export class SpotLightHelper extends Object3D { - constructor(light: Light, sphereSize: number, arrowLength: number); - light: Light; - direction: Vector3; - color: Color; - lightArrow: ArrowHelper; - lightSphere: Mesh; - lightCone: Mesh; - lightRays: Line; - gyroscope: Gyroscope; - targetSphere: Mesh; - targetLine: Line; - } - - // Extras / Objects ///////////////////////////////////////////////////////////////////// - - export class ImmediateRenderObject extends Object3D { - constructor(); - // render(renderCallback):void; - } - - export interface LensFlareProperty { - texture: Texture; // Texture - size: number; // size in pixels (-1 = use texture.width) - distance: number; // distance (0-1) from light source (0=at light source) - x: number; - y: number; - z: number; // screen position (-1 => 1) z = 0 is ontop z = 1 is back - scale: number; // scale - rotation: number; // rotation - opacity: number; // opacity - color: Color; // color - blending: Blending; - } - - export class LensFlare extends Object3D { - constructor(texture?: Texture, size?: number, distance?: number, blending?: Blending, color?: number); - lensFlares: LensFlareProperty[]; - positionScreen: Vector3; - customUpdateCallback: () => void; - add(object: Object3D): void; - add(texture?: Texture, size?: number, distance?: number, blending?: Blending, color?: number, opacity?: number): void; - updateLensFlares(): void; - } - - export interface MorphBlendMeshAnimation { - startFrame: number; - endFrame: number; - length: number; - fps: number; - duration: number; - lastFrame: number; - currentFrame: number; - active: boolean; - time: number; - direction: number; - weight: number; - directionBackwards: boolean; - mirroredLoop: boolean; - } - - export class MorphBlendMesh extends Mesh { - constructor(geometry: Geometry, material: Material); - animationsMap: { [name: string]: MorphBlendMeshAnimation; }; - animationsList: MorphBlendMeshAnimation[]; - createAnimation(name: string, start: number, end: number, fps: number): void; - autoCreateAnimations(fps: number): void; - firstAnimation: string; - setAnimationDirectionForward(name: string): void; - setAnimationDirectionBackward(name: string): void; - setAnimationFPS(name: string, fps: number): void; - setAnimationDuration(name: string, duration: number): void; - setAnimationWeight(name: string, weight: number): void; - setAnimationTime(name: string, time: number): void; - getAnimationTime(name: string): number; - getAnimationDuration(name: string): number; - playAnimation(name: string): void; - stopAnimation(name: string): void; - update(delta: number): void; - } - - // Extras / Renderers / Plugins ///////////////////////////////////////////////////////////////////// - - export class DepthPassPlugin implements RendererPlugin { - constructor(); - enabled: boolean; - renderTarget: RenderTarget; - init(renderer: Renderer): void; - render(scene: Scene, camera: Camera): void; - update(scene: Scene, camera: Camera): void; - } - - export class LensFlarePlugin implements RendererPlugin { - constructor(); - init(renderer: Renderer): void; - render(scene: Scene, camera: Camera, viewportWidth: number, viewportHeight: number): void; - } - - export class ShadowMapPlugin implements RendererPlugin { - constructor(); - init(renderer: Renderer): void; - render(scene: Scene, camera: Camera): void; - update(scene: Scene, camera: Camera): void; - } - - export class SpritePlugin implements RendererPlugin { - constructor(); - init(renderer: Renderer): void; - render(scene: Scene, camera: Camera, viewportWidth: number, viewportHeight: number): void; - } - - // renderers ///////////////////////////////////////////////////////////////////// - - export interface ShaderLibrary { - [name: string]: { - vertexShader: string; - fragmentShader: string; - }; - } - export var ShaderFlares: ShaderLibrary; - export var ShaderSprite: ShaderLibrary; - - export var UniformsUtils: { - merge(uniforms: Object[]): Uniforms; - merge(uniforms: Uniforms[]): Uniforms; - clone(uniforms_src: Object[][]): Object[][]; - }; - - export var UniformsLib: { - common: Uniforms; - bump: Uniforms; - normalmap: Uniforms; - fog: Uniforms; - lights: Uniforms; - particle: Uniforms; - shadowmap: Uniforms; - }; - - export interface Shader { - uniforms: Uniforms; - vertexShader: string; - fragmentShader: string; - } - - export var ShaderLib: { - [name: string]: Shader; - basic: Shader; - lambert: Shader; - phong: Shader; - particle_basic: Shader; - depth: Shader; - dashed: Shader; - normal: Shader; - normalmap: Shader; - cube: Shader; - depthRGBA: Shader; - }; -} - - - diff --git a/threejs/three-r55.d.ts.tscparams b/threejs/three-r55.d.ts.tscparams deleted file mode 100644 index e16c76dff..000000000 --- a/threejs/three-r55.d.ts.tscparams +++ /dev/null @@ -1 +0,0 @@ -"" diff --git a/threejs/three-tests.ts b/threejs/three-tests.disabled.ts similarity index 100% rename from threejs/three-tests.ts rename to threejs/three-tests.disabled.ts diff --git a/threejs/three.d.ts b/threejs/three.d.ts index bac14bb4a..e2e923f87 100644 --- a/threejs/three.d.ts +++ b/threejs/three.d.ts @@ -5468,7 +5468,7 @@ declare module THREE { /** * Defines a 2d shape plane using paths. */ - export class Shape extends Path { + export class Shape /* extends Path */ implements Path { constructor(points?: Vector2[]); holes: Path[]; extrude(options?: any): ExtrudeGeometry; @@ -5504,6 +5504,48 @@ declare module THREE { b3p3(t: number, p: number): number; b3(t: number, p0: number, p1: number, p2: number, p3: number): number; }; + + // trick for TypeScript 0.9.5 compile passed + // from Path + actions: PathActions[]; + fromPoints(vectors: Vector2[]): void; + moveTo(x: number, y: number): void; + lineTo(x: number, y: number): void; + quadraticCurveTo(aCPx: number, aCPy: number, aX: number, aY: number): void; + bezierCurveTo(aCP1x: number, aCP1y: number, aCP2x: number, aCP2y: number, aX: number, aY: number): void; + splineThru(pts: Vector2[]): void; + arc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; + absarc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; + ellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; + absellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; + toShapes(): Shape[]; + // from CurvePath + curves: Curve[]; + bends: Path[]; + autoClose: boolean; + add(curve: Curve): void; + checkConnection(): boolean; + closePath(): void; + getBoundingBox(): BoundingBox; + createPointsGeometry(divisions: number): Geometry; + createSpacedPointsGeometry(divisions: number): Geometry; + createGeometry(points: Vector2[]): Geometry; + addWrapPath(bendpath: Path): void; + getTransformedPoints(segments: number, bends?: Path): Vector2[]; + getTransformedSpacedPoints(segments: number, bends?: Path[]): Vector2[]; + getWrapPoints(oldPts: Vector2[], path: Path): Vector2[]; + getPoint(t: number): Vector; + getPointAt(u: number): Vector; + getPoints(divisions?: number): Vector[]; + getSpacedPoints(divisions?: number): Vector[]; + getLength(): number; + getLengths(divisions?: number): number[]; + needsUpdate: boolean; + updateArcLengths(): void; + getUtoTmapping(u: number, distance: number): number; + getNormalVector(t: number): Vector; + getTangent(t: number): Vector; + getTangentAt(u: number): Vector; } diff --git a/titanium/titanium-tests.ts b/titanium/titanium-tests.ts index 3899824c7..a4057b80c 100644 --- a/titanium/titanium-tests.ts +++ b/titanium/titanium-tests.ts @@ -111,7 +111,7 @@ function test_map() { mapview.regionFit = true; mapview.userLocation = true; mapview.annotations = [mountainView]; - mapview.addEventListener('click', function(evt) { + mapview.addEventListener('click', function(evt?) { if (evt.clicksource === 'leftButton' || evt.clicksource === 'leftPane') { alert(evt.title + ' left button clicked'); } diff --git a/titanium/titanium.d.ts b/titanium/titanium.d.ts index f4346e579..5ebe93024 100644 --- a/titanium/titanium.d.ts +++ b/titanium/titanium.d.ts @@ -460,7 +460,7 @@ declare module Ti { } export interface DocumentViewer extends Ti.UI.View { setUrl (url: string) : void; - show (animated: boolean, view: any) : void; + show(animated?: boolean, view?: any) : void; } export interface Popover extends Ti.UI.View { arrowDirection : number; diff --git a/typeahead/typeahead-tests.ts b/typeahead/typeahead-tests.ts index dee467e0f..f93049a44 100644 --- a/typeahead/typeahead-tests.ts +++ b/typeahead/typeahead-tests.ts @@ -4,7 +4,7 @@ // // Examples from http://twitter.github.com/typeahead.js/examples // -declare var Hogan: any; +declare var Hogan: string; // Countries // Prefetches data, stores it in localStorage, and searches it on the client diff --git a/underscore/underscore-tests.ts b/underscore/underscore-tests.ts index aa70ea4d9..ae5ab6f7e 100644 --- a/underscore/underscore-tests.ts +++ b/underscore/underscore-tests.ts @@ -8,11 +8,13 @@ _.each({ one: 1, two: 2, three: 3 }, (value) => alert(value.toString())); _.map([1, 2, 3], (num) => num * 3); _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3); -var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0); -sum = _.reduce([1, 2, 3], (memo, num) => memo + num); // memo is optional #issue 5 github +//var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0); // https://typescript.codeplex.com/workitem/1960 +var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0); +sum = _.reduce([1, 2, 3], (memo, num) => memo + num); // memo is optional #issue 5 github var list = [[0, 1], [2, 3], [4, 5]]; -var flat = _.reduceRight(list, (a, b) => a.concat(b), []); +//var flat = _.reduceRight(list, (a, b) => a.concat(b), []); // https://typescript.codeplex.com/workitem/1960 +var flat = _.reduceRight(list, (a, b) => a.concat(b), []); var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); @@ -23,7 +25,8 @@ _.where(listOfPlays, { author: "Shakespeare", year: 1611 }); var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); -_.every([true, 1, null, 'yes'], _.identity); +//_.every([true, 1, null, 'yes'], _.identity); // https://typescript.codeplex.com/workitem/1960 +_.every([true, 1, null, 'yes'], _.identity); _.every<{}>([true, 1, null, 'yes']); _.any([null, 0, 'yes', false]); @@ -279,10 +282,11 @@ _(['test', 'test']).pick(['test2', 'test2']); //////////////// Chain Tests function chain_tests() { - var list:number[] = _.chain([1, 2, 3, 4, 5, 6, 7, 8]) + // https://typescript.codeplex.com/workitem/1960 + var list:number[] = _.chain([1, 2, 3, 4, 5, 6, 7, 8]) .filter(n => n % 2 == 0) .map(n => n * n) - .value(); + .value(); _([1, 2, 3, 4]) .chain() diff --git a/viewporter/viewporter-tests.ts b/viewporter/viewporter-tests.ts index 35c8c2ae4..9ce0be298 100644 --- a/viewporter/viewporter-tests.ts +++ b/viewporter/viewporter-tests.ts @@ -119,7 +119,7 @@ function test_swipey() { }).trigger(viewporter.ACTIVE ? 'viewportchange' : 'resize'); $('canvas').bind(iOS ? 'touchstart' : 'mousedown', function (e) { e.preventDefault(); - var touches = iOS ? e.originalEvent.changedTouches : [e.originalEvent]; + var touches = iOS ? (e.originalEvent).changedTouches : [e.originalEvent]; var identifier; for (var i = 0; i < touches.length; i++) { identifier = touches[i].identifier || 'mouse'; @@ -133,7 +133,7 @@ function test_swipey() { }); $('canvas').bind(iOS ? 'touchmove' : 'mousemove', function (e) { - var touches = iOS ? e.originalEvent.changedTouches : [e.originalEvent]; + var touches = iOS ? (e.originalEvent).changedTouches : [e.originalEvent]; var identifier; for (var i = 0; i < touches.length; i++) { identifier = touches[i].identifier || 'mouse'; @@ -144,7 +144,7 @@ function test_swipey() { }); $('canvas').bind(iOS ? 'touchend' : 'mouseup', function (e) { - var touches = iOS ? e.originalEvent.changedTouches : [e.originalEvent]; + var touches = iOS ? (e.originalEvent).changedTouches : [e.originalEvent]; var identifier; for (var i = 0; i < touches.length; i++) { identifier = touches[i].identifier || 'mouse';