ng2-adal-aot
Version:
Use Azure AD Library - ADAL in Angular 2
1,359 lines (1,342 loc) • 802 kB
JavaScript
System.registerDynamic("ng2-adal/services.js", ["./services/adal.service", "./services/authHttp.service"], true, function ($__require, exports, module) {
/**
* ng2-adal-aot - Use Azure AD Library - ADAL in Angular 2
* @version v0.3.4
* @link https://github.com/2020-vision/angular2-adal#readme
* @license MIT
*/
"use strict";
var global = this || self,
GLOBAL = global;
Object.defineProperty(exports, "__esModule", { value: true });
var adal_service_1 = $__require("./services/adal.service");
exports.AdalService = adal_service_1.AdalService;
var authHttp_service_1 = $__require("./services/authHttp.service");
exports.AuthHttp = authHttp_service_1.AuthHttp;
});
System.registerDynamic("ng2-adal/modules/adal.module.js", ["@angular/core", "./../services/adal.service"], true, function ($__require, exports, module) {
/**
* ng2-adal-aot - Use Azure AD Library - ADAL in Angular 2
* @version v0.3.4
* @link https://github.com/2020-vision/angular2-adal#readme
* @license MIT
*/
"use strict";
var global = this || self,
GLOBAL = global;
var __decorate = exports && exports.__decorate || function (decorators, target, key, desc) {
var c = arguments.length,
r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
var core_1 = $__require("@angular/core");
var adal_service_1 = $__require("./../services/adal.service");
var AdalModule = function () {
function AdalModule() {}
return AdalModule;
}();
AdalModule = __decorate([core_1.NgModule({
imports: [],
exports: [],
declarations: [],
providers: [adal_service_1.AdalService]
})], AdalModule);
exports.AdalModule = AdalModule;
});
System.register("@angular/http/src/backends/browser_jsonp.js", ["@angular/core"], function($__export) {
"use strict";
var Injectable,
_nextRequestId,
JSONP_HOME,
_jsonpConnections,
BrowserJsonp;
function _getJsonpConnections() {
var w = (typeof window === 'undefined' ? 'undefined' : $traceurRuntime.typeof(window)) == 'object' ? window : {};
if (_jsonpConnections === null) {
_jsonpConnections = w[JSONP_HOME] = {};
}
return _jsonpConnections;
}
function BrowserJsonp_tsickle_Closure_declarations() {
BrowserJsonp.decorators;
BrowserJsonp.ctorParameters;
}
return {
setters: [function($__m) {
Injectable = $__m.Injectable;
}],
execute: function() {
_nextRequestId = 0;
JSONP_HOME = '__ng_jsonp__';
$__export("JSONP_HOME", JSONP_HOME);
_jsonpConnections = null;
BrowserJsonp = (function() {
function BrowserJsonp() {}
BrowserJsonp.prototype.build = function(url) {
var node = document.createElement('script');
node.src = url;
return node;
};
BrowserJsonp.prototype.nextRequestID = function() {
return "__req" + _nextRequestId++;
};
BrowserJsonp.prototype.requestCallback = function(id) {
return JSONP_HOME + "." + id + ".finished";
};
BrowserJsonp.prototype.exposeConnection = function(id, connection) {
var connections = _getJsonpConnections();
connections[id] = connection;
};
BrowserJsonp.prototype.removeConnection = function(id) {
var connections = _getJsonpConnections();
connections[id] = null;
};
BrowserJsonp.prototype.send = function(node) {
document.body.appendChild(((node)));
};
BrowserJsonp.prototype.cleanup = function(node) {
if (node.parentNode) {
node.parentNode.removeChild(((node)));
}
};
BrowserJsonp.decorators = [{type: Injectable}];
BrowserJsonp.ctorParameters = function() {
return [];
};
return BrowserJsonp;
}());
$__export("BrowserJsonp", BrowserJsonp);
}
};
});
System.register("@angular/http/src/backends/jsonp_backend.js", ["@angular/core", "rxjs/Observable", "../base_response_options", "../enums", "../interfaces", "../static_response", "./browser_jsonp"], function($__export) {
"use strict";
var __extends,
Injectable,
Observable,
ResponseOptions,
ReadyState,
RequestMethod,
ResponseType,
ConnectionBackend,
Response,
BrowserJsonp,
JSONP_ERR_NO_CALLBACK,
JSONP_ERR_WRONG_METHOD,
JSONPConnection,
JSONPConnection_,
JSONPBackend,
JSONPBackend_;
function JSONPConnection_tsickle_Closure_declarations() {
JSONPConnection.prototype.readyState;
JSONPConnection.prototype.request;
JSONPConnection.prototype.response;
}
function JSONPConnection__tsickle_Closure_declarations() {
JSONPConnection_.prototype._id;
JSONPConnection_.prototype._script;
JSONPConnection_.prototype._responseData;
JSONPConnection_.prototype._finished;
JSONPConnection_.prototype._dom;
JSONPConnection_.prototype.baseResponseOptions;
}
function JSONPBackend__tsickle_Closure_declarations() {
JSONPBackend_.decorators;
JSONPBackend_.ctorParameters;
JSONPBackend_.prototype._browserJSONP;
JSONPBackend_.prototype._baseResponseOptions;
}
return {
setters: [function($__m) {
Injectable = $__m.Injectable;
}, function($__m) {
Observable = $__m.Observable;
}, function($__m) {
ResponseOptions = $__m.ResponseOptions;
}, function($__m) {
ReadyState = $__m.ReadyState;
RequestMethod = $__m.RequestMethod;
ResponseType = $__m.ResponseType;
}, function($__m) {
ConnectionBackend = $__m.ConnectionBackend;
}, function($__m) {
Response = $__m.Response;
}, function($__m) {
BrowserJsonp = $__m.BrowserJsonp;
}],
execute: function() {
__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 __());
};
JSONP_ERR_NO_CALLBACK = 'JSONP injected script did not invoke callback.';
JSONP_ERR_WRONG_METHOD = 'JSONP requests must use GET request method.';
JSONPConnection = (function() {
function JSONPConnection() {}
JSONPConnection.prototype.finished = function(data) {};
return JSONPConnection;
}());
$__export("JSONPConnection", JSONPConnection);
JSONPConnection_ = (function(_super) {
__extends(JSONPConnection_, _super);
function JSONPConnection_(req, _dom, baseResponseOptions) {
var _this = this;
_super.call(this);
this._dom = _dom;
this.baseResponseOptions = baseResponseOptions;
this._finished = false;
if (req.method !== RequestMethod.Get) {
throw new TypeError(JSONP_ERR_WRONG_METHOD);
}
this.request = req;
this.response = new Observable(function(responseObserver) {
_this.readyState = ReadyState.Loading;
var id = _this._id = _dom.nextRequestID();
_dom.exposeConnection(id, _this);
var callback = _dom.requestCallback(_this._id);
var url = req.url;
if (url.indexOf('=JSONP_CALLBACK&') > -1) {
url = url.replace('=JSONP_CALLBACK&', "=" + callback + "&");
} else if (url.lastIndexOf('=JSONP_CALLBACK') === url.length - '=JSONP_CALLBACK'.length) {
url = url.substring(0, url.length - '=JSONP_CALLBACK'.length) + ("=" + callback);
}
var script = _this._script = _dom.build(url);
var onLoad = function(event) {
if (_this.readyState === ReadyState.Cancelled)
return;
_this.readyState = ReadyState.Done;
_dom.cleanup(script);
if (!_this._finished) {
var responseOptions_1 = new ResponseOptions({
body: JSONP_ERR_NO_CALLBACK,
type: ResponseType.Error,
url: url
});
if (baseResponseOptions) {
responseOptions_1 = baseResponseOptions.merge(responseOptions_1);
}
responseObserver.error(new Response(responseOptions_1));
return;
}
var responseOptions = new ResponseOptions({
body: _this._responseData,
url: url
});
if (_this.baseResponseOptions) {
responseOptions = _this.baseResponseOptions.merge(responseOptions);
}
responseObserver.next(new Response(responseOptions));
responseObserver.complete();
};
var onError = function(error) {
if (_this.readyState === ReadyState.Cancelled)
return;
_this.readyState = ReadyState.Done;
_dom.cleanup(script);
var responseOptions = new ResponseOptions({
body: error.message,
type: ResponseType.Error
});
if (baseResponseOptions) {
responseOptions = baseResponseOptions.merge(responseOptions);
}
responseObserver.error(new Response(responseOptions));
};
script.addEventListener('load', onLoad);
script.addEventListener('error', onError);
_dom.send(script);
return function() {
_this.readyState = ReadyState.Cancelled;
script.removeEventListener('load', onLoad);
script.removeEventListener('error', onError);
_this._dom.cleanup(script);
};
});
}
JSONPConnection_.prototype.finished = function(data) {
this._finished = true;
this._dom.removeConnection(this._id);
if (this.readyState === ReadyState.Cancelled)
return;
this._responseData = data;
};
return JSONPConnection_;
}(JSONPConnection));
$__export("JSONPConnection_", JSONPConnection_);
JSONPBackend = (function(_super) {
__extends(JSONPBackend, _super);
function JSONPBackend() {
_super.apply(this, arguments);
}
return JSONPBackend;
}(ConnectionBackend));
$__export("JSONPBackend", JSONPBackend);
JSONPBackend_ = (function(_super) {
__extends(JSONPBackend_, _super);
function JSONPBackend_(_browserJSONP, _baseResponseOptions) {
_super.call(this);
this._browserJSONP = _browserJSONP;
this._baseResponseOptions = _baseResponseOptions;
}
JSONPBackend_.prototype.createConnection = function(request) {
return new JSONPConnection_(request, this._browserJSONP, this._baseResponseOptions);
};
JSONPBackend_.decorators = [{type: Injectable}];
JSONPBackend_.ctorParameters = function() {
return [{type: BrowserJsonp}, {type: ResponseOptions}];
};
return JSONPBackend_;
}(JSONPBackend));
$__export("JSONPBackend_", JSONPBackend_);
}
};
});
System.register("@angular/platform-browser/src/facade/browser.js", [], function($__export) {
"use strict";
var win,
document,
location,
gc,
performance,
Event,
MouseEvent,
KeyboardEvent,
EventTarget,
History,
Location,
EventListener;
return {
setters: [],
execute: function() {
win = typeof window !== 'undefined' && window || ({});
$__export("window", win);
document = win.document;
$__export("document", document);
location = win.location;
$__export("location", location);
gc = win['gc'] ? function() {
return win['gc']();
} : function() {
return null;
};
$__export("gc", gc);
performance = win['performance'] ? win['performance'] : null;
$__export("performance", performance);
Event = win['Event'];
$__export("Event", Event);
MouseEvent = win['MouseEvent'];
$__export("MouseEvent", MouseEvent);
KeyboardEvent = win['KeyboardEvent'];
$__export("KeyboardEvent", KeyboardEvent);
EventTarget = win['EventTarget'];
$__export("EventTarget", EventTarget);
History = win['History'];
$__export("History", History);
Location = win['Location'];
$__export("Location", Location);
EventListener = win['EventListener'];
$__export("EventListener", EventListener);
}
};
});
System.register("@angular/platform-browser/src/browser/tools/common_tools.js", ["@angular/core", "../../dom/dom_adapter", "../../facade/browser", "../../facade/lang"], function($__export) {
"use strict";
var ApplicationRef,
getDOM,
window,
isPresent,
ChangeDetectionPerfRecord,
AngularTools,
AngularProfiler;
function ChangeDetectionPerfRecord_tsickle_Closure_declarations() {
ChangeDetectionPerfRecord.prototype.msPerTick;
ChangeDetectionPerfRecord.prototype.numTicks;
}
function AngularTools_tsickle_Closure_declarations() {
AngularTools.prototype.profiler;
}
function AngularProfiler_tsickle_Closure_declarations() {
AngularProfiler.prototype.appRef;
}
return {
setters: [function($__m) {
ApplicationRef = $__m.ApplicationRef;
}, function($__m) {
getDOM = $__m.getDOM;
}, function($__m) {
window = $__m.window;
}, function($__m) {
isPresent = $__m.isPresent;
}],
execute: function() {
ChangeDetectionPerfRecord = (function() {
function ChangeDetectionPerfRecord(msPerTick, numTicks) {
this.msPerTick = msPerTick;
this.numTicks = numTicks;
}
return ChangeDetectionPerfRecord;
}());
$__export("ChangeDetectionPerfRecord", ChangeDetectionPerfRecord);
AngularTools = (function() {
function AngularTools(ref) {
this.profiler = new AngularProfiler(ref);
}
return AngularTools;
}());
$__export("AngularTools", AngularTools);
AngularProfiler = (function() {
function AngularProfiler(ref) {
this.appRef = ref.injector.get(ApplicationRef);
}
AngularProfiler.prototype.timeChangeDetection = function(config) {
var record = config && config['record'];
var profileName = 'Change Detection';
var isProfilerAvailable = isPresent(window.console.profile);
if (record && isProfilerAvailable) {
window.console.profile(profileName);
}
var start = getDOM().performanceNow();
var numTicks = 0;
while (numTicks < 5 || (getDOM().performanceNow() - start) < 500) {
this.appRef.tick();
numTicks++;
}
var end = getDOM().performanceNow();
if (record && isProfilerAvailable) {
((window.console.profileEnd))(profileName);
}
var msPerTick = (end - start) / numTicks;
window.console.log("ran " + numTicks + " change detection cycles");
window.console.log(msPerTick.toFixed(2) + " ms per check");
return new ChangeDetectionPerfRecord(msPerTick, numTicks);
};
return AngularProfiler;
}());
$__export("AngularProfiler", AngularProfiler);
}
};
});
System.register("@angular/platform-browser/src/browser/tools/tools.js", ["../../facade/lang", "./common_tools"], function($__export) {
"use strict";
var global,
AngularTools,
context;
function enableDebugTools(ref) {
((Object)).assign(context.ng, new AngularTools(ref));
return ref;
}
function disableDebugTools() {
if (context.ng) {
delete context.ng.profiler;
}
}
$__export("enableDebugTools", enableDebugTools);
$__export("disableDebugTools", disableDebugTools);
return {
setters: [function($__m) {
global = $__m.global;
}, function($__m) {
AngularTools = $__m.AngularTools;
}],
execute: function() {
context = (global);
}
};
});
System.register("@angular/platform-browser/src/dom/debug/by.js", ["../../dom/dom_adapter", "../../facade/lang"], function($__export) {
"use strict";
var getDOM,
isPresent,
By;
return {
setters: [function($__m) {
getDOM = $__m.getDOM;
}, function($__m) {
isPresent = $__m.isPresent;
}],
execute: function() {
By = (function() {
function By() {}
By.all = function() {
return function(debugElement) {
return true;
};
};
By.css = function(selector) {
return function(debugElement) {
return isPresent(debugElement.nativeElement) ? getDOM().elementMatches(debugElement.nativeElement, selector) : false;
};
};
By.directive = function(type) {
return function(debugElement) {
return debugElement.providerTokens.indexOf(type) !== -1;
};
};
return By;
}());
$__export("By", By);
}
};
});
System.register("@angular/platform-browser/src/browser/title.js", ["../dom/dom_adapter"], function($__export) {
"use strict";
var getDOM,
Title;
return {
setters: [function($__m) {
getDOM = $__m.getDOM;
}],
execute: function() {
Title = (function() {
function Title() {}
Title.prototype.getTitle = function() {
return getDOM().getTitle();
};
Title.prototype.setTitle = function(newTitle) {
getDOM().setTitle(newTitle);
};
return Title;
}());
$__export("Title", Title);
}
};
});
System.register("@angular/platform-browser/src/security/html_sanitizer.js", ["@angular/core", "../dom/dom_adapter", "./url_sanitizer"], function($__export) {
"use strict";
var isDevMode,
getDOM,
sanitizeSrcset,
sanitizeUrl,
inertElement,
DOM,
VOID_ELEMENTS,
OPTIONAL_END_TAG_BLOCK_ELEMENTS,
OPTIONAL_END_TAG_INLINE_ELEMENTS,
OPTIONAL_END_TAG_ELEMENTS,
BLOCK_ELEMENTS,
INLINE_ELEMENTS,
VALID_ELEMENTS,
URI_ATTRS,
SRCSET_ATTRS,
HTML_ATTRS,
VALID_ATTRS,
SanitizingHtmlSerializer,
SURROGATE_PAIR_REGEXP,
NON_ALPHANUMERIC_REGEXP;
function getInertElement() {
if (inertElement)
return inertElement;
DOM = getDOM();
var templateEl = DOM.createElement('template');
if ('content' in templateEl)
return templateEl;
var doc = DOM.createHtmlDocument();
inertElement = DOM.querySelector(doc, 'body');
if (inertElement == null) {
var html = DOM.createElement('html', doc);
inertElement = DOM.createElement('body', doc);
DOM.appendChild(html, inertElement);
DOM.appendChild(doc, html);
}
return inertElement;
}
function tagSet(tags) {
var res = {};
for (var _i = 0,
_a = tags.split(','); _i < _a.length; _i++) {
var t = _a[_i];
res[t] = true;
}
return res;
}
function merge() {
var sets = [];
for (var _i = 0; _i < arguments.length; _i++) {
sets[_i - 0] = arguments[_i];
}
var res = {};
for (var _a = 0,
sets_1 = sets; _a < sets_1.length; _a++) {
var s = sets_1[_a];
for (var v in s) {
if (s.hasOwnProperty(v))
res[v] = true;
}
}
return res;
}
function SanitizingHtmlSerializer_tsickle_Closure_declarations() {
SanitizingHtmlSerializer.prototype.sanitizedSomething;
SanitizingHtmlSerializer.prototype.buf;
}
function encodeEntities(value) {
return value.replace(/&/g, '&').replace(SURROGATE_PAIR_REGEXP, function(match) {
var hi = match.charCodeAt(0);
var low = match.charCodeAt(1);
return '&#' + (((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000) + ';';
}).replace(NON_ALPHANUMERIC_REGEXP, function(match) {
return '&#' + match.charCodeAt(0) + ';';
}).replace(/</g, '<').replace(/>/g, '>');
}
function stripCustomNsAttrs(el) {
DOM.attributeMap(el).forEach(function(_, attrName) {
if (attrName === 'xmlns:ns1' || attrName.indexOf('ns1:') === 0) {
DOM.removeAttribute(el, attrName);
}
});
for (var _i = 0,
_a = DOM.childNodesAsList(el); _i < _a.length; _i++) {
var n = _a[_i];
if (DOM.isElementNode(n))
stripCustomNsAttrs((n));
}
}
function sanitizeHtml(unsafeHtmlInput) {
try {
var containerEl = getInertElement();
var unsafeHtml = unsafeHtmlInput ? String(unsafeHtmlInput) : '';
var mXSSAttempts = 5;
var parsedHtml = unsafeHtml;
do {
if (mXSSAttempts === 0) {
throw new Error('Failed to sanitize html because the input is unstable');
}
mXSSAttempts--;
unsafeHtml = parsedHtml;
DOM.setInnerHTML(containerEl, unsafeHtml);
if (((DOM.defaultDoc())).documentMode) {
stripCustomNsAttrs(containerEl);
}
parsedHtml = DOM.getInnerHTML(containerEl);
} while (unsafeHtml !== parsedHtml);
var sanitizer = new SanitizingHtmlSerializer();
var safeHtml = sanitizer.sanitizeChildren(DOM.getTemplateContent(containerEl) || containerEl);
var parent_1 = DOM.getTemplateContent(containerEl) || containerEl;
for (var _i = 0,
_a = DOM.childNodesAsList(parent_1); _i < _a.length; _i++) {
var child = _a[_i];
DOM.removeChild(parent_1, child);
}
if (isDevMode() && sanitizer.sanitizedSomething) {
DOM.log('WARNING: sanitizing HTML stripped some content (see http://g.co/ng/security#xss).');
}
return safeHtml;
} catch (e) {
inertElement = null;
throw e;
}
}
$__export("sanitizeHtml", sanitizeHtml);
return {
setters: [function($__m) {
isDevMode = $__m.isDevMode;
}, function($__m) {
getDOM = $__m.getDOM;
}, function($__m) {
sanitizeSrcset = $__m.sanitizeSrcset;
sanitizeUrl = $__m.sanitizeUrl;
}],
execute: function() {
inertElement = null;
DOM = null;
VOID_ELEMENTS = tagSet('area,br,col,hr,img,wbr');
OPTIONAL_END_TAG_BLOCK_ELEMENTS = tagSet('colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr');
OPTIONAL_END_TAG_INLINE_ELEMENTS = tagSet('rp,rt');
OPTIONAL_END_TAG_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, OPTIONAL_END_TAG_BLOCK_ELEMENTS);
BLOCK_ELEMENTS = merge(OPTIONAL_END_TAG_BLOCK_ELEMENTS, tagSet('address,article,' + 'aside,blockquote,caption,center,del,details,dialog,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5,' + 'h6,header,hgroup,hr,ins,main,map,menu,nav,ol,pre,section,summary,table,ul'));
INLINE_ELEMENTS = merge(OPTIONAL_END_TAG_INLINE_ELEMENTS, tagSet('a,abbr,acronym,audio,b,' + 'bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,picture,q,ruby,rp,rt,s,' + 'samp,small,source,span,strike,strong,sub,sup,time,track,tt,u,var,video'));
VALID_ELEMENTS = merge(VOID_ELEMENTS, BLOCK_ELEMENTS, INLINE_ELEMENTS, OPTIONAL_END_TAG_ELEMENTS);
URI_ATTRS = tagSet('background,cite,href,itemtype,longdesc,poster,src,xlink:href');
SRCSET_ATTRS = tagSet('srcset');
HTML_ATTRS = tagSet('abbr,accesskey,align,alt,autoplay,axis,bgcolor,border,cellpadding,cellspacing,class,clear,color,cols,colspan,' + 'compact,controls,coords,datetime,default,dir,download,face,headers,height,hidden,hreflang,hspace,' + 'ismap,itemscope,itemprop,kind,label,lang,language,loop,media,muted,nohref,nowrap,open,preload,rel,rev,role,rows,rowspan,rules,' + 'scope,scrolling,shape,size,sizes,span,srclang,start,summary,tabindex,target,title,translate,type,usemap,' + 'valign,value,vspace,width');
VALID_ATTRS = merge(URI_ATTRS, SRCSET_ATTRS, HTML_ATTRS);
SanitizingHtmlSerializer = (function() {
function SanitizingHtmlSerializer() {
this.sanitizedSomething = false;
this.buf = [];
}
SanitizingHtmlSerializer.prototype.sanitizeChildren = function(el) {
var current = el.firstChild;
while (current) {
if (DOM.isElementNode(current)) {
this.startElement((current));
} else if (DOM.isTextNode(current)) {
this.chars(DOM.nodeValue(current));
} else {
this.sanitizedSomething = true;
}
if (DOM.firstChild(current)) {
current = DOM.firstChild(current);
continue;
}
while (current) {
if (DOM.isElementNode(current)) {
this.endElement((current));
}
if (DOM.nextSibling(current)) {
current = DOM.nextSibling(current);
break;
}
current = DOM.parentElement(current);
}
}
return this.buf.join('');
};
SanitizingHtmlSerializer.prototype.startElement = function(element) {
var _this = this;
var tagName = DOM.nodeName(element).toLowerCase();
if (!VALID_ELEMENTS.hasOwnProperty(tagName)) {
this.sanitizedSomething = true;
return;
}
this.buf.push('<');
this.buf.push(tagName);
DOM.attributeMap(element).forEach(function(value, attrName) {
var lower = attrName.toLowerCase();
if (!VALID_ATTRS.hasOwnProperty(lower)) {
_this.sanitizedSomething = true;
return;
}
if (URI_ATTRS[lower])
value = sanitizeUrl(value);
if (SRCSET_ATTRS[lower])
value = sanitizeSrcset(value);
_this.buf.push(' ');
_this.buf.push(attrName);
_this.buf.push('="');
_this.buf.push(encodeEntities(value));
_this.buf.push('"');
});
this.buf.push('>');
};
SanitizingHtmlSerializer.prototype.endElement = function(current) {
var tagName = DOM.nodeName(current).toLowerCase();
if (VALID_ELEMENTS.hasOwnProperty(tagName) && !VOID_ELEMENTS.hasOwnProperty(tagName)) {
this.buf.push('</');
this.buf.push(tagName);
this.buf.push('>');
}
};
SanitizingHtmlSerializer.prototype.chars = function(chars) {
this.buf.push(encodeEntities(chars));
};
return SanitizingHtmlSerializer;
}());
SURROGATE_PAIR_REGEXP = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
NON_ALPHANUMERIC_REGEXP = /([^\#-~ |!])/g;
}
};
});
System.register("@angular/platform-browser/src/security/style_sanitizer.js", ["@angular/core", "../dom/dom_adapter", "./url_sanitizer"], function($__export) {
"use strict";
var isDevMode,
getDOM,
sanitizeUrl,
VALUES,
TRANSFORMATION_FNS,
COLOR_FNS,
GRADIENTS,
CSS3_FNS,
FN_ARGS,
SAFE_STYLE_VALUE,
URL_RE;
function hasBalancedQuotes(value) {
var outsideSingle = true;
var outsideDouble = true;
for (var i = 0; i < value.length; i++) {
var c = value.charAt(i);
if (c === '\'' && outsideDouble) {
outsideSingle = !outsideSingle;
} else if (c === '"' && outsideSingle) {
outsideDouble = !outsideDouble;
}
}
return outsideSingle && outsideDouble;
}
function sanitizeStyle(value) {
value = String(value).trim();
if (!value)
return '';
var urlMatch = value.match(URL_RE);
if ((urlMatch && sanitizeUrl(urlMatch[1]) === urlMatch[1]) || value.match(SAFE_STYLE_VALUE) && hasBalancedQuotes(value)) {
return value;
}
if (isDevMode()) {
getDOM().log("WARNING: sanitizing unsafe style value " + value + " (see http://g.co/ng/security#xss).");
}
return 'unsafe';
}
$__export("sanitizeStyle", sanitizeStyle);
return {
setters: [function($__m) {
isDevMode = $__m.isDevMode;
}, function($__m) {
getDOM = $__m.getDOM;
}, function($__m) {
sanitizeUrl = $__m.sanitizeUrl;
}],
execute: function() {
VALUES = '[-,."\'%_!# a-zA-Z0-9]+';
TRANSFORMATION_FNS = '(?:matrix|translate|scale|rotate|skew|perspective)(?:X|Y|3d)?';
COLOR_FNS = '(?:rgb|hsl)a?';
GRADIENTS = '(?:repeating-)?(?:linear|radial)-gradient';
CSS3_FNS = '(?:calc|attr)';
FN_ARGS = '\\([-0-9.%, #a-zA-Z]+\\)';
SAFE_STYLE_VALUE = new RegExp(("^(" + VALUES + "|") + ("(?:" + TRANSFORMATION_FNS + "|" + COLOR_FNS + "|" + GRADIENTS + "|" + CSS3_FNS + ")") + (FN_ARGS + ")$"), 'g');
URL_RE = /^url\(([^)]+)\)$/;
}
};
});
System.register("@angular/platform-browser/src/security/url_sanitizer.js", ["@angular/core", "../dom/dom_adapter"], function($__export) {
"use strict";
var isDevMode,
getDOM,
SAFE_URL_PATTERN,
SAFE_SRCSET_PATTERN,
DATA_URL_PATTERN;
function sanitizeUrl(url) {
url = String(url);
if (url.match(SAFE_URL_PATTERN) || url.match(DATA_URL_PATTERN))
return url;
if (isDevMode()) {
getDOM().log("WARNING: sanitizing unsafe URL value " + url + " (see http://g.co/ng/security#xss)");
}
return 'unsafe:' + url;
}
function sanitizeSrcset(srcset) {
srcset = String(srcset);
return srcset.split(',').map(function(srcset) {
return sanitizeUrl(srcset.trim());
}).join(', ');
}
$__export("sanitizeUrl", sanitizeUrl);
$__export("sanitizeSrcset", sanitizeSrcset);
return {
setters: [function($__m) {
isDevMode = $__m.isDevMode;
}, function($__m) {
getDOM = $__m.getDOM;
}],
execute: function() {
SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi;
SAFE_SRCSET_PATTERN = /^(?:(?:https?|file):|[^&:/?#]*(?:[/?#]|$))/gi;
DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+\/]+=*$/i;
}
};
});
System.register("@angular/platform-browser/src/security/dom_sanitization_service.js", ["@angular/core", "./html_sanitizer", "./style_sanitizer", "./url_sanitizer"], function($__export) {
"use strict";
var __extends,
Injectable,
SecurityContext,
sanitizeHtml,
sanitizeStyle,
sanitizeUrl,
DomSanitizer,
DomSanitizerImpl,
SafeValueImpl,
SafeHtmlImpl,
SafeStyleImpl,
SafeScriptImpl,
SafeUrlImpl,
SafeResourceUrlImpl;
function DomSanitizerImpl_tsickle_Closure_declarations() {
DomSanitizerImpl.decorators;
DomSanitizerImpl.ctorParameters;
}
function SafeValueImpl_tsickle_Closure_declarations() {
SafeValueImpl.prototype.changingThisBreaksApplicationSecurity;
}
return {
setters: [function($__m) {
Injectable = $__m.Injectable;
SecurityContext = $__m.SecurityContext;
}, function($__m) {
sanitizeHtml = $__m.sanitizeHtml;
}, function($__m) {
sanitizeStyle = $__m.sanitizeStyle;
}, function($__m) {
sanitizeUrl = $__m.sanitizeUrl;
}],
execute: function() {
__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 __());
};
$__export("SecurityContext", SecurityContext);
DomSanitizer = (function() {
function DomSanitizer() {}
DomSanitizer.prototype.sanitize = function(context, value) {};
DomSanitizer.prototype.bypassSecurityTrustHtml = function(value) {};
DomSanitizer.prototype.bypassSecurityTrustStyle = function(value) {};
DomSanitizer.prototype.bypassSecurityTrustScript = function(value) {};
DomSanitizer.prototype.bypassSecurityTrustUrl = function(value) {};
DomSanitizer.prototype.bypassSecurityTrustResourceUrl = function(value) {};
return DomSanitizer;
}());
$__export("DomSanitizer", DomSanitizer);
DomSanitizerImpl = (function(_super) {
__extends(DomSanitizerImpl, _super);
function DomSanitizerImpl() {
_super.apply(this, arguments);
}
DomSanitizerImpl.prototype.sanitize = function(ctx, value) {
if (value == null)
return null;
switch (ctx) {
case SecurityContext.NONE:
return value;
case SecurityContext.HTML:
if (value instanceof SafeHtmlImpl)
return value.changingThisBreaksApplicationSecurity;
this.checkNotSafeValue(value, 'HTML');
return sanitizeHtml(String(value));
case SecurityContext.STYLE:
if (value instanceof SafeStyleImpl)
return value.changingThisBreaksApplicationSecurity;
this.checkNotSafeValue(value, 'Style');
return sanitizeStyle(value);
case SecurityContext.SCRIPT:
if (value instanceof SafeScriptImpl)
return value.changingThisBreaksApplicationSecurity;
this.checkNotSafeValue(value, 'Script');
throw new Error('unsafe value used in a script context');
case SecurityContext.URL:
if (value instanceof SafeResourceUrlImpl || value instanceof SafeUrlImpl) {
return value.changingThisBreaksApplicationSecurity;
}
this.checkNotSafeValue(value, 'URL');
return sanitizeUrl(String(value));
case SecurityContext.RESOURCE_URL:
if (value instanceof SafeResourceUrlImpl) {
return value.changingThisBreaksApplicationSecurity;
}
this.checkNotSafeValue(value, 'ResourceURL');
throw new Error('unsafe value used in a resource URL context (see http://g.co/ng/security#xss)');
default:
throw new Error("Unexpected SecurityContext " + ctx + " (see http://g.co/ng/security#xss)");
}
};
DomSanitizerImpl.prototype.checkNotSafeValue = function(value, expectedType) {
if (value instanceof SafeValueImpl) {
throw new Error(("Required a safe " + expectedType + ", got a " + value.getTypeName() + " ") + "(see http://g.co/ng/security#xss)");
}
};
DomSanitizerImpl.prototype.bypassSecurityTrustHtml = function(value) {
return new SafeHtmlImpl(value);
};
DomSanitizerImpl.prototype.bypassSecurityTrustStyle = function(value) {
return new SafeStyleImpl(value);
};
DomSanitizerImpl.prototype.bypassSecurityTrustScript = function(value) {
return new SafeScriptImpl(value);
};
DomSanitizerImpl.prototype.bypassSecurityTrustUrl = function(value) {
return new SafeUrlImpl(value);
};
DomSanitizerImpl.prototype.bypassSecurityTrustResourceUrl = function(value) {
return new SafeResourceUrlImpl(value);
};
DomSanitizerImpl.decorators = [{type: Injectable}];
DomSanitizerImpl.ctorParameters = function() {
return [];
};
return DomSanitizerImpl;
}(DomSanitizer));
$__export("DomSanitizerImpl", DomSanitizerImpl);
SafeValueImpl = (function() {
function SafeValueImpl(changingThisBreaksApplicationSecurity) {
this.changingThisBreaksApplicationSecurity = changingThisBreaksApplicationSecurity;
}
SafeValueImpl.prototype.getTypeName = function() {};
SafeValueImpl.prototype.toString = function() {
return ("SafeValue must use [property]=binding: " + this.changingThisBreaksApplicationSecurity) + " (see http://g.co/ng/security#xss)";
};
return SafeValueImpl;
}());
SafeHtmlImpl = (function(_super) {
__extends(SafeHtmlImpl, _super);
function SafeHtmlImpl() {
_super.apply(this, arguments);
}
SafeHtmlImpl.prototype.getTypeName = function() {
return 'HTML';
};
return SafeHtmlImpl;
}(SafeValueImpl));
SafeStyleImpl = (function(_super) {
__extends(SafeStyleImpl, _super);
function SafeStyleImpl() {
_super.apply(this, arguments);
}
SafeStyleImpl.prototype.getTypeName = function() {
return 'Style';
};
return SafeStyleImpl;
}(SafeValueImpl));
SafeScriptImpl = (function(_super) {
__extends(SafeScriptImpl, _super);
function SafeScriptImpl() {
_super.apply(this, arguments);
}
SafeScriptImpl.prototype.getTypeName = function() {
return 'Script';
};
return SafeScriptImpl;
}(SafeValueImpl));
SafeUrlImpl = (function(_super) {
__extends(SafeUrlImpl, _super);
function SafeUrlImpl() {
_super.apply(this, arguments);
}
SafeUrlImpl.prototype.getTypeName = function() {
return 'URL';
};
return SafeUrlImpl;
}(SafeValueImpl));
SafeResourceUrlImpl = (function(_super) {
__extends(SafeResourceUrlImpl, _super);
function SafeResourceUrlImpl() {
_super.apply(this, arguments);
}
SafeResourceUrlImpl.prototype.getTypeName = function() {
return 'ResourceURL';
};
return SafeResourceUrlImpl;
}(SafeValueImpl));
}
};
});
System.register("@angular/platform-browser/src/browser.js", ["@angular/common", "@angular/core", "../src/dom/animation_driver", "../src/dom/web_animations_driver", "./browser/browser_adapter", "./browser/location/browser_platform_location", "./browser/testability", "./browser/title", "./dom/debug/ng_probe", "./dom/dom_adapter", "./dom/dom_renderer", "./dom/dom_tokens", "./dom/events/dom_events", "./dom/events/event_manager", "./dom/events/hammer_gestures", "./dom/events/key_events", "./dom/shared_styles_host", "./security/dom_sanitization_service"], function($__export) {
"use strict";
var CommonModule,
PlatformLocation,
ApplicationModule,
ErrorHandler,
NgModule,
Optional,
PLATFORM_INITIALIZER,
RootRenderer,
Sanitizer,
SkipSelf,
Testability,
createPlatformFactory,
platformCore,
AnimationDriver,
WebAnimationsDriver,
BrowserDomAdapter,
BrowserPlatformLocation,
BrowserGetTestability,
Title,
ELEMENT_PROBE_PROVIDERS,
getDOM,
DomRootRenderer,
DomRootRenderer_,
DOCUMENT,
DomEventsPlugin,
EVENT_MANAGER_PLUGINS,
EventManager,
HAMMER_GESTURE_CONFIG,
HammerGestureConfig,
HammerGesturesPlugin,
KeyEventsPlugin,
DomSharedStylesHost,
SharedStylesHost,
DomSanitizer,
DomSanitizerImpl,
INTERNAL_BROWSER_PLATFORM_PROVIDERS,
BROWSER_SANITIZATION_PROVIDERS,
platformBrowser,
BrowserModule;
function initDomAdapter() {
BrowserDomAdapter.makeCurrent();
BrowserGetTestability.init();
}
function errorHandler() {
return new ErrorHandler();
}
function _document() {
return getDOM().defaultDoc();
}
function _resolveDefaultAnimationDriver() {
if (getDOM().supportsWebAnimation()) {
return new WebAnimationsDriver();
}
return AnimationDriver.NOOP;
}
function BrowserModule_tsickle_Closure_declarations() {
BrowserModule.decorators;
BrowserModule.ctorParameters;
}
$__export("initDomAdapter", initDomAdapter);
$__export("errorHandler", errorHandler);
$__export("_document", _document);
$__export("_resolveDefaultAnimationDriver", _resolveDefaultAnimationDriver);
return {
setters: [function($__m) {
CommonModule = $__m.CommonModule;
PlatformLocation = $__m.PlatformLocation;
}, function($__m) {
ApplicationModule = $__m.ApplicationModule;
ErrorHandler = $__m.ErrorHandler;
NgModule = $__m.NgModule;
Optional = $__m.Optional;
PLATFORM_INITIALIZER = $__m.PLATFORM_INITIALIZER;
RootRenderer = $__m.RootRenderer;
Sanitizer = $__m.Sanitizer;
SkipSelf = $__m.SkipSelf;
Testability = $__m.Testability;
createPlatformFactory = $__m.createPlatformFactory;
platformCore = $__m.platformCore;
}, function($__m) {
AnimationDriver = $__m.AnimationDriver;
}, function($__m) {
WebAnimationsDriver = $__m.WebAnimationsDriver;
}, function($__m) {
BrowserDomAdapter = $__m.BrowserDomAdapter;
}, function($__m) {
BrowserPlatformLocation = $__m.BrowserPlatformLocation;
}, function($__m) {
BrowserGetTestability = $__m.BrowserGetTestability;
}, function($__m) {
Title = $__m.Title;
}, function($__m) {
ELEMENT_PROBE_PROVIDERS = $__m.ELEMENT_PROBE_PROVIDERS;
}, function($__m) {
getDOM = $__m.getDOM;
}, function($__m) {
DomRootRenderer = $__m.DomRootRenderer;
DomRootRenderer_ = $__m.DomRootRenderer_;
}, function($__m) {
DOCUMENT = $__m.DOCUMENT;
}, function($__m) {
DomEventsPlugin = $__m.DomEventsPlugin;
}, function($__m) {
EVENT_MANAGER_PLUGINS = $__m.EVENT_MANAGER_PLUGINS;
EventManager = $__m.EventManager;
}, function($__m) {
HAMMER_GESTURE_CONFIG = $__m.HAMMER_GESTURE_CONFIG;
HammerGestureConfig = $__m.HammerGestureConfig;
HammerGesturesPlugin = $__m.HammerGesturesPlugin;
}, function($__m) {
KeyEventsPlugin = $__m.KeyEventsPlugin;
}, function($__m) {
DomSharedStylesHost = $__m.DomSharedStylesHost;
SharedStylesHost = $__m.SharedStylesHost;
}, function($__m) {
DomSanitizer = $__m.DomSanitizer;
DomSanitizerImpl = $__m.DomSanitizerImpl;
}],
execute: function() {
INTERNAL_BROWSER_PLATFORM_PROVIDERS = [{
provide: PLATFORM_INITIALIZER,
useValue: initDomAdapter,
multi: true
}, {
provide: PlatformLocation,
useClass: BrowserPlatformLocation
}];
$__export("INTERNAL_BROWSER_PLATFORM_PROVIDERS", INTERNAL_BROWSER_PLATFORM_PROVIDERS);
BROWSER_SANITIZATION_PROVIDERS = [{
provide: Sanitizer,
useExisting: DomSanitizer
}, {
provide: DomSanitizer,
useClass: DomSanitizerImpl
}];
$__export("BROWSER_SANITIZATION_PROVIDERS", BROWSER_SANITIZATION_PROVIDERS);
platformBrowser = createPlatformFactory(platformCore, 'browser', INTERNAL_BROWSER_PLATFORM_PROVIDERS);
$__export("platformBrowser", platformBrowser);
BrowserModule = (function() {
function BrowserModule(parentModule) {
if (parentModule) {
throw new Error("BrowserModule has already been loaded. If you need access to common directives such as NgIf and NgFor from a lazy loaded module, import CommonModule instead.");
}
}
BrowserModule.decorators = [{
type: NgModule,
args: [{
providers: [BROWSER_SANITIZATION_PROVIDERS, {
provide: ErrorHandler,
useFactory: errorHandler,
deps: []
}, {
provide: DOCUMENT,
useFactory: _document,
deps: []
}, {
provide: EVENT_MANAGER_PLUGINS,
useClass: DomEventsPlugin,
multi: true
}, {
provide: EVENT_MANAGER_PLUGINS,
useClass: KeyEventsPlugin,
multi: true
}, {
provide: EVENT_MANAGER_PLUGINS,
useClass: HammerGesturesPlugin,
multi: true
}, {
provide: HAMMER_GESTURE_CONFIG,
useClass: HammerGestureConfig
}, {
provide: DomRootRenderer,
useClass: DomRootRenderer_
}, {
provide: RootRenderer,
useExisting: DomRootRenderer
}, {
provide: SharedStylesHost,
useExisting: DomSharedStylesHost
}, {
provide: AnimationDriver,
useFactory: _resolveDefaultAnimationDriver
}, DomSharedStylesHost, Testability, EventManager, ELEMENT_PROBE_PROVIDERS, Title],
exports: [CommonModule, ApplicationModule]
}]
}];
BrowserModule.ctorParameters = function() {
return [{
type: BrowserModule,
decorators: [{type: Optional}, {type: SkipSelf}]
}];
};
return BrowserModule;
}());
$__export("BrowserModule", BrowserModule);
}
};
});
System.register("@angular/platform-browser/src/browser/generic_browser_adapter.js", ["../dom/dom_adapter", "../facade/lang"], function($__export) {
"use strict";
var __extends,
DomAdapter,
isPresent,
GenericBrowserDomAdapter;
function GenericBrowserDomAdapter_tsickle_Closure_declarations() {
GenericBrowserDomAdapter.prototype._animationPrefix;
GenericBrowserDomAdapter.prototype._transitionEnd;
}
return {
setters: [function($__m) {
DomAdapter = $__m.DomAdapter;
}, function($__m) {
isPresent = $__m.isPresent;
}],
execute: function() {
__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 __());
};
GenericBrowserDomAdapter = (function(_super) {
__extends(GenericBrowserDomAdapter, _super);
function GenericBrowserDomAdapter() {
var _this = this;
_super.call(this);
this._animationPrefix = null;
this._transitionEnd = null;
try {
var element_1 = this.createElement('div', this.defaultDoc());
if (isPresent(this.getStyle(element_1, 'animationName'))) {
this._animationPrefix = '';
} else {
var domPrefixes = ['Webkit', 'Moz', 'O', 'ms'];
for (var i = 0; i < domPrefixes.length; i++) {
if (isPresent(this.getStyle(element_1, domPrefixes[i] + 'AnimationName'))) {
this._animationPrefix = '-' + domPrefixes[i].toLowerCase() + '-';
break;
}
}
}
var transEndEventNames_1 = {
WebkitTransition: 'webkitTransitionEnd',
MozTransition: 'transitionend',
OTransition: 'oTransitionEnd otransitionend',
transition: 'transitionend'
};
Object.keys(transEndEventNames_1).forEach(function(key) {
if (isPresent(_this.getStyle(element_1, key))) {
_this._transitionEnd = transEndEventNames_1[key];
}
});
} catch (e) {
this._animationPrefix = null;
this._transitionEnd = null;
}
}
GenericBrowserDomAdapter.prototype.getDistributedNodes = function(el) {
return ((el)).getDistributedNodes();
};
GenericBrowserDomAdapter.prototype.resolveAndSetHref = function(el, baseUrl, href) {
el.href = href == null ? baseUrl : baseUrl + '/../' + href;
};
GenericBrowserDomAdapter.prototype.supportsDOMEvents = function() {
return true;
};
GenericBrowserDomAdapter.prototype.supportsNativeShadowDOM = function() {
return typeof((this.defaultDoc().body)).createShadowRoot === 'function';
};
GenericBrowserDomAdapter.prototype.getAnimationPrefix = function() {
return this._animationPrefix ? this._animationPrefix : '';
};
GenericBrowserDomAdapter.prototype.getTransitionEnd = function() {
return this._transitionEnd ? this._transitionEnd : '';
};
GenericBrowserDomAdapter.prototype.supportsAnimation = function() {
return isPresent(this._animationPrefix) && isPresent(this._transitionEnd);
};
return GenericBrowserDomAdapter;
}(DomAdapter));
$__export("GenericBrowserDomAdapter", GenericBrowserDomAdapter);
}
};
});
System.register("@angular/platform-browser/src/browser/browser_adapter.js", ["../dom/dom_adapter", "../facade/lang", "./generic_browser_adapter"], function($__export) {
"use strict";
var __extends,
setRootDomAdapter,
global,
isBlank,
isPresent,
setValueOnPath,
GenericBrowserDomAdapter,
_attrToPropMap,
DOM_KEY_LOCATION_NUMPAD,
_keyMap,
_chromeNumKeyPadMap,
BrowserDomAdapter,
baseElement,
urlParsingNode;
function getBaseElementHref() {
if (!baseElement) {
baseElement = document.querySelector('base');
if (!baseElement) {
return null;
}
}
return baseElement.getAttribute('href');
}
function relativePath(url) {
if (!urlParsingNode) {
urlParsingNode = document.createElement('a');
}
urlParsingNode.setAttribute('href', url);
return (urlParsingNode.pathname.charAt(0