@angular-wave/angular.ts 0.0.47 → 0.0.49

package/types/core/parser/ast.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @param {import('./lexer').Lexer} lexer
+ * @param {*} options
+ */
+export function AST(lexer: import("./lexer").Lexer, options: any): void;
+export class AST {
+    /**
+     * @param {import('./lexer').Lexer} lexer
+     * @param {*} options
+     */
+    constructor(lexer: import("./lexer").Lexer, options: any);
+    lexer: import("./lexer").Lexer;
+    options: any;
+    ast(text: any): {
+        type: string;
+        body: {
+            type: string;
+            expression: any;
+        }[];
+    };
+    text: any;
+    tokens: import("./lexer").Token[];
+    program(): {
+        type: string;
+        body: {
+            type: string;
+            expression: any;
+        }[];
+    };
+    expressionStatement(): {
+        type: string;
+        expression: any;
+    };
+    filterChain(): any;
+    expression(): any;
+    assignment(): any;
+    ternary(): any;
+    logicalOR(): any;
+    logicalAND(): any;
+    equality(): any;
+    relational(): any;
+    additive(): any;
+    multiplicative(): any;
+    unary(): any;
+    primary(): any;
+    filter(baseExpression: any): {
+        type: string;
+        callee: {
+            type: string;
+            name: any;
+        };
+        arguments: any[];
+        filter: boolean;
+    };
+    parseArguments(): any;
+    identifier(): {
+        type: string;
+        name: any;
+    };
+    constant(): {
+        type: string;
+        value: any;
+    };
+    arrayDeclaration(): any;
+    object(): {
+        type: string;
+        properties: {
+            type: string;
+            kind: string;
+        }[];
+    };
+    throwError(msg: any, token: any): never;
+    consume(e1: any): false | import("./lexer").Token;
+    peekToken(): import("./lexer").Token;
+    peek(e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
+    peekAhead(i: any, e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
+    expect(e1: any, e2: any, e3: any, e4: any): false | import("./lexer").Token;
+    selfReferential: {
+        this: {
+            type: string;
+        };
+        $locals: {
+            type: string;
+        };
+    };
+}

package/types/core/parser/compiler.d.ts

@@ -0,0 +1,49 @@
+export function ASTCompiler($filter: any): void;
+export class ASTCompiler {
+    constructor($filter: any);
+    $filter: any;
+    compile(ast: any): any;
+    state: {
+        nextId: number;
+        filters: {};
+        fn: {
+            vars: any[];
+            body: any[];
+            own: {};
+        };
+        assign: {
+            vars: any[];
+            body: any[];
+            own: {};
+        };
+        inputs: any[];
+    };
+    stage: string;
+    watchFns(): string;
+    generateFunction(name: any, params: any): string;
+    filterPrefix(): string;
+    varsPrefix(section: any): string;
+    body(section: any): any;
+    recurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): void;
+    getHasOwnProperty(element: any, property: any): any;
+    assign(id: any, value: any): any;
+    filter(filterName: any): any;
+    ifDefined(id: any, defaultValue: any): string;
+    plus(left: any, right: any): string;
+    return_(id: any): void;
+    if_(test: any, alternate: any, consequent: any): void;
+    not(expression: any): string;
+    isNull(expression: any): string;
+    notNull(expression: any): string;
+    nonComputedMember(left: any, right: any): string;
+    computedMember(left: any, right: any): string;
+    member(left: any, right: any, computed: any): string;
+    getStringValue(item: any): void;
+    lazyRecurse(ast: any, intoId: any, nameId: any, recursionFn: any, create: any, skipWatchIdCheck: any): () => void;
+    lazyAssign(id: any, value: any): () => void;
+    stringEscapeRegex: RegExp;
+    stringEscapeFn(c: any): string;
+    escape(value: any): any;
+    nextId(skip: any, init: any): string;
+    current(): any;
+}

package/types/core/parser/interpreter.d.ts

@@ -0,0 +1,57 @@
+export function ASTInterpreter($filter: any): void;
+export class ASTInterpreter {
+    constructor($filter: any);
+    $filter: any;
+    compile(ast: any): any;
+    recurse(ast: any, context: any, create: any): any;
+    "unary+": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    "unary-": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    "unary!": (argument: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary+": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    "binary-": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
+        value: number;
+    };
+    "binary*": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
+        value: number;
+    };
+    "binary/": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
+        value: number;
+    };
+    "binary%": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => number | {
+        value: number;
+    };
+    "binary===": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary!==": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary==": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary!=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary<": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary>": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary<=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary>=": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => boolean | {
+        value: boolean;
+    };
+    "binary&&": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    "binary||": (left: any, right: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    "ternary?:": (test: any, alternate: any, consequent: any, context: any) => (scope: any, locals: any, assign: any, inputs: any) => any;
+    value(value: any, context: any): () => any;
+    identifier(name: any, context: any, create: any): (scope: any, locals: any) => any;
+    computedMember(left: any, right: any, context: any, create: any): (scope: any, locals: any, assign: any, inputs: any) => any;
+    nonComputedMember(left: any, right: any, context: any, create: any): (scope: any, locals: any, assign: any, inputs: any) => any;
+    inputs(input: any, watchId: any): (scope: any, value: any, locals: any, inputs: any) => any;
+}

