@angular/router 0.1.0 → 2.0.0-rc.2

package/src/facade/exception_handler.js

@@ -0,0 +1,133 @@
+"use strict";
+var base_wrapped_exception_1 = require('./base_wrapped_exception');
+var collection_1 = require('./collection');
+var lang_1 = require('./lang');
+var _ArrayLogger = (function () {
+    function _ArrayLogger() {
+        this.res = [];
+    }
+    _ArrayLogger.prototype.log = function (s) { this.res.push(s); };
+    _ArrayLogger.prototype.logError = function (s) { this.res.push(s); };
+    _ArrayLogger.prototype.logGroup = function (s) { this.res.push(s); };
+    _ArrayLogger.prototype.logGroupEnd = function () { };
+    ;
+    return _ArrayLogger;
+}());
+/**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ExceptionHandler` prints error messages to the `Console`. To
+ * intercept error handling,
+ * write a custom exception handler that replaces this default as appropriate for your app.
+ *
+ * ### Example
+ *
+ * ```javascript
+ *
+ * class MyExceptionHandler implements ExceptionHandler {
+ *   call(error, stackTrace = null, reason = null) {
+ *     // do something with the exception
+ *   }
+ * }
+ *
+ * bootstrap(MyApp, {provide: ExceptionHandler, useClass: MyExceptionHandler}])
+ *
+ * ```
+ * @stable
+ */
+var ExceptionHandler = (function () {
+    function ExceptionHandler(_logger, _rethrowException) {
+        if (_rethrowException === void 0) { _rethrowException = true; }
+        this._logger = _logger;
+        this._rethrowException = _rethrowException;
+    }
+    ExceptionHandler.exceptionToString = function (exception, stackTrace, reason) {
+        if (stackTrace === void 0) { stackTrace = null; }
+        if (reason === void 0) { reason = null; }
+        var l = new _ArrayLogger();
+        var e = new ExceptionHandler(l, false);
+        e.call(exception, stackTrace, reason);
+        return l.res.join('\n');
+    };
+    ExceptionHandler.prototype.call = function (exception, stackTrace, reason) {
+        if (stackTrace === void 0) { stackTrace = null; }
+        if (reason === void 0) { reason = null; }
+        var originalException = this._findOriginalException(exception);
+        var originalStack = this._findOriginalStack(exception);
+        var context = this._findContext(exception);
+        this._logger.logGroup("EXCEPTION: " + this._extractMessage(exception));
+        if (lang_1.isPresent(stackTrace) && lang_1.isBlank(originalStack)) {
+            this._logger.logError('STACKTRACE:');
+            this._logger.logError(this._longStackTrace(stackTrace));
+        }
+        if (lang_1.isPresent(reason)) {
+            this._logger.logError("REASON: " + reason);
+        }
+        if (lang_1.isPresent(originalException)) {
+            this._logger.logError("ORIGINAL EXCEPTION: " + this._extractMessage(originalException));
+        }
+        if (lang_1.isPresent(originalStack)) {
+            this._logger.logError('ORIGINAL STACKTRACE:');
+            this._logger.logError(this._longStackTrace(originalStack));
+        }
+        if (lang_1.isPresent(context)) {
+            this._logger.logError('ERROR CONTEXT:');
+            this._logger.logError(context);
+        }
+        this._logger.logGroupEnd();
+        // We rethrow exceptions, so operations like 'bootstrap' will result in an error
+        // when an exception happens. If we do not rethrow, bootstrap will always succeed.
+        if (this._rethrowException)
+            throw exception;
+    };
+    /** @internal */
+    ExceptionHandler.prototype._extractMessage = function (exception) {
+        return exception instanceof base_wrapped_exception_1.BaseWrappedException ? exception.wrapperMessage :
+            exception.toString();
+    };
+    /** @internal */
+    ExceptionHandler.prototype._longStackTrace = function (stackTrace) {
+        return collection_1.isListLikeIterable(stackTrace) ? stackTrace.join('\n\n-----async gap-----\n') :
+            stackTrace.toString();
+    };
+    /** @internal */
+    ExceptionHandler.prototype._findContext = function (exception) {
+        try {
+            if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
+                return null;
+            return lang_1.isPresent(exception.context) ? exception.context :
+                this._findContext(exception.originalException);
+        }
+        catch (e) {
+            // exception.context can throw an exception. if it happens, we ignore the context.
+            return null;
+        }
+    };
+    /** @internal */
+    ExceptionHandler.prototype._findOriginalException = function (exception) {
+        if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
+            return null;
+        var e = exception.originalException;
+        while (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
+            e = e.originalException;
+        }
+        return e;
+    };
+    /** @internal */
+    ExceptionHandler.prototype._findOriginalStack = function (exception) {
+        if (!(exception instanceof base_wrapped_exception_1.BaseWrappedException))
+            return null;
+        var e = exception;
+        var stack = exception.originalStack;
+        while (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
+            e = e.originalException;
+            if (e instanceof base_wrapped_exception_1.BaseWrappedException && lang_1.isPresent(e.originalException)) {
+                stack = e.originalStack;
+            }
+        }
+        return stack;
+    };
+    return ExceptionHandler;
+}());
+exports.ExceptionHandler = ExceptionHandler;
+//# sourceMappingURL=exception_handler.js.map

