@angular-devkit/core 0.0.14 → 0.0.15

package/src/logger/logger.js

@@ -51,6 +51,22 @@ class Logger extends Observable_1.Observable {
             });
         }
     }
+    asApi() {
+        return {
+            createChild: (name) => this.createChild(name),
+            log: (level, message, metadata) => {
+                return this.log(level, message, metadata);
+            },
+            debug: (message, metadata) => this.debug(message, metadata),
+            info: (message, metadata) => this.info(message, metadata),
+            warn: (message, metadata) => this.warn(message, metadata),
+            error: (message, metadata) => this.error(message, metadata),
+            fatal: (message, metadata) => this.fatal(message, metadata),
+        };
+    }
+    createChild(name) {
+        return new Logger(name, this);
+    }
     complete() {
         this._subject.complete();
     }
@@ -89,4 +105,4 @@ class Logger extends Observable_1.Observable {
     }
 }
 exports.Logger = Logger;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"/Users/hansl/Sources/devkit/","sources":["packages/angular_devkit/core/src/logger/logger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Observable } from 'rxjs/Observable';\nimport { PartialObserver } from 'rxjs/Observer';\nimport { Operator } from 'rxjs/Operator';\nimport { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { JsonObject } from '../json/interface';\n\n\nexport interface LoggerMetadata extends JsonObject {\n  name: string;\n  path: string[];\n}\nexport interface LogEntry extends LoggerMetadata {\n  level: LogLevel;\n  message: string;\n  timestamp: number;\n}\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';\n\n\nexport class Logger extends Observable<LogEntry> {\n  protected readonly _subject: Subject<LogEntry> = new Subject<LogEntry>();\n  protected _metadata: LoggerMetadata;\n\n  private _obs: Observable<LogEntry>;\n  private _subscription: Subscription | null;\n\n  protected get _observable() { return this._obs; }\n  protected set _observable(v: Observable<LogEntry>) {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n    }\n    this._obs = v;\n    if (this.parent) {\n      this._subscription = this.subscribe((value: LogEntry) => {\n        if (this.parent) {\n          this.parent._subject.next(value);\n        }\n      }, (error: Error) => {\n        if (this.parent) {\n          this.parent._subject.error(error);\n        }\n      }, () => {\n        if (this._subscription) {\n          this._subscription.unsubscribe();\n        }\n        this._subscription = null;\n      });\n    }\n  }\n\n  constructor(public readonly name: string, public readonly parent: Logger | null = null) {\n    super();\n\n    const path: string[] = [];\n    let p = parent;\n    while (p) {\n      path.push(p.name);\n      p = p.parent;\n    }\n    this._metadata = { name, path };\n    this._observable = this._subject.asObservable();\n    if (this.parent) {\n      // When the parent completes, complete us as well.\n      this.parent._subject.subscribe(undefined, undefined, () => this.complete());\n    }\n  }\n\n  complete() {\n    this._subject.complete();\n  }\n\n  log(level: LogLevel, message: string, metadata: JsonObject = {}): void {\n    const entry: LogEntry = Object.assign({}, this._metadata, metadata, {\n      level, message, timestamp: +Date.now(),\n    });\n    this._subject.next(entry);\n  }\n\n  debug(message: string, metadata: JsonObject = {}) {\n    return this.log('debug', message, metadata);\n  }\n  info(message: string, metadata: JsonObject = {}) {\n    return this.log('info', message, metadata);\n  }\n  warn(message: string, metadata: JsonObject = {}) {\n    return this.log('warn', message, metadata);\n  }\n  error(message: string, metadata: JsonObject = {}) {\n    return this.log('error', message, metadata);\n  }\n  fatal(message: string, metadata: JsonObject = {}) {\n    return this.log('fatal', message, metadata);\n  }\n\n  toString() {\n    return `<Logger(${this.name})>`;\n  }\n\n  lift(operator: Operator<LogEntry, LogEntry>): Observable<LogEntry> {\n    return this._observable.lift(operator);\n  }\n\n  subscribe(): Subscription;\n  subscribe(observer: PartialObserver<LogEntry>): Subscription;\n  subscribe(next?: (value: LogEntry) => void, error?: (error: Error) => void,\n            complete?: () => void): Subscription;\n  subscribe(_observerOrNext?: PartialObserver<LogEntry> | ((value: LogEntry) => void),\n            _error?: (error: Error) => void,\n            _complete?: () => void): Subscription {\n    return this._observable.subscribe.apply(this._observable, arguments);\n  }\n  forEach(next: (value: LogEntry) => void, PromiseCtor?: typeof Promise): Promise<void> {\n    return this._observable.forEach(next, PromiseCtor);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"/Users/hansl/Sources/devkit/","sources":["packages/angular_devkit/core/src/logger/logger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Observable } from 'rxjs/Observable';\nimport { PartialObserver } from 'rxjs/Observer';\nimport { Operator } from 'rxjs/Operator';\nimport { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { JsonObject } from '../json/interface';\n\n\nexport interface LoggerMetadata extends JsonObject {\n  name: string;\n  path: string[];\n}\nexport interface LogEntry extends LoggerMetadata {\n  level: LogLevel;\n  message: string;\n  timestamp: number;\n}\nexport interface LoggerApi {\n  createChild(name: string): Logger;\n  log(level: LogLevel, message: string, metadata?: JsonObject): void;\n  debug(message: string, metadata?: JsonObject): void;\n  info(message: string, metadata?: JsonObject): void;\n  warn(message: string, metadata?: JsonObject): void;\n  error(message: string, metadata?: JsonObject): void;\n  fatal(message: string, metadata?: JsonObject): void;\n}\n\nexport type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'fatal';\n\n\nexport class Logger extends Observable<LogEntry> implements LoggerApi {\n  protected readonly _subject: Subject<LogEntry> = new Subject<LogEntry>();\n  protected _metadata: LoggerMetadata;\n\n  private _obs: Observable<LogEntry>;\n  private _subscription: Subscription | null;\n\n  protected get _observable() { return this._obs; }\n  protected set _observable(v: Observable<LogEntry>) {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n    }\n    this._obs = v;\n    if (this.parent) {\n      this._subscription = this.subscribe((value: LogEntry) => {\n        if (this.parent) {\n          this.parent._subject.next(value);\n        }\n      }, (error: Error) => {\n        if (this.parent) {\n          this.parent._subject.error(error);\n        }\n      }, () => {\n        if (this._subscription) {\n          this._subscription.unsubscribe();\n        }\n        this._subscription = null;\n      });\n    }\n  }\n\n  constructor(public readonly name: string, public readonly parent: Logger | null = null) {\n    super();\n\n    const path: string[] = [];\n    let p = parent;\n    while (p) {\n      path.push(p.name);\n      p = p.parent;\n    }\n    this._metadata = { name, path };\n    this._observable = this._subject.asObservable();\n    if (this.parent) {\n      // When the parent completes, complete us as well.\n      this.parent._subject.subscribe(undefined, undefined, () => this.complete());\n    }\n  }\n\n  asApi(): LoggerApi {\n    return {\n      createChild: (name: string) => this.createChild(name),\n      log: (level: LogLevel, message: string, metadata?: JsonObject) => {\n        return this.log(level, message, metadata);\n      },\n      debug: (message: string, metadata?: JsonObject) => this.debug(message, metadata),\n      info: (message: string, metadata?: JsonObject) => this.info(message, metadata),\n      warn: (message: string, metadata?: JsonObject) => this.warn(message, metadata),\n      error: (message: string, metadata?: JsonObject) => this.error(message, metadata),\n      fatal: (message: string, metadata?: JsonObject) => this.fatal(message, metadata),\n    };\n  }\n\n  createChild(name: string) {\n    return new Logger(name, this);\n  }\n\n  complete() {\n    this._subject.complete();\n  }\n\n  log(level: LogLevel, message: string, metadata: JsonObject = {}): void {\n    const entry: LogEntry = Object.assign({}, this._metadata, metadata, {\n      level, message, timestamp: +Date.now(),\n    });\n    this._subject.next(entry);\n  }\n\n  debug(message: string, metadata: JsonObject = {}) {\n    return this.log('debug', message, metadata);\n  }\n  info(message: string, metadata: JsonObject = {}) {\n    return this.log('info', message, metadata);\n  }\n  warn(message: string, metadata: JsonObject = {}) {\n    return this.log('warn', message, metadata);\n  }\n  error(message: string, metadata: JsonObject = {}) {\n    return this.log('error', message, metadata);\n  }\n  fatal(message: string, metadata: JsonObject = {}) {\n    return this.log('fatal', message, metadata);\n  }\n\n  toString() {\n    return `<Logger(${this.name})>`;\n  }\n\n  lift(operator: Operator<LogEntry, LogEntry>): Observable<LogEntry> {\n    return this._observable.lift(operator);\n  }\n\n  subscribe(): Subscription;\n  subscribe(observer: PartialObserver<LogEntry>): Subscription;\n  subscribe(next?: (value: LogEntry) => void, error?: (error: Error) => void,\n            complete?: () => void): Subscription;\n  subscribe(_observerOrNext?: PartialObserver<LogEntry> | ((value: LogEntry) => void),\n            _error?: (error: Error) => void,\n            _complete?: () => void): Subscription {\n    return this._observable.subscribe.apply(this._observable, arguments);\n  }\n  forEach(next: (value: LogEntry) => void, PromiseCtor?: typeof Promise): Promise<void> {\n    return this._observable.forEach(next, PromiseCtor);\n  }\n}\n"]}

package/src/logger/null-logger.d.ts

@@ -1,5 +1,6 @@
 import 'rxjs/add/observable/empty';
-import { Logger } from './logger';
+import { Logger, LoggerApi } from './logger';
 export declare class NullLogger extends Logger {
     constructor(parent?: Logger | null);
+    asApi(): LoggerApi;
 }

package/src/logger/null-logger.js

@@ -15,6 +15,17 @@ class NullLogger extends logger_1.Logger {
         super('', parent);
         this._observable = Observable_1.Observable.empty();
     }
+    asApi() {
+        return {
+            createChild: () => new NullLogger(this),
+            log() { },
+            debug() { },
+            info() { },
+            warn() { },
+            error() { },
+            fatal() { },
+        };
+    }
 }
 exports.NullLogger = NullLogger;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbC1sb2dnZXIuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvbG9nZ2VyL251bGwtbG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7Ozs7OztHQU1HO0FBQ0gsZ0RBQTZDO0FBQzdDLHFDQUFtQztBQUNuQyxxQ0FBa0M7QUFHbEMsZ0JBQXdCLFNBQVEsZUFBTTtJQUNwQyxZQUFZLFNBQXdCLElBQUk7UUFDdEMsS0FBSyxDQUFDLEVBQUUsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNsQixJQUFJLENBQUMsV0FBVyxHQUFHLHVCQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDeEMsQ0FBQztDQUNGO0FBTEQsZ0NBS0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcy9PYnNlcnZhYmxlJztcbmltcG9ydCAncnhqcy9hZGQvb2JzZXJ2YWJsZS9lbXB0eSc7XG5pbXBvcnQgeyBMb2dnZXIgfSBmcm9tICcuL2xvZ2dlcic7XG5cblxuZXhwb3J0IGNsYXNzIE51bGxMb2dnZXIgZXh0ZW5kcyBMb2dnZXIge1xuICBjb25zdHJ1Y3RvcihwYXJlbnQ6IExvZ2dlciB8IG51bGwgPSBudWxsKSB7XG4gICAgc3VwZXIoJycsIHBhcmVudCk7XG4gICAgdGhpcy5fb2JzZXJ2YWJsZSA9IE9ic2VydmFibGUuZW1wdHkoKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVsbC1sb2dnZXIuanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvbG9nZ2VyL251bGwtbG9nZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7Ozs7OztHQU1HO0FBQ0gsZ0RBQTZDO0FBQzdDLHFDQUFtQztBQUNuQyxxQ0FBNkM7QUFHN0MsZ0JBQXdCLFNBQVEsZUFBTTtJQUNwQyxZQUFZLFNBQXdCLElBQUk7UUFDdEMsS0FBSyxDQUFDLEVBQUUsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNsQixJQUFJLENBQUMsV0FBVyxHQUFHLHVCQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDeEMsQ0FBQztJQUVELEtBQUs7UUFDSCxNQUFNLENBQUM7WUFDTCxXQUFXLEVBQUUsTUFBTSxJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUM7WUFDdkMsR0FBRyxLQUFJLENBQUM7WUFDUixLQUFLLEtBQUksQ0FBQztZQUNWLElBQUksS0FBSSxDQUFDO1lBQ1QsSUFBSSxLQUFJLENBQUM7WUFDVCxLQUFLLEtBQUksQ0FBQztZQUNWLEtBQUssS0FBSSxDQUFDO1NBQ0UsQ0FBQztJQUNqQixDQUFDO0NBQ0Y7QUFqQkQsZ0NBaUJDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMvT2JzZXJ2YWJsZSc7XG5pbXBvcnQgJ3J4anMvYWRkL29ic2VydmFibGUvZW1wdHknO1xuaW1wb3J0IHsgTG9nZ2VyLCBMb2dnZXJBcGkgfSBmcm9tICcuL2xvZ2dlcic7XG5cblxuZXhwb3J0IGNsYXNzIE51bGxMb2dnZXIgZXh0ZW5kcyBMb2dnZXIge1xuICBjb25zdHJ1Y3RvcihwYXJlbnQ6IExvZ2dlciB8IG51bGwgPSBudWxsKSB7XG4gICAgc3VwZXIoJycsIHBhcmVudCk7XG4gICAgdGhpcy5fb2JzZXJ2YWJsZSA9IE9ic2VydmFibGUuZW1wdHkoKTtcbiAgfVxuXG4gIGFzQXBpKCk6IExvZ2dlckFwaSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIGNyZWF0ZUNoaWxkOiAoKSA9PiBuZXcgTnVsbExvZ2dlcih0aGlzKSxcbiAgICAgIGxvZygpIHt9LFxuICAgICAgZGVidWcoKSB7fSxcbiAgICAgIGluZm8oKSB7fSxcbiAgICAgIHdhcm4oKSB7fSxcbiAgICAgIGVycm9yKCkge30sXG4gICAgICBmYXRhbCgpIHt9LFxuICAgIH0gYXMgTG9nZ2VyQXBpO1xuICB9XG59XG4iXX0=

package/src/utils/index.d.ts

@@ -5,5 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import * as tags from './literals';
 export * from './object';
 export * from './strings';
+export * from './template';
+export { tags };

package/src/utils/index.js

@@ -10,6 +10,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+const tags = require("./literals");
+exports.tags = tags;
 __export(require("./object"));
 __export(require("./strings"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTs7Ozs7O0dBTUc7QUFDSCw4QkFBeUI7QUFDekIsK0JBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuZXhwb3J0ICogZnJvbSAnLi9vYmplY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9zdHJpbmdzJztcbiJdfQ==
+__export(require("./template"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiL1VzZXJzL2hhbnNsL1NvdXJjZXMvZGV2a2l0LyIsInNvdXJjZXMiOlsicGFja2FnZXMvYW5ndWxhcl9kZXZraXQvY29yZS9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQTs7Ozs7O0dBTUc7QUFDSCxtQ0FBbUM7QUFLMUIsb0JBQUk7QUFKYiw4QkFBeUI7QUFDekIsK0JBQTBCO0FBQzFCLGdDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCAqIGFzIHRhZ3MgZnJvbSAnLi9saXRlcmFscyc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdCc7XG5leHBvcnQgKiBmcm9tICcuL3N0cmluZ3MnO1xuZXhwb3J0ICogZnJvbSAnLi90ZW1wbGF0ZSc7XG5cbmV4cG9ydCB7IHRhZ3MgfTtcbiJdfQ==

package/src/utils/literals.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export declare type TemplateTag = (template: TemplateStringsArray, ...substitutions: any[]) => string;
+export declare function oneLine(strings: TemplateStringsArray, ...values: any[]): string;
+export declare function indentBy(indentations: number): TemplateTag;
+export declare function stripIndent(strings: TemplateStringsArray, ...values: any[]): string;
+export declare function stripIndents(strings: TemplateStringsArray, ...values: any[]): string;

package/src/utils/literals.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable-next-line:no-any
+function oneLine(strings, ...values) {
+    const endResult = String.raw(strings, ...values);
+    return endResult.replace(/(?:\n(?:\s*))+/gm, ' ').trim();
+}
+exports.oneLine = oneLine;
+function indentBy(indentations) {
+    let i = '';
+    while (indentations--) {
+        i += ' ';
+    }
+    return (strings, ...values) => {
+        return i + stripIndent(strings, ...values).replace(/\n/g, '\n' + i);
+    };
+}
+exports.indentBy = indentBy;
+// tslint:disable-next-line:no-any
+function stripIndent(strings, ...values) {
+    const endResult = String.raw(strings, ...values);
+    // remove the shortest leading indentation from each line
+    const match = endResult.match(/^[ \t]*(?=\S)/gm);
+    // return early if there's nothing to strip
+    if (match === null) {
+        return endResult;
+    }
+    const indent = Math.min(...match.map(el => el.length));
+    const regexp = new RegExp('^[ \\t]{' + indent + '}', 'gm');
+    return (indent > 0 ? endResult.replace(regexp, '') : endResult).trim();
+}
+exports.stripIndent = stripIndent;
+// tslint:disable-next-line:no-any
+function stripIndents(strings, ...values) {
+    return String.raw(strings, ...values)
+        .split('\n')
+        .map(line => line.trim())
+        .join('\n')
+        .trim();
+}
+exports.stripIndents = stripIndents;
+//# sourceMappingURL=data:application/json;base64,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

package/src/utils/template.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Position } from 'source-map';
+export interface TemplateOptions {
+    sourceURL?: string;
+    sourceMap?: boolean;
+    module?: boolean | {
+        exports: {};
+    };
+    sourceRoot?: string;
+    fileName?: string;
+}
+/**
+ * A simple AST for templates. There's only one level of AST nodes, but it's still useful
+ * to have the information you're looking for.
+ */
+export interface TemplateAst {
+    fileName: string;
+    content: string;
+    children: TemplateAstNode[];
+}
+/**
+ * The base, which contains positions.
+ */
+export interface TemplateAstBase {
+    start: Position;
+    end: Position;
+}
+/**
+ * A static content node.
+ */
+export interface TemplateAstContent extends TemplateAstBase {
+    kind: 'content';
+    content: string;
+}
+/**
+ * An evaluate node, which is the code between `<% ... %>`.
+ */
+export interface TemplateAstEvaluate extends TemplateAstBase {
+    kind: 'evaluate';
+    expression: string;
+}
+/**
+ * An escape node, which is the code between `<%- ... %>`.
+ */
+export interface TemplateAstEscape extends TemplateAstBase {
+    kind: 'escape';
+    expression: string;
+}
+/**
+ * An interpolation node, which is the code between `<%= ... %>`.
+ */
+export interface TemplateAstInterpolate extends TemplateAstBase {
+    kind: 'interpolate';
+    expression: string;
+}
+export declare type TemplateAstNode = TemplateAstContent | TemplateAstEvaluate | TemplateAstEscape | TemplateAstInterpolate;
+/**
+ * Given a source text (and a fileName), returns a TemplateAst.
+ */
+export declare function templateParser(sourceText: string, fileName: string): TemplateAst;
+/**
+ * An equivalent of EJS templates, which is based on John Resig's `tmpl` implementation
+ * (http://ejohn.org/blog/javascript-micro-templating/) and Laura Doktorova's doT.js
+ * (https://github.com/olado/doT).
+ *
+ * This version differs from lodash by removing support from ES6 quasi-literals, and making the
+ * code slightly simpler to follow. It also does not depend on any third party, which is nice.
+ *
+ * Finally, it supports SourceMap, if you ever need to debug, which is super nice.
+ *
+ * @param content The template content.
+ * @param options Optional Options. See TemplateOptions for more description.
+ * @return {(input: T) => string} A function that accept an input object and returns the content
+ *         of the template with the input applied.
+ */
+export declare function template<T>(content: string, options?: TemplateOptions): (input: T) => string;

package/src/utils/template.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const source_map_1 = require("source-map");
+// Matches <%= expr %>. This does not support structural JavaScript (for/if/...).
+const kInterpolateRe = /<%=([\s\S]+?)%>/g;
+// Used to match template delimiters.
+// <%- expr %>: HTML escape the value.
+// <% ... %>: Structural template code.
+const kEscapeRe = /<%-([\s\S]+?)%>/g;
+const kEvaluateRe = /<%([\s\S]+?)%>/g;
+/** Used to map characters to HTML entities. */
+const kHtmlEscapes = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '`': '&#96;',
+};
+// Used to match HTML entities and HTML characters.
+const reUnescapedHtml = new RegExp(`[${Object.keys(kHtmlEscapes).join('')}]`, 'g');
+function _positionFor(content, offset) {
+    let line = 1;
+    let column = 0;
+    for (let i = 0; i < offset - 1; i++) {
+        if (content[i] == '\n') {
+            line++;
+            column = 0;
+        }
+        else {
+            column++;
+        }
+    }
+    return {
+        line,
+        column,
+    };
+}
+/**
+ * Given a source text (and a fileName), returns a TemplateAst.
+ */
+function templateParser(sourceText, fileName) {
+    const children = [];
+    // Compile the regexp to match each delimiter.
+    const reDelimiters = RegExp(`${kEscapeRe.source}|${kInterpolateRe.source}|${kEvaluateRe.source}|$`, 'g');
+    const parsed = sourceText.split(reDelimiters);
+    let offset = 0;
+    // Optimization that uses the fact that the end of a node is always the beginning of the next
+    // node, so we keep the positioning of the nodes in memory.
+    let start = _positionFor(sourceText, offset);
+    let end = null;
+    for (let i = 0; i < parsed.length; i += 4) {
+        const [content, escape, interpolate, evaluate] = parsed.slice(i, i + 4);
+        if (content) {
+            end = _positionFor(sourceText, offset + content.length);
+            offset += content.length;
+            children.push({ kind: 'content', content, start, end });
+            start = end;
+        }
+        if (escape) {
+            end = _positionFor(sourceText, offset + escape.length + 5);
+            offset += escape.length + 5;
+            children.push({ kind: 'escape', expression: escape, start, end });
+            start = end;
+        }
+        if (interpolate) {
+            end = _positionFor(sourceText, offset + interpolate.length + 5);
+            offset += interpolate.length + 5;
+            children.push({
+                kind: 'interpolate',
+                expression: interpolate,
+                start,
+                end,
+            });
+            start = end;
+        }
+        if (evaluate) {
+            end = _positionFor(sourceText, offset + evaluate.length + 5);
+            offset += evaluate.length + 5;
+            children.push({ kind: 'evaluate', expression: evaluate, start, end });
+            start = end;
+        }
+    }
+    return {
+        fileName,
+        content: sourceText,
+        children,
+    };
+}
+exports.templateParser = templateParser;
+/**
+ * Fastest implementation of the templating algorithm. It only add strings and does not bother
+ * with source maps.
+ */
+function templateFast(ast, options) {
+    const module = options && options.module ? 'module.exports.default =' : '';
+    const reHtmlEscape = reUnescapedHtml.source.replace(/[']/g, '\\\\\\\'');
+    return `
+    return ${module} function(obj) {
+      obj || (obj = {});
+      let __t;
+      let __p = '';
+      const __escapes = ${JSON.stringify(kHtmlEscapes)};
+      const __escapesre = new RegExp('${reHtmlEscape}', 'g');
+
+      const __e = function(s) {
+        return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';
+      };
+      with (obj) {
+        ${ast.children.map(node => {
+        switch (node.kind) {
+            case 'content':
+                return `__p += ${JSON.stringify(node.content)};`;
+            case 'interpolate':
+                return `__p += ((__t = (${node.expression})) == null) ? '' : __t;`;
+            case 'escape':
+                return `__p += __e(${node.expression});`;
+            case 'evaluate':
+                return node.expression;
+        }
+    }).join('\n')}
+      }
+
+      return __p;
+    };
+  `;
+}
+/**
+ * Templating algorithm with source map support. The map is outputted as //# sourceMapUrl=...
+ */
+function templateWithSourceMap(ast, options) {
+    const sourceUrl = ast.fileName;
+    const module = options && options.module ? 'module.exports.default =' : '';
+    const reHtmlEscape = reUnescapedHtml.source.replace(/[']/g, '\\\\\\\'');
+    const preamble = (new source_map_1.SourceNode(1, 0, sourceUrl, ''))
+        .add(new source_map_1.SourceNode(1, 0, sourceUrl, [
+        `return ${module} function(obj) {\n`,
+        '  obj || (obj = {});\n',
+        '  let __t;\n',
+        '  let __p = "";\n',
+        `  const __escapes = ${JSON.stringify(kHtmlEscapes)};\n`,
+        `  const __escapesre = new RegExp('${reHtmlEscape}', 'g');\n`,
+        `\n`,
+        `  const __e = function(s) { `,
+        `    return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';`,
+        `  };\n`,
+        `  with (obj) {\n`,
+    ]));
+    const end = ast.children.length
+        ? ast.children[ast.children.length - 1].end
+        : { line: 0, column: 0 };
+    const nodes = ast.children.reduce((chunk, node) => {
+        let code = '';
+        switch (node.kind) {
+            case 'content':
+                code = [
+                    new source_map_1.SourceNode(node.start.line, node.start.column, sourceUrl, '__p = __p'),
+                    ...node.content.split('\n').map((line, i, arr) => {
+                        return new source_map_1.SourceNode(node.start.line + i, i == 0 ? node.start.column : 0, sourceUrl, '\n    + '
+                            + JSON.stringify(line + (i == arr.length - 1 ? '' : '\n')));
+                    }),
+                    new source_map_1.SourceNode(node.end.line, node.end.column, sourceUrl, ';\n'),
+                ];
+                break;
+            case 'interpolate':
+                code = [
+                    new source_map_1.SourceNode(node.start.line, node.start.column, sourceUrl, '__p += ((__t = '),
+                    ...node.expression.split('\n').map((line, i, arr) => {
+                        return new source_map_1.SourceNode(node.start.line + i, i == 0 ? node.start.column : 0, sourceUrl, line + ((i == arr.length - 1) ? '' : '\n'));
+                    }),
+                    new source_map_1.SourceNode(node.end.line, node.end.column, sourceUrl, ') == null ? "" : __t);\n'),
+                ];
+                break;
+            case 'escape':
+                code = [
+                    new source_map_1.SourceNode(node.start.line, node.start.column, sourceUrl, '__p += __e('),
+                    ...node.expression.split('\n').map((line, i, arr) => {
+                        return new source_map_1.SourceNode(node.start.line + i, i == 0 ? node.start.column : 0, sourceUrl, line + ((i == arr.length - 1) ? '' : '\n'));
+                    }),
+                    new source_map_1.SourceNode(node.end.line, node.end.column, sourceUrl, ');\n'),
+                ];
+                break;
+            case 'evaluate':
+                code = [
+                    ...node.expression.split('\n').map((line, i, arr) => {
+                        return new source_map_1.SourceNode(node.start.line + i, i == 0 ? node.start.column : 0, sourceUrl, line + ((i == arr.length - 1) ? '' : '\n'));
+                    }),
+                    new source_map_1.SourceNode(node.end.line, node.end.column, sourceUrl, '\n'),
+                ];
+                break;
+        }
+        return chunk.add(new source_map_1.SourceNode(node.start.line, node.start.column, sourceUrl, code));
+    }, preamble)
+        .add(new source_map_1.SourceNode(end.line, end.column, sourceUrl, [
+        '  };\n',
+        '\n',
+        '  return __p;\n',
+        '}\n',
+    ]));
+    const code = nodes.toStringWithSourceMap({
+        file: sourceUrl,
+        sourceRoot: options && options.sourceRoot || '.',
+    });
+    // Set the source content in the source map, otherwise the sourceUrl is not enough
+    // to find the content.
+    code.map.setSourceContent(sourceUrl, ast.content);
+    return code.code
+        + '\n//# sourceMappingURL=data:application/json;base64,'
+        + new Buffer(code.map.toString()).toString('base64');
+}
+/**
+ * An equivalent of EJS templates, which is based on John Resig's `tmpl` implementation
+ * (http://ejohn.org/blog/javascript-micro-templating/) and Laura Doktorova's doT.js
+ * (https://github.com/olado/doT).
+ *
+ * This version differs from lodash by removing support from ES6 quasi-literals, and making the
+ * code slightly simpler to follow. It also does not depend on any third party, which is nice.
+ *
+ * Finally, it supports SourceMap, if you ever need to debug, which is super nice.
+ *
+ * @param content The template content.
+ * @param options Optional Options. See TemplateOptions for more description.
+ * @return {(input: T) => string} A function that accept an input object and returns the content
+ *         of the template with the input applied.
+ */
+function template(content, options) {
+    const sourceUrl = options && options.sourceURL || 'ejs';
+    const ast = templateParser(content, sourceUrl);
+    let source;
+    // If there's no need for source map support, we revert back to the fast implementation.
+    if (options && options.sourceMap) {
+        source = templateWithSourceMap(ast, options);
+    }
+    else {
+        source = templateFast(ast, options);
+    }
+    // We pass a dummy module in case the module option is passed. If `module: true` is passed, we
+    // need to only use the source, not the function itself. Otherwise expect a module object to be
+    // passed, and we use that one.
+    const fn = Function('module', source);
+    const module = options && options.module
+        ? (options.module === true ? { exports: {} } : options.module)
+        : null;
+    const result = fn(module);
+    // Provide the compiled function's source by its `toString` method or
+    // the `source` property as a convenience for inlining compiled templates.
+    result.source = source;
+    return result;
+}
+exports.template = template;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.js","sourceRoot":"/Users/hansl/Sources/devkit/","sources":["packages/angular_devkit/core/src/utils/template.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Position, SourceNode } from 'source-map';\n\n// Matches <%= expr %>. This does not support structural JavaScript (for/if/...).\nconst kInterpolateRe = /<%=([\\s\\S]+?)%>/g;\n\n// Used to match template delimiters.\n// <%- expr %>: HTML escape the value.\n// <% ... %>: Structural template code.\nconst kEscapeRe = /<%-([\\s\\S]+?)%>/g;\nconst kEvaluateRe = /<%([\\s\\S]+?)%>/g;\n\n/** Used to map characters to HTML entities. */\nconst kHtmlEscapes: {[char: string]: string} = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n  '`': '&#96;',\n};\n\n// Used to match HTML entities and HTML characters.\nconst reUnescapedHtml = new RegExp(`[${Object.keys(kHtmlEscapes).join('')}]`, 'g');\n\n// Options to pass to template.\nexport interface TemplateOptions {\n  sourceURL?: string;\n  sourceMap?: boolean;\n  module?: boolean | { exports: {} };\n  sourceRoot?: string;\n  fileName?: string;\n}\n\n\nfunction _positionFor(content: string, offset: number): Position {\n  let line = 1;\n  let column = 0;\n  for (let i = 0; i < offset - 1; i++) {\n    if (content[i] == '\\n') {\n      line++;\n      column = 0;\n    } else {\n      column++;\n    }\n  }\n\n  return {\n    line,\n    column,\n  };\n}\n\n/**\n * A simple AST for templates. There's only one level of AST nodes, but it's still useful\n * to have the information you're looking for.\n */\nexport interface TemplateAst {\n  fileName: string;\n  content: string;\n  children: TemplateAstNode[];\n}\n\n/**\n * The base, which contains positions.\n */\nexport interface TemplateAstBase {\n  start: Position;\n  end: Position;\n}\n\n/**\n * A static content node.\n */\nexport interface TemplateAstContent extends TemplateAstBase {\n  kind: 'content';\n  content: string;\n}\n\n/**\n * An evaluate node, which is the code between `<% ... %>`.\n */\nexport interface TemplateAstEvaluate extends TemplateAstBase {\n  kind: 'evaluate';\n  expression: string;\n}\n\n/**\n * An escape node, which is the code between `<%- ... %>`.\n */\nexport interface TemplateAstEscape extends TemplateAstBase {\n  kind: 'escape';\n  expression: string;\n}\n\n/**\n * An interpolation node, which is the code between `<%= ... %>`.\n */\nexport interface TemplateAstInterpolate extends TemplateAstBase {\n  kind: 'interpolate';\n  expression: string;\n}\n\nexport type TemplateAstNode = TemplateAstContent\n                            | TemplateAstEvaluate\n                            | TemplateAstEscape\n                            | TemplateAstInterpolate;\n\n/**\n * Given a source text (and a fileName), returns a TemplateAst.\n */\nexport function templateParser(sourceText: string, fileName: string): TemplateAst {\n  const children = [];\n\n  // Compile the regexp to match each delimiter.\n  const reDelimiters = RegExp(\n    `${kEscapeRe.source}|${kInterpolateRe.source}|${kEvaluateRe.source}|$`, 'g');\n\n  const parsed = sourceText.split(reDelimiters);\n  let offset = 0;\n  // Optimization that uses the fact that the end of a node is always the beginning of the next\n  // node, so we keep the positioning of the nodes in memory.\n  let start = _positionFor(sourceText, offset);\n  let end = null as Position | null;\n\n  for (let i = 0; i < parsed.length; i += 4) {\n    const [content, escape, interpolate, evaluate] = parsed.slice(i, i + 4);\n    if (content) {\n      end = _positionFor(sourceText, offset + content.length);\n      offset += content.length;\n      children.push({ kind: 'content', content, start, end } as TemplateAstContent);\n      start = end;\n    }\n    if (escape) {\n      end = _positionFor(sourceText, offset + escape.length + 5);\n      offset += escape.length + 5;\n      children.push({ kind: 'escape', expression: escape, start, end } as TemplateAstEscape);\n      start = end;\n    }\n    if (interpolate) {\n      end = _positionFor(sourceText, offset + interpolate.length + 5);\n      offset += interpolate.length + 5;\n      children.push({\n        kind: 'interpolate',\n        expression: interpolate,\n        start,\n        end,\n      } as TemplateAstInterpolate);\n      start = end;\n    }\n    if (evaluate) {\n      end = _positionFor(sourceText, offset + evaluate.length + 5);\n      offset += evaluate.length + 5;\n      children.push({ kind: 'evaluate', expression: evaluate, start, end } as TemplateAstEvaluate);\n      start = end;\n    }\n  }\n\n  return {\n    fileName,\n    content: sourceText,\n    children,\n  };\n}\n\n/**\n * Fastest implementation of the templating algorithm. It only add strings and does not bother\n * with source maps.\n */\nfunction templateFast(ast: TemplateAst, options?: TemplateOptions): string {\n  const module = options && options.module ? 'module.exports.default =' : '';\n  const reHtmlEscape = reUnescapedHtml.source.replace(/[']/g, '\\\\\\\\\\\\\\'');\n\n  return `\n    return ${module} function(obj) {\n      obj || (obj = {});\n      let __t;\n      let __p = '';\n      const __escapes = ${JSON.stringify(kHtmlEscapes)};\n      const __escapesre = new RegExp('${reHtmlEscape}', 'g');\n\n      const __e = function(s) {\n        return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';\n      };\n      with (obj) {\n        ${ast.children.map(node => {\n            switch (node.kind) {\n              case 'content':\n                return `__p += ${JSON.stringify(node.content)};`;\n              case 'interpolate':\n                return `__p += ((__t = (${node.expression})) == null) ? '' : __t;`;\n              case 'escape':\n                return `__p += __e(${node.expression});`;\n              case 'evaluate':\n                return node.expression;\n            }\n          }).join('\\n')\n        }\n      }\n\n      return __p;\n    };\n  `;\n}\n\n/**\n * Templating algorithm with source map support. The map is outputted as //# sourceMapUrl=...\n */\nfunction templateWithSourceMap(ast: TemplateAst, options?: TemplateOptions): string {\n  const sourceUrl = ast.fileName;\n  const module = options && options.module ? 'module.exports.default =' : '';\n  const reHtmlEscape = reUnescapedHtml.source.replace(/[']/g, '\\\\\\\\\\\\\\'');\n\n  const preamble = (new SourceNode(1, 0, sourceUrl, ''))\n    .add(new SourceNode(1, 0, sourceUrl, [\n      `return ${module} function(obj) {\\n`,\n      '  obj || (obj = {});\\n',\n      '  let __t;\\n',\n      '  let __p = \"\";\\n',\n      `  const __escapes = ${JSON.stringify(kHtmlEscapes)};\\n`,\n      `  const __escapesre = new RegExp('${reHtmlEscape}', 'g');\\n`,\n      `\\n`,\n      `  const __e = function(s) { `,\n      `    return s ? s.replace(__escapesre, function(key) { return __escapes[key]; }) : '';`,\n      `  };\\n`,\n      `  with (obj) {\\n`,\n    ]));\n\n  const end = ast.children.length\n    ? ast.children[ast.children.length - 1].end\n    : { line: 0, column: 0 };\n  const nodes = ast.children.reduce((chunk, node) => {\n    let code: string | SourceNode | (SourceNode | string)[] = '';\n    switch (node.kind) {\n      case 'content':\n        code = [\n          new SourceNode(node.start.line, node.start.column, sourceUrl, '__p = __p'),\n          ...node.content.split('\\n').map((line, i, arr) => {\n            return new SourceNode(\n              node.start.line + i,\n              i == 0 ? node.start.column : 0,\n              sourceUrl,\n              '\\n    + '\n              + JSON.stringify(line + (i == arr.length - 1 ? '' : '\\n')),\n            );\n          }),\n          new SourceNode(node.end.line, node.end.column, sourceUrl, ';\\n'),\n        ];\n        break;\n      case 'interpolate':\n        code = [\n          new SourceNode(node.start.line, node.start.column, sourceUrl, '__p += ((__t = '),\n          ...node.expression.split('\\n').map((line, i, arr) => {\n            return new SourceNode(\n              node.start.line + i,\n              i == 0 ? node.start.column : 0,\n              sourceUrl,\n              line + ((i == arr.length - 1) ? '' : '\\n'),\n            );\n          }),\n          new SourceNode(node.end.line, node.end.column, sourceUrl, ') == null ? \"\" : __t);\\n'),\n        ];\n        break;\n      case 'escape':\n        code = [\n          new SourceNode(node.start.line, node.start.column, sourceUrl, '__p += __e('),\n          ...node.expression.split('\\n').map((line, i, arr) => {\n            return new SourceNode(\n              node.start.line + i,\n              i == 0 ? node.start.column : 0,\n              sourceUrl,\n              line + ((i == arr.length - 1) ? '' : '\\n'),\n            );\n          }),\n          new SourceNode(node.end.line, node.end.column, sourceUrl, ');\\n'),\n        ];\n        break;\n      case 'evaluate':\n        code = [\n          ...node.expression.split('\\n').map((line, i, arr) => {\n            return new SourceNode(\n              node.start.line + i,\n              i == 0 ? node.start.column : 0,\n              sourceUrl,\n              line + ((i == arr.length - 1) ? '' : '\\n'),\n            );\n          }),\n          new SourceNode(node.end.line, node.end.column, sourceUrl, '\\n'),\n        ];\n        break;\n    }\n\n    return chunk.add(new SourceNode(node.start.line, node.start.column, sourceUrl, code));\n  }, preamble)\n  .add(new SourceNode(end.line, end.column, sourceUrl, [\n    '  };\\n',\n    '\\n',\n    '  return __p;\\n',\n    '}\\n',\n  ]));\n\n  const code = nodes.toStringWithSourceMap({\n    file: sourceUrl,\n    sourceRoot: options && options.sourceRoot || '.',\n  });\n\n  // Set the source content in the source map, otherwise the sourceUrl is not enough\n  // to find the content.\n  code.map.setSourceContent(sourceUrl, ast.content);\n\n  return code.code\n       + '\\n//# sourceMappingURL=data:application/json;base64,'\n       + new Buffer(code.map.toString()).toString('base64');\n}\n\n\n/**\n * An equivalent of EJS templates, which is based on John Resig's `tmpl` implementation\n * (http://ejohn.org/blog/javascript-micro-templating/) and Laura Doktorova's doT.js\n * (https://github.com/olado/doT).\n *\n * This version differs from lodash by removing support from ES6 quasi-literals, and making the\n * code slightly simpler to follow. It also does not depend on any third party, which is nice.\n *\n * Finally, it supports SourceMap, if you ever need to debug, which is super nice.\n *\n * @param content The template content.\n * @param options Optional Options. See TemplateOptions for more description.\n * @return {(input: T) => string} A function that accept an input object and returns the content\n *         of the template with the input applied.\n */\nexport function template<T>(content: string, options?: TemplateOptions): (input: T) => string {\n  const sourceUrl = options && options.sourceURL || 'ejs';\n  const ast = templateParser(content, sourceUrl);\n\n  let source: string;\n  // If there's no need for source map support, we revert back to the fast implementation.\n  if (options && options.sourceMap) {\n    source = templateWithSourceMap(ast, options);\n  } else {\n    source = templateFast(ast, options);\n  }\n\n  // We pass a dummy module in case the module option is passed. If `module: true` is passed, we\n  // need to only use the source, not the function itself. Otherwise expect a module object to be\n  // passed, and we use that one.\n  const fn = Function('module', source);\n  const module = options && options.module\n               ? (options.module === true ? { exports: {} } : options.module)\n               : null;\n  const result = fn(module);\n\n  // Provide the compiled function's source by its `toString` method or\n  // the `source` property as a convenience for inlining compiled templates.\n  result.source = source;\n\n  return result;\n}\n"]}

package/src/logger/cli-logger.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * @license
- * Copyright Google Inc. All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-require("rxjs/add/operator/filter");
-const terminal_1 = require("../terminal");
-const indent_1 = require("./indent");
-/**
- * A Logger that sends information to STDOUT and STDERR.
- */
-function createLogger(verbose = false) {
-    const logger = new indent_1.IndentLogger('cling');
-    logger
-        .filter((entry) => (entry.level != 'debug' || verbose))
-        .subscribe((entry) => {
-        let color = x => terminal_1.dim(terminal_1.white(x));
-        let output = process.stdout;
-        switch (entry.level) {
-            case 'info':
-                color = terminal_1.white;
-                break;
-            case 'warn':
-                color = terminal_1.yellow;
-                break;
-            case 'error':
-                color = terminal_1.red;
-                output = process.stderr;
-                break;
-            case 'fatal':
-                color = (x) => terminal_1.bold(terminal_1.red(x));
-                output = process.stderr;
-                break;
-        }
-        output.write(color(entry.message) + '\n');
-    });
-    return logger;
-}
-exports.createLogger = createLogger;
-//# sourceMappingURL=data:application/json;base64,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