package/types/core/parser/lexer.d.ts

@@ -0,0 +1,153 @@
+/**
+ * @typedef {Object} LexerOptions
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] Custom function to determine if a character is a valid identifier start.
+ * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] Custom function to determine if a character is a valid identifier continuation.
+ */
+/**
+ * Represents a token produced by the lexer.
+ * @typedef {Object} Token
+ * @property {number} index Index of the token.
+ * @property {string} text Text of the token.
+ * @property {boolean} [identifier] Indicates if token is an identifier.
+ * @property {boolean} [constant] Indicates if token is a constant.
+ * @property {string|number} [value] Value of the token if it's a constant.
+ * @property {boolean} [operator] Indicates if token is an operator.
+ */
+/**
+ * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
+ * For example, the string "a + b" would result in tokens for a, +, and b.
+ */
+export class Lexer {
+    /**
+     * Creates an instance of Lexer.
+     * @param {LexerOptions} options Lexer options.
+     */
+    constructor(options: LexerOptions);
+    /** @type {LexerOptions} */
+    options: LexerOptions;
+    /**
+     * Tokenizes the input text.
+     * @param {string} text Input text to lex.
+     * @returns {Array<Token>} Array of tokens.
+     */
+    lex(text: string): Array<Token>;
+    text: string;
+    index: number;
+    /** @type {Array<Token>} */
+    tokens: Array<Token>;
+    /**
+     * Checks if a character is contained in a set of characters.
+     * @param {string} ch Character to check.
+     * @param {string} chars Set of characters.
+     * @returns {boolean} True if character is in the set, false otherwise.
+     */
+    is(ch: string, chars: string): boolean;
+    /**
+     * Peeks at the next character in the text.
+     * @param {number} [i=1] Number of characters to peek.
+     * @returns {string|false} Next character or false if end of text.
+     */
+    peek(i?: number): string | false;
+    /**
+     * Checks if a character is a number.
+     * @param {string} ch Character to check.
+     * @returns {boolean} True if character is a number, false otherwise.
+     */
+    isNumber(ch: string): boolean;
+    /**
+     * Checks if a character is whitespace.
+     * @param {string} ch Character to check.
+     * @returns {boolean} True if character is whitespace, false otherwise.
+     */
+    isWhitespace(ch: string): boolean;
+    /**
+     * Checks if a character is a valid identifier start.
+     * @param {string} ch Character to check.
+     * @returns {boolean} True if character is a valid identifier start, false otherwise.
+     */
+    isIdentifierStart(ch: string): boolean;
+    /**
+     * Checks if a character is a valid identifier continuation.
+     * @param {string} ch Character to check.
+     * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
+     */
+    isIdentifierContinue(ch: string): boolean;
+    /**
+     * Converts a character to its Unicode code point.
+     * @param {string} ch Character to convert.
+     * @returns {number} Unicode code point.
+     */
+    codePointAt(ch: string): number;
+    /**
+     * Peeks at the next multicharacter sequence in the text.
+     * @returns {string} Next multicharacter sequence.
+     */
+    peekMultichar(): string;
+    /**
+     * Checks if a character is an exponent operator.
+     * @param {string} ch Character to check.
+     * @returns {boolean} True if character is an exponent operator, false otherwise.
+     */
+    isExpOperator(ch: string): boolean;
+    /**
+     * Throws a lexer error.
+     * @param {string} error Error message.
+     * @param {number} [start] Start index.
+     * @param {number} [end] End index.
+     * @throws {Error} Lexer error.
+     */
+    throwError(error: string, start?: number, end?: number): void;
+    /**
+     * Reads and tokenizes a number from the text.
+     */
+    readNumber(): void;
+    /**
+     * Reads and tokenizes an identifier from the text.
+     */
+    readIdent(): void;
+    /**
+     * Reads and tokenizes a string from the text.
+     * @param {string} quote Quote character used for the string.
+     */
+    readString(quote: string): void;
+    handleUnicodeEscape(): string;
+}
+export type LexerOptions = {
+    /**
+     * Custom function to determine if a character is a valid identifier start.
+     */
+    isIdentifierStart?: (ch: string, codePoint: number) => boolean;
+    /**
+     * Custom function to determine if a character is a valid identifier continuation.
+     */
+    isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
+};
+/**
+ * Represents a token produced by the lexer.
+ */
+export type Token = {
+    /**
+     * Index of the token.
+     */
+    index: number;
+    /**
+     * Text of the token.
+     */
+    text: string;
+    /**
+     * Indicates if token is an identifier.
+     */
+    identifier?: boolean;
+    /**
+     * Indicates if token is a constant.
+     */
+    constant?: boolean;
+    /**
+     * Value of the token if it's a constant.
+     */
+    value?: string | number;
+    /**
+     * Indicates if token is an operator.
+     */
+    operator?: boolean;
+};