package/src/facade/exception_handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception_handler.js","sourceRoot":"","sources":["../../../../../modules/@angular/router/src/facade/exception_handler.ts"],"names":[],"mappings":"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","sourcesContent":["import {BaseWrappedException} from './base_wrapped_exception';\nimport {isListLikeIterable} from './collection';\nimport {isBlank, isPresent} from './lang';\n\nclass _ArrayLogger {\n  res: any[] = [];\n  log(s: any): void { this.res.push(s); }\n  logError(s: any): void { this.res.push(s); }\n  logGroup(s: any): void { this.res.push(s); }\n  logGroupEnd(){};\n}\n\n/**\n * Provides a hook for centralized exception handling.\n *\n * The default implementation of `ExceptionHandler` prints error messages to the `Console`. To\n * intercept error handling,\n * write a custom exception handler that replaces this default as appropriate for your app.\n *\n * ### Example\n *\n * ```javascript\n *\n * class MyExceptionHandler implements ExceptionHandler {\n *   call(error, stackTrace = null, reason = null) {\n *     // do something with the exception\n *   }\n * }\n *\n * bootstrap(MyApp, {provide: ExceptionHandler, useClass: MyExceptionHandler}])\n *\n * ```\n * @stable\n */\nexport class ExceptionHandler {\n  constructor(private _logger: any, private _rethrowException: boolean = true) {}\n\n  static exceptionToString(exception: any, stackTrace: any = null, reason: string = null): string {\n    var l = new _ArrayLogger();\n    var e = new ExceptionHandler(l, false);\n    e.call(exception, stackTrace, reason);\n    return l.res.join('\\n');\n  }\n\n  call(exception: any, stackTrace: any = null, reason: string = null): void {\n    var originalException = this._findOriginalException(exception);\n    var originalStack = this._findOriginalStack(exception);\n    var context = this._findContext(exception);\n\n    this._logger.logGroup(`EXCEPTION: ${this._extractMessage(exception)}`);\n\n    if (isPresent(stackTrace) && isBlank(originalStack)) {\n      this._logger.logError('STACKTRACE:');\n      this._logger.logError(this._longStackTrace(stackTrace));\n    }\n\n    if (isPresent(reason)) {\n      this._logger.logError(`REASON: ${reason}`);\n    }\n\n    if (isPresent(originalException)) {\n      this._logger.logError(`ORIGINAL EXCEPTION: ${this._extractMessage(originalException)}`);\n    }\n\n    if (isPresent(originalStack)) {\n      this._logger.logError('ORIGINAL STACKTRACE:');\n      this._logger.logError(this._longStackTrace(originalStack));\n    }\n\n    if (isPresent(context)) {\n      this._logger.logError('ERROR CONTEXT:');\n      this._logger.logError(context);\n    }\n\n    this._logger.logGroupEnd();\n\n    // We rethrow exceptions, so operations like 'bootstrap' will result in an error\n    // when an exception happens. If we do not rethrow, bootstrap will always succeed.\n    if (this._rethrowException) throw exception;\n  }\n\n  /** @internal */\n  _extractMessage(exception: any): string {\n    return exception instanceof BaseWrappedException ? exception.wrapperMessage :\n                                                       exception.toString();\n  }\n\n  /** @internal */\n  _longStackTrace(stackTrace: any): any {\n    return isListLikeIterable(stackTrace) ? (<any[]>stackTrace).join('\\n\\n-----async gap-----\\n') :\n                                            stackTrace.toString();\n  }\n\n  /** @internal */\n  _findContext(exception: any): any {\n    try {\n      if (!(exception instanceof BaseWrappedException)) return null;\n      return isPresent(exception.context) ? exception.context :\n                                            this._findContext(exception.originalException);\n    } catch (e) {\n      // exception.context can throw an exception. if it happens, we ignore the context.\n      return null;\n    }\n  }\n\n  /** @internal */\n  _findOriginalException(exception: any): any {\n    if (!(exception instanceof BaseWrappedException)) return null;\n\n    var e = exception.originalException;\n    while (e instanceof BaseWrappedException && isPresent(e.originalException)) {\n      e = e.originalException;\n    }\n\n    return e;\n  }\n\n  /** @internal */\n  _findOriginalStack(exception: any): any {\n    if (!(exception instanceof BaseWrappedException)) return null;\n\n    var e = exception;\n    var stack = exception.originalStack;\n    while (e instanceof BaseWrappedException && isPresent(e.originalException)) {\n      e = e.originalException;\n      if (e instanceof BaseWrappedException && isPresent(e.originalException)) {\n        stack = e.originalStack;\n      }\n    }\n\n    return stack;\n  }\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/src/facade/exceptions.d.ts

@@ -0,0 +1,32 @@
+import { BaseWrappedException } from './base_wrapped_exception';
+export { ExceptionHandler } from './exception_handler';
+/**
+ * @stable
+ */
+export declare class BaseException extends Error {
+    message: string;
+    stack: any;
+    constructor(message?: string);
+    toString(): string;
+}
+/**
+ * Wraps an exception and provides additional context or information.
+ * @stable
+ */
+export declare class WrappedException extends BaseWrappedException {
+    private _wrapperMessage;
+    private _originalException;
+    private _originalStack;
+    private _context;
+    private _wrapperStack;
+    constructor(_wrapperMessage: string, _originalException: any, _originalStack?: any, _context?: any);
+    wrapperMessage: string;
+    wrapperStack: any;
+    originalException: any;
+    originalStack: any;
+    context: any;
+    message: string;
+    toString(): string;
+}
+export declare function makeTypeError(message?: string): Error;
+export declare function unimplemented(): any;

package/src/facade/exceptions.js

@@ -0,0 +1,82 @@
+"use strict";
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var base_wrapped_exception_1 = require('./base_wrapped_exception');
+var exception_handler_1 = require('./exception_handler');
+var exception_handler_2 = require('./exception_handler');
+exports.ExceptionHandler = exception_handler_2.ExceptionHandler;
+/**
+ * @stable
+ */
+var BaseException = (function (_super) {
+    __extends(BaseException, _super);
+    function BaseException(message) {
+        if (message === void 0) { message = '--'; }
+        _super.call(this, message);
+        this.message = message;
+        this.stack = (new Error(message)).stack;
+    }
+    BaseException.prototype.toString = function () { return this.message; };
+    return BaseException;
+}(Error));
+exports.BaseException = BaseException;
+/**
+ * Wraps an exception and provides additional context or information.
+ * @stable
+ */
+var WrappedException = (function (_super) {
+    __extends(WrappedException, _super);
+    function WrappedException(_wrapperMessage, _originalException /** TODO #9100 */, _originalStack /** TODO #9100 */, _context /** TODO #9100 */) {
+        _super.call(this, _wrapperMessage);
+        this._wrapperMessage = _wrapperMessage;
+        this._originalException = _originalException;
+        this._originalStack = _originalStack;
+        this._context = _context;
+        this._wrapperStack = (new Error(_wrapperMessage)).stack;
+    }
+    Object.defineProperty(WrappedException.prototype, "wrapperMessage", {
+        get: function () { return this._wrapperMessage; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WrappedException.prototype, "wrapperStack", {
+        get: function () { return this._wrapperStack; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WrappedException.prototype, "originalException", {
+        get: function () { return this._originalException; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WrappedException.prototype, "originalStack", {
+        get: function () { return this._originalStack; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WrappedException.prototype, "context", {
+        get: function () { return this._context; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WrappedException.prototype, "message", {
+        get: function () { return exception_handler_1.ExceptionHandler.exceptionToString(this); },
+        enumerable: true,
+        configurable: true
+    });
+    WrappedException.prototype.toString = function () { return this.message; };
+    return WrappedException;
+}(base_wrapped_exception_1.BaseWrappedException));
+exports.WrappedException = WrappedException;
+function makeTypeError(message) {
+    return new TypeError(message);
+}
+exports.makeTypeError = makeTypeError;
+function unimplemented() {
+    throw new BaseException('unimplemented');
+}
+exports.unimplemented = unimplemented;
+//# sourceMappingURL=exceptions.js.map

package/src/facade/exceptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exceptions.js","sourceRoot":"","sources":["../../../../../modules/@angular/router/src/facade/exceptions.ts"],"names":[],"mappings":";;;;;;AAAA,uCAAmC,0BAA0B,CAAC,CAAA;AAC9D,kCAA+B,qBAAqB,CAAC,CAAA;AAErD,kCAA+B,qBAAqB,CAAC;AAA7C,gEAA6C;AAErD;;GAEG;AACH;IAAmC,iCAAK;IAEtC,uBAAmB,OAAsB;QAA7B,uBAA6B,GAA7B,cAA6B;QACvC,kBAAM,OAAO,CAAC,CAAC;QADE,YAAO,GAAP,OAAO,CAAe;QAEvC,IAAI,CAAC,KAAK,GAAG,CAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/C,CAAC;IAED,gCAAQ,GAAR,cAAqB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7C,oBAAC;AAAD,CAAC,AARD,CAAmC,KAAK,GAQvC;AARY,qBAAa,gBAQzB,CAAA;AAED;;;GAGG;AACH;IAAsC,oCAAoB;IAGxD,0BACY,eAAuB,EAAU,kBAAuB,CAAC,iBAAiB,EAC1E,cAAoB,CAAC,iBAAiB,EAAU,QAAc,CAAC,iBAAiB;QAC1F,kBAAM,eAAe,CAAC,CAAC;QAFb,oBAAe,GAAf,eAAe,CAAQ;QAAU,uBAAkB,GAAlB,kBAAkB,CAAK;QACxD,mBAAc,GAAd,cAAc,CAAM;QAA4B,aAAQ,GAAR,QAAQ,CAAM;QAExE,IAAI,CAAC,aAAa,GAAG,CAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC;IAC/D,CAAC;IAED,sBAAI,4CAAc;aAAlB,cAA+B,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;;;OAAA;IAE7D,sBAAI,0CAAY;aAAhB,cAA0B,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;;;OAAA;IAGtD,sBAAI,+CAAiB;aAArB,cAA+B,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;;;OAAA;IAEhE,sBAAI,2CAAa;aAAjB,cAA2B,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;;;OAAA;IAGxD,sBAAI,qCAAO;aAAX,cAAqB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;;;OAAA;IAE5C,sBAAI,qCAAO;aAAX,cAAwB,MAAM,CAAC,oCAAgB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;;OAAA;IAE1E,mCAAQ,GAAR,cAAqB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7C,uBAAC;AAAD,CAAC,AAzBD,CAAsC,6CAAoB,GAyBzD;AAzBY,wBAAgB,mBAyB5B,CAAA;AAED,uBAA8B,OAAgB;IAC5C,MAAM,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC;AAChC,CAAC;AAFe,qBAAa,gBAE5B,CAAA;AAED;IACE,MAAM,IAAI,aAAa,CAAC,eAAe,CAAC,CAAC;AAC3C,CAAC;AAFe,qBAAa,gBAE5B,CAAA","sourcesContent":["import {BaseWrappedException} from './base_wrapped_exception';\nimport {ExceptionHandler} from './exception_handler';\n\nexport {ExceptionHandler} from './exception_handler';\n\n/**\n * @stable\n */\nexport class BaseException extends Error {\n  public stack: any;\n  constructor(public message: string = '--') {\n    super(message);\n    this.stack = (<any>new Error(message)).stack;\n  }\n\n  toString(): string { return this.message; }\n}\n\n/**\n * Wraps an exception and provides additional context or information.\n * @stable\n */\nexport class WrappedException extends BaseWrappedException {\n  private _wrapperStack: any;\n\n  constructor(\n      private _wrapperMessage: string, private _originalException: any /** TODO #9100 */,\n      private _originalStack?: any /** TODO #9100 */, private _context?: any /** TODO #9100 */) {\n    super(_wrapperMessage);\n    this._wrapperStack = (<any>new Error(_wrapperMessage)).stack;\n  }\n\n  get wrapperMessage(): string { return this._wrapperMessage; }\n\n  get wrapperStack(): any { return this._wrapperStack; }\n\n\n  get originalException(): any { return this._originalException; }\n\n  get originalStack(): any { return this._originalStack; }\n\n\n  get context(): any { return this._context; }\n\n  get message(): string { return ExceptionHandler.exceptionToString(this); }\n\n  toString(): string { return this.message; }\n}\n\nexport function makeTypeError(message?: string): Error {\n  return new TypeError(message);\n}\n\nexport function unimplemented(): any {\n  throw new BaseException('unimplemented');\n}\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/src/facade/exceptions.metadata.json

@@ -0,0 +1 @@
+{"__symbolic":"module","version":1,"metadata":{"makeTypeError":{"__symbolic":"function","parameters":["message"],"value":{"__symbolic":"new","expression":{"__symbolic":"reference","name":"TypeError"},"arguments":[{"__symbolic":"reference","name":"message"}]}}}}

package/src/facade/lang.d.ts

@@ -0,0 +1,158 @@
+export interface BrowserNodeGlobal {
+    Object: typeof Object;
+    Array: typeof Array;
+    Map: typeof Map;
+    Set: typeof Set;
+    Date: DateConstructor;
+    RegExp: RegExpConstructor;
+    JSON: typeof JSON;
+    Math: any;
+    assert(condition: any): void;
+    Reflect: any;
+    getAngularTestability: Function;
+    getAllAngularTestabilities: Function;
+    getAllAngularRootElements: Function;
+    frameworkStabilizers: Array<Function>;
+    setTimeout: Function;
+    clearTimeout: Function;
+    setInterval: Function;
+    clearInterval: Function;
+    encodeURI: Function;
+}
+export declare function scheduleMicroTask(fn: Function): void;
+export declare const IS_DART: boolean;
+declare var _global: BrowserNodeGlobal;
+export { _global as global };
+export declare var Type: FunctionConstructor;
+/**
+ * Runtime representation a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+ * the `MyCustomComponent` constructor function.
+ */
+export interface Type extends Function {
+}
+/**
+ * Runtime representation of a type that is constructable (non-abstract).
+ */
+export interface ConcreteType extends Type {
+    new (...args: any[]): any;
+}
+export declare function getTypeNameForDebugging(type: Type): string;
+export declare var Math: any;
+export declare var Date: DateConstructor;
+export declare function lockMode(): void;
+/**
+ * Disable Angular's development mode, which turns off assertions and other
+ * checks within the framework.
+ *
+ * One important assertion this disables verifies that a change detection pass
+ * does not result in additional changes to any bindings (also known as
+ * unidirectional data flow).
+ * @stable
+ */
+export declare function enableProdMode(): void;
+export declare function assertionsEnabled(): boolean;
+export declare function isPresent(obj: any): boolean;
+export declare function isBlank(obj: any): boolean;
+export declare function isBoolean(obj: any): boolean;
+export declare function isNumber(obj: any): boolean;
+export declare function isString(obj: any): obj is String;
+export declare function isFunction(obj: any): boolean;
+export declare function isType(obj: any): boolean;
+export declare function isStringMap(obj: any): boolean;
+export declare function isStrictStringMap(obj: any): boolean;
+export declare function isPromise(obj: any): boolean;
+export declare function isArray(obj: any): boolean;
+export declare function isDate(obj: any): obj is Date;
+export declare function noop(): void;
+export declare function stringify(token: any): string;
+export declare function serializeEnum(val: any): number;
+export declare function deserializeEnum(val: any, values: Map<number, any>): any;
+export declare function resolveEnumToken(enumValue: any, val: any): string;
+export declare class StringWrapper {
+    static fromCharCode(code: number): string;
+    static charCodeAt(s: string, index: number): number;
+    static split(s: string, regExp: RegExp): string[];
+    static equals(s: string, s2: string): boolean;
+    static stripLeft(s: string, charVal: string): string;
+    static stripRight(s: string, charVal: string): string;
+    static replace(s: string, from: string, replace: string): string;
+    static replaceAll(s: string, from: RegExp, replace: string): string;
+    static slice<T>(s: string, from?: number, to?: number): string;
+    static replaceAllMapped(s: string, from: RegExp, cb: Function): string;
+    static contains(s: string, substr: string): boolean;
+    static compare(a: string, b: string): number;
+}
+export declare class StringJoiner {
+    parts: string[];
+    constructor(parts?: string[]);
+    add(part: string): void;
+    toString(): string;
+}
+export declare class NumberParseError extends Error {
+    message: string;
+    name: string;
+    constructor(message: string);
+    toString(): string;
+}
+export declare class NumberWrapper {
+    static toFixed(n: number, fractionDigits: number): string;
+    static equal(a: number, b: number): boolean;
+    static parseIntAutoRadix(text: string): number;
+    static parseInt(text: string, radix: number): number;
+    static parseFloat(text: string): number;
+    static NaN: number;
+    static isNaN(value: any): boolean;
+    static isInteger(value: any): boolean;
+}
+export declare var RegExp: RegExpConstructor;
+export declare class RegExpWrapper {
+    static create(regExpStr: string, flags?: string): RegExp;
+    static firstMatch(regExp: RegExp, input: string): RegExpExecArray;
+    static test(regExp: RegExp, input: string): boolean;
+    static matcher(regExp: RegExp, input: string): {
+        re: RegExp;
+        input: string;
+    };
+    static replaceAll(regExp: RegExp, input: string, replace: Function): string;
+}
+export declare class RegExpMatcherWrapper {
+    static next(matcher: {
+        re: RegExp;
+        input: string;
+    }): RegExpExecArray;
+}
+export declare class FunctionWrapper {
+    static apply(fn: Function, posArgs: any): any;
+    static bind(fn: Function, scope: any): Function;
+}
+export declare function looseIdentical(a: any, b: any): boolean;
+export declare function getMapKey<T>(value: T): T;
+export declare function normalizeBlank(obj: Object): any;
+export declare function normalizeBool(obj: boolean): boolean;
+export declare function isJsObject(o: any): boolean;
+export declare function print(obj: Error | Object): void;
+export declare function warn(obj: Error | Object): void;
+export declare class Json {
+    static parse(s: string): Object;
+    static stringify(data: Object): string;
+}
+export declare class DateWrapper {
+    static create(year: number, month?: number, day?: number, hour?: number, minutes?: number, seconds?: number, milliseconds?: number): Date;
+    static fromISOString(str: string): Date;
+    static fromMillis(ms: number): Date;
+    static toMillis(date: Date): number;
+    static now(): Date;
+    static toJson(date: Date): string;
+}
+export declare function setValueOnPath(global: any, path: string, value: any): void;
+export declare function getSymbolIterator(): string | symbol;
+export declare function evalExpression(sourceUrl: string, expr: string, declarations: string, vars: {
+    [key: string]: any;
+}): any;
+export declare function isPrimitive(obj: any): boolean;
+export declare function hasConstructor(value: Object, type: Type): boolean;
+export declare function bitWiseOr(values: number[]): number;
+export declare function bitWiseAnd(values: number[]): number;
+export declare function escape(s: string): string;