package/types/core/parser/parse.d.ts

@@ -0,0 +1,68 @@
+export function $ParseProvider(): void;
+export class $ParseProvider {
+    /**
+     * @ngdoc method
+     * @name $parseProvider#addLiteral
+     * @description
+     *
+     * Configure $parse service to add literal values that will be present as literal at expressions.
+     *
+     * @param {string} literalName Token for the literal value. The literal name value must be a valid literal name.
+     * @param {*} literalValue Value for this literal. All literal values must be primitives or `undefined`.
+     *
+     **/
+    addLiteral: (literalName: string, literalValue: any) => void;
+    /**
+     * @ngdoc method
+     * @name $parseProvider#setIdentifierFns
+     *
+     * @description
+     *
+     * Allows defining the set of characters that are allowed in AngularJS expressions. The function
+     * `identifierStart` will get called to know if a given character is a valid character to be the
+     * first character for an identifier. The function `identifierContinue` will get called to know if
+     * a given character is a valid character to be a follow-up identifier character. The functions
+     * `identifierStart` and `identifierContinue` will receive as arguments the single character to be
+     * identifier and the character code point. These arguments will be `string` and `numeric`. Keep in
+     * mind that the `string` parameter can be two characters long depending on the character
+     * representation. It is expected for the function to return `true` or `false`, whether that
+     * character is allowed or not.
+     *
+     * Since this function will be called extensively, keep the implementation of these functions fast,
+     * as the performance of these functions have a direct impact on the expressions parsing speed.
+     *
+     * @param {function(any):boolean=} identifierStart The function that will decide whether the given character is
+     *   a valid identifier start character.
+     * @param {function(any):boolean=} identifierContinue The function that will decide whether the given character is
+     *   a valid identifier continue character.
+     */
+    setIdentifierFns: (identifierStart?: ((arg0: any) => boolean) | undefined, identifierContinue?: ((arg0: any) => boolean) | undefined) => this;
+    $get: (string | (($filter: any) => {
+        (exp: any, interceptorFn: any): any;
+        $$getAst: (exp: any) => {
+            type: string;
+            body: {
+                type: string;
+                expression: any;
+            }[];
+        };
+    }))[];
+}
+export function inputsWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
+export function oneTimeWatchDelegate(scope: any, listener: any, objectEquality: any, parsedExpression: any): any;
+export function chainInterceptors(first: any, second: any): {
+    (value: any): any;
+    $stateful: any;
+    $$pure: any;
+};
+export const $parseMinErr: (arg0: string, ...arg1: any[]) => Error;
+export namespace literals {
+    let _true: boolean;
+    export { _true as true };
+    let _false: boolean;
+    export { _false as false };
+    let _null: any;
+    export { _null as null };
+    export let undefined: any;
+}
+export type ParseService = (arg0: string | ((arg0: import("../scope/scope").Scope) => any), arg1: ((arg0: any, arg1: import("../scope/scope").Scope, arg2: any) => any) | undefined, arg2: boolean | undefined) => import("../../types").CompiledExpression;

package/types/core/parser/parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @constructor
+ */
+export class Parser {
+    /**
+     *
+     * @param {import('./lexer').Lexer} lexer
+     * @param {*} $filter
+     * @param {*} options
+     */
+    constructor(lexer: import("./lexer").Lexer, $filter: any, options: any);
+    ast: AST;
+    astCompiler: ASTInterpreter | ASTCompiler;
+    parse(text: any): any;
+    getAst(exp: any): {
+        ast: {
+            type: string;
+            body: {
+                type: string;
+                expression: any;
+            }[];
+        };
+        oneTime: boolean;
+    };
+}
+import { AST } from "./ast";
+import { ASTInterpreter } from "./interpreter";
+import { ASTCompiler } from "./compiler";

package/types/core/parser/shared.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Converts parameter to  strings property name for use  as keys in an object.
+ * Any non-string object, including a number, is typecasted into a string via the toString method.
+ * {@link https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Property_accessors#Property_names}
+ *
+ * @param {!any} name
+ * @returns {string}
+ */
+export function getStringValue(name: any): string;
+export function ifDefined(v: any, d: any): any;
+export function plusFn(l: any, r: any): any;
+export function isStateless($filter: any, filterName: any): boolean;
+export function isPure(node: any, parentIsPure: any): any;
+export function findConstantAndWatchExpressions(ast: any, $filter: any, parentIsPure: any): void;
+export function getInputs(body: any): any;
+export function isAssignable(ast: any): boolean;
+export function assignableAST(ast: any): {
+    type: string;
+    left: any;
+    right: {
+        type: string;
+    };
+    operator: string;
+};
+export function isLiteral(ast: any): boolean;
+export function isConstant(ast: any): any;
+export function getValueOf(value: any): any;
+export const PURITY_ABSOLUTE: 1;
+export const PURITY_RELATIVE: 2;

package/types/core/scope/scope.d.ts

@@ -45,7 +45,10 @@ export const TTL: TTL;
 /** @type {AsyncQueueTask[]} */
 export const $$asyncQueue: AsyncQueueTask[];
 export const $$postDigestQueue: any[];
-export const $$applyAsyncQueue: any[];
+/**
+ * @type {Function[]}
+ */
+export const $$applyAsyncQueue: Function[];
 /**
  * Provider responsible for instantiating the initial scope, aka - root scope.
  * Every application has a single root {@link ng.$rootScope.Scope scope}.
@@ -58,7 +61,7 @@ export const $$applyAsyncQueue: any[];
  *
  */
 export class $RootScopeProvider {
-    $get: (string | ((exceptionHandler: angular.IExceptionHandlerService, parse: angular.IParseService, browser: any) => Scope))[];
+    $get: (string | ((exceptionHandler: import("../exception-handler").ErrorHandler, parse: import("../parser/parse").ParseService, browser: import("../../services/browser").Browser) => Scope))[];
 }
 /**
  * DESIGN NOTES
@@ -100,9 +103,9 @@ export class Scope {
      */
     $root: Scope | null;
     /**
-     * @type {[]}
+     * @type {Array<any>}
      */
-    $$watchers: [];
+    $$watchers: Array<any>;
     /**
      * @type {number}
      */
@@ -293,10 +296,10 @@ export class Scope {
      *   values are examined for changes on every call to `$digest`.
      * - The `listener` is called whenever any expression in the `watchExpressions` array changes.
      *
-     * @param {Array.<string|Function(scope)>} watchExpressions Array of expressions that will be individually
+     * @param {Array.<string|((Scope)=>any)>} watchExpressions Array of expressions that will be individually
      * watched using {@link ng.$rootScope.Scope#$watch $watch()}
      *
-     * @param {function(newValues, oldValues, scope)} listener Callback called whenever the return value of any
+     * @param {function(any, any, Scope): any} listener Callback called whenever the return value of any
      *    expression in `watchExpressions` changes
      *    The `newValues` array contains the current values of the `watchExpressions`, with the indexes matching
      *    those of `watchExpression`
@@ -305,7 +308,7 @@ export class Scope {
      *    The `scope` refers to the current scope.
      * @returns {function()} Returns a de-registration function for all listeners.
      */
-    $watchGroup(watchExpressions: any, listener: (arg0: any[], arg1: any[], arg2: scope) => any): () => any;
+    $watchGroup(watchExpressions: Array<string | ((Scope: any) => any)>, listener: (arg0: any, arg1: any, arg2: Scope) => any): () => any;
     /**
      * @ngdoc method
      * @name $rootScope.Scope#$watchCollection
@@ -324,12 +327,12 @@ export class Scope {
      *
      *
      *
-     * @param {string|function(scope)} obj Evaluated as {@link guide/expression expression}. The
+     * @param {string|function(Scope):any} obj Evaluated as {@link guide/expression expression}. The
      *    expression value should evaluate to an object or an array which is observed on each
      *    {@link ng.$rootScope.Scope#$digest $digest} cycle. Any shallow change within the
      *    collection will trigger a call to the `listener`.
      *
-     * @param {function(newCollection, oldCollection, scope)} listener a callback function called
+     * @param {function(any[], any[], Scope):any} listener a callback function called
      *    when a change is detected.
      *    - The `newCollection` object is the newly modified data obtained from the `obj` expression
      *    - The `oldCollection` object is a copy of the former collection data.
@@ -340,7 +343,7 @@ export class Scope {
      * @returns {function()} Returns a de-registration function for this listener. When the
      *    de-registration function is executed, the internal watch operation is terminated.
      */
-    $watchCollection(obj: string | ((arg0: scope) => any), listener: (arg0: newCollection, arg1: oldCollection, arg2: scope) => any): () => any;
+    $watchCollection(obj: string | ((arg0: Scope) => any), listener: (arg0: any[], arg1: any[], arg2: Scope) => any): () => any;
     /**
    * @ngdoc method
    * @name $rootScope.Scope#$digest
@@ -627,10 +630,10 @@ export class Scope {
      *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
      *
      * @param {string} name Event name to listen on.
-     * @param {function(angular.IAngularEvent): any} listener Function to call when the event is emitted.
+     * @param {function(any): any} listener Function to call when the event is emitted witn angular.IAngularEvent
      * @returns {function()} Returns a deregistration function for this listener.
      */
-    $on(name: string, listener: (arg0: angular.IAngularEvent) => any): () => any;
+    $on(name: string, listener: (arg0: any) => any): () => any;
     /**
    * @ngdoc method
    * @name $rootScope.Scope#$eval
@@ -664,6 +667,10 @@ export class Scope {
      * @private
      */
     private $$postDigest;
+    /**
+     * @private
+     */
+    private retry;
     clearPhase(): void;
     /**
      * @param {number} count

package/types/shared/utils.d.ts

@@ -228,7 +228,7 @@ export function forEach(obj: any | any[], iterator: Function, context?: any | un
 export function forEachSorted(obj: any, iterator: any, context: any): string[];
 /**
  * when using forEach the params are value, key, but it is often useful to have key, value.
- * @param {function(string, *)} iteratorFn
+ * @param {function(string, *):any} iteratorFn
  * @returns {function(*, string)}
  */
 export function reverseParams(iteratorFn: (arg0: string, arg1: any) => any): (arg0: any, arg1: string) => any;
@@ -257,7 +257,7 @@ export function baseExtend(dst: any, objs: any, deep: any): any;
  * @param {...Object} src Source object(s).
  * @returns {Object} Reference to `dst`.
  */
-export function extend(dst: any, ...args: any[]): any;
+export function extend(dst: any, ...src: any[]): any;
 /**
  * @module angular
  * @function merge
@@ -293,8 +293,21 @@ export function extend(dst: any, ...args: any[]): any;
  * @returns {Object} Reference to `dst`.
  */
 export function merge(dst: any, ...src: any[]): any;
-export function toInt(str: any): number;
+/**
+ * @param {string} str
+ * @returns {number}
+ */
+export function toInt(str: string): number;
+/**
+ * @param {any} num
+ * @returns {boolean}
+ */
 export function isNumberNaN(num: any): boolean;
+/**
+ * @param {Object} parent
+ * @param {Object} extra
+ * @returns {Object}
+ */
 export function inherit(parent: any, extra: any): any;
 /**
  * @module angular
@@ -349,10 +362,10 @@ export function isElement(node: any): boolean;
  *
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeName)
  *
- * @param {JQLite|Element} element
+ * @param {import('../shared/jqlite/jqlite').JQLite|Element} element
  * @returns
  */
-export function getNodeName(element: JQLite | Element): string;
+export function getNodeName(element: import("../shared/jqlite/jqlite").JQLite | Element): string;
 export function includes(array: any, obj: any): boolean;
 /**
  * Removes the first occurrence of a specified value from an array.

package/types/types.d.ts

@@ -1,5 +1,6 @@
 export type BootstrapConfig = any;
 export type Injectable<T_1> = Function | Array<string | Function>;
+export type CompiledExpression = any | ((arg0: any, arg1: any | undefined) => any);
 export type ComponentOptions = any;
 export type ControllerConstructor = Function;
 export type OnChangesObject = any;

package/types-back/index.d.ts

@@ -782,18 +782,6 @@ declare namespace angular {
     ): void;
   }
 
-  interface ICompiledExpression {
-    (context: any, locals?: any): any;
-
-    literal: boolean;
-    constant: boolean;
-
-    // If value is not provided, undefined is gonna be used since the implementation
-    // does not check the parameter. Let's force a value for consistency. If consumer
-    // whants to undefine it, pass the undefined value explicitly.
-    assign(context: any, value: any): any;
-  }
-
   /**
    * $location - $locationProvider - service in module ng
    * see https://docs.angularjs.org/api/ng/service/$location