Template Upload

node_modules/zone.js/lib/browser/browser.ts

@@ -0,0 +1,99 @@
+import '../zone';
+import {eventTargetPatch} from './event-target';
+import {propertyPatch} from './define-property';
+import {registerElementPatch} from './register-element';
+import {propertyDescriptorPatch} from './property-descriptor';
+import {patchMethod, patchPrototype, patchClass} from "./utils";
+
+const set = 'set';
+const clear = 'clear';
+const blockingMethods = ['alert', 'prompt', 'confirm'];
+const _global = typeof window == 'undefined' ? global : window;
+
+patchTimer(_global, set, clear, 'Timeout');
+patchTimer(_global, set, clear, 'Interval');
+patchTimer(_global, set, clear, 'Immediate');
+patchTimer(_global, 'request', 'cancelMacroTask', 'AnimationFrame');
+patchTimer(_global, 'mozRequest', 'mozCancel', 'AnimationFrame');
+patchTimer(_global, 'webkitRequest', 'webkitCancel', 'AnimationFrame')
+
+for (var i = 0; i < blockingMethods.length; i++) {
+  var name = blockingMethods[i];
+  patchMethod(_global, name, (delegate, symbol, name) => {
+    return function (s:any, args: any[]) {
+      return Zone.current.run(delegate, _global, args, name)
+    }
+  });
+}
+
+eventTargetPatch(_global);
+propertyDescriptorPatch(_global);
+patchClass('MutationObserver');
+patchClass('WebKitMutationObserver');
+patchClass('FileReader');
+propertyPatch();
+registerElementPatch(_global);
+
+/// GEO_LOCATION
+if (_global['navigator'] && _global['navigator'].geolocation) {
+  patchPrototype(_global['navigator'].geolocation, [
+    'getCurrentPosition',
+    'watchPosition'
+  ]);
+}
+
+interface TimerOptions extends TaskData {
+  handleId: number,
+  args: any[]
+}
+
+function patchTimer(
+    window: any,
+    setName: string,
+    cancelName: string,
+    nameSuffix: string)
+{
+  setName += nameSuffix;
+  cancelName += nameSuffix;
+
+  function scheduleTask(task: Task) {
+    var data = <TimerOptions>task.data;
+    data.args[0] = task.invoke;
+    data.handleId = setNative.apply(window, data.args);
+    return task;
+  }
+
+  function clearTask(task: Task) {
+    return clearNative((<TimerOptions>task.data).handleId);
+  }
+
+  var setNative = patchMethod(window, setName, (delegate: Function) => function(self: any, args: any[]) {
+    if (typeof args[0] === 'function') {
+      var zone = Zone.current;
+      var options:TimerOptions = {
+        handleId: null,
+        isPeriodic: nameSuffix == 'Interval',
+        delay: (nameSuffix == 'Timeout' || nameSuffix == 'Interval') ? args[1] || 0 : null,
+        args: args
+      };
+      return zone.scheduleMacroTask(setName, args[0], options, scheduleTask, clearTask);
+    } else {
+      // cause an error by calling it directly.
+      return delegate.apply(window, args);
+    }
+  });
+
+  var clearNative = patchMethod(window, cancelName, (delegate: Function) => function(self: any, args: any[]) {
+    var task: Task = args[0];
+    if (task && typeof task.type == 'string') {
+      if (task.cancelFn) {
+        // Do not cancel already canceled functions
+        task.zone.cancelTask(task);
+      }
+    } else {
+      // cause an error by calling it directly.
+      delegate.apply(window, args);
+    }
+  });
+}
+

node_modules/zone.js/lib/browser/define-property.ts

@@ -0,0 +1,67 @@
+import {zoneSymbol} from "./utils";
+
+// might need similar for object.freeze
+// i regret nothing
+
+var _defineProperty = Object.defineProperty;
+var _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var _create = Object.create;
+var unconfigurablesKey = zoneSymbol('unconfigurables');
+
+export function propertyPatch() {
+  Object.defineProperty = function (obj, prop, desc) {
+    if (isUnconfigurable(obj, prop)) {
+      throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
+    }
+    if (prop !== 'prototype') {
+      desc = rewriteDescriptor(obj, prop, desc);
+    }
+    return _defineProperty(obj, prop, desc);
+  };
+
+  Object.defineProperties = function (obj, props) {
+    Object.keys(props).forEach(function (prop) {
+      Object.defineProperty(obj, prop, props[prop]);
+    });
+    return obj;
+  };
+
+  Object.create = function (obj, proto) {
+    if (typeof proto === 'object') {
+      Object.keys(proto).forEach(function (prop) {
+        proto[prop] = rewriteDescriptor(obj, prop, proto[prop]);
+      });
+    }
+    return _create(obj, proto);
+  };
+
+  Object.getOwnPropertyDescriptor = function (obj, prop) {
+    var desc = _getOwnPropertyDescriptor(obj, prop);
+    if (isUnconfigurable(obj, prop)) {
+      desc.configurable = false;
+    }
+    return desc;
+  };
+};
+
+export function _redefineProperty(obj, prop, desc) {
+  desc = rewriteDescriptor(obj, prop, desc);
+  return _defineProperty(obj, prop, desc);
+};
+
+function isUnconfigurable (obj, prop) {
+  return obj && obj[unconfigurablesKey] && obj[unconfigurablesKey][prop];
+}
+
+function rewriteDescriptor (obj, prop, desc) {
+  desc.configurable = true;
+  if (!desc.configurable) {
+    if (!obj[unconfigurablesKey]) {
+      _defineProperty(obj, unconfigurablesKey, { writable: true, value: {} });
+    }
+    obj[unconfigurablesKey][prop] = true;
+  }
+  return desc;
+}
+
+

node_modules/zone.js/lib/browser/event-target.ts

@@ -0,0 +1,25 @@
+import {patchEventTargetMethods} from './utils';
+
+const WTF_ISSUE_555 = 'Anchor,Area,Audio,BR,Base,BaseFont,Body,Button,Canvas,Content,DList,Directory,Div,Embed,FieldSet,Font,Form,Frame,FrameSet,HR,Head,Heading,Html,IFrame,Image,Input,Keygen,LI,Label,Legend,Link,Map,Marquee,Media,Menu,Meta,Meter,Mod,OList,Object,OptGroup,Option,Output,Paragraph,Pre,Progress,Quote,Script,Select,Source,Span,Style,TableCaption,TableCell,TableCol,Table,TableRow,TableSection,TextArea,Title,Track,UList,Unknown,Video';
+const NO_EVENT_TARGET = 'ApplicationCache,EventSource,FileReader,InputMethodContext,MediaController,MessagePort,Node,Performance,SVGElementInstance,SharedWorker,TextTrack,TextTrackCue,TextTrackList,WebKitNamedFlow,Worker,WorkerGlobalScope,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload,IDBRequest,IDBOpenDBRequest,IDBDatabase,IDBTransaction,IDBCursor,DBIndex'.split(',');
+const EVENT_TARGET = 'EventTarget';
+
+export function eventTargetPatch(_global) {
+  var apis = [];
+  var isWtf = _global['wtf'];
+  if (isWtf) {
+    // Workaround for: https://github.com/google/tracing-framework/issues/555
+    apis = WTF_ISSUE_555.split(',').map((v) => 'HTML' + v + 'Element').concat(NO_EVENT_TARGET);
+  } else if (_global[EVENT_TARGET]) {
+    apis.push(EVENT_TARGET);
+  } else {
+    // Note: EventTarget is not available in all browsers,
+    // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget
+    apis = NO_EVENT_TARGET;
+  }
+
+  for (var i = 0; i < apis.length; i++) {
+    var type = _global[apis[i]];
+    patchEventTargetMethods(type && type.prototype);
+  }
+}

node_modules/zone.js/lib/browser/property-descriptor.ts

@@ -0,0 +1,81 @@
+import * as webSocketPatch from './websocket';
+import {zoneSymbol, patchOnProperties, patchClass, isBrowser, isNode} from './utils';
+
+var eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'.split(' ');
+
+export function propertyDescriptorPatch(_global) {
+  if (isNode){
+    return;
+  }
+  
+  var supportsWebSocket = typeof WebSocket !== 'undefined';
+  if (canPatchViaPropertyDescriptor()) {
+    // for browsers that we can patch the descriptor:  Chrome & Firefox
+    if (isBrowser) {
+      patchOnProperties(HTMLElement.prototype, eventNames);
+    }
+    patchOnProperties(XMLHttpRequest.prototype, null);
+    if (typeof IDBIndex !== 'undefined') {
+      patchOnProperties(IDBIndex.prototype, null);
+      patchOnProperties(IDBRequest.prototype, null);
+      patchOnProperties(IDBOpenDBRequest.prototype, null);
+      patchOnProperties(IDBDatabase.prototype, null);
+      patchOnProperties(IDBTransaction.prototype, null);
+      patchOnProperties(IDBCursor.prototype, null);
+    }
+    if (supportsWebSocket) {
+      patchOnProperties(WebSocket.prototype, null);
+    }
+  } else {
+    // Safari, Android browsers (Jelly Bean)
+    patchViaCapturingAllTheEvents();
+    patchClass('XMLHttpRequest');
+    if (supportsWebSocket) {
+      webSocketPatch.apply(_global);
+    }
+  }
+}
+
+function canPatchViaPropertyDescriptor() {
+  if (isBrowser && !Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick')
+      && typeof Element !== 'undefined') {
+    // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364
+    // IDL interface attributes are not configurable
+    var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick');
+    if (desc && !desc.configurable) return false;
+  }
+
+  Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {
+    get: function () {
+      return true;
+    }
+  });
+  var req = new XMLHttpRequest();
+  var result = !!req.onreadystatechange;
+  Object.defineProperty(XMLHttpRequest.prototype, 'onreadystatechange', {});
+  return result;
+};
+
+var unboundKey = zoneSymbol('unbound');
+
+// Whenever any eventListener fires, we check the eventListener target and all parents
+// for `onwhatever` properties and replace them with zone-bound functions
+// - Chrome (for now)
+function patchViaCapturingAllTheEvents() {
+  for(var i = 0; i < eventNames.length; i++) {
+    var property = eventNames[i];
+    var onproperty = 'on' + property;
+    document.addEventListener(property, function (event) {
+      var elt = <Node>event.target, bound;
+      var source = elt.constructor['name'] + '.' + onproperty;
+      while (elt) {
+        if (elt[onproperty] && !elt[onproperty][unboundKey]) {
+          bound = Zone.current.wrap(elt[onproperty], source);
+          bound[unboundKey] = elt[onproperty];
+          elt[onproperty] = bound;
+        }
+        elt = elt.parentElement;
+      }
+    }, true);
+  };
+};

node_modules/zone.js/lib/browser/register-element.ts

@@ -0,0 +1,37 @@
+import {_redefineProperty} from './define-property';
+import {isBrowser} from './utils';
+
+export function registerElementPatch(_global: any) {
+  if (!isBrowser || !('registerElement' in (<any>_global).document)) {
+    return;
+  }
+
+  var _registerElement = (<any>document).registerElement;
+  var callbacks = [
+    'createdCallback',
+    'attachedCallback',
+    'detachedCallback',
+    'attributeChangedCallback'
+  ];
+
+  (<any>document).registerElement = function (name, opts) {
+    if (opts && opts.prototype) {
+      callbacks.forEach(function (callback) {
+        var source = 'Document.registerElement::' + callback;
+        if (opts.prototype.hasOwnProperty(callback)) {
+          var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback);
+          if (descriptor && descriptor.value) {
+            descriptor.value = Zone.current.wrap(descriptor.value, source);
+            _redefineProperty(opts.prototype, callback, descriptor);
+          } else {
+            opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+          }
+        } else if (opts.prototype[callback]) {
+          opts.prototype[callback] = Zone.current.wrap(opts.prototype[callback], source);
+        }
+      });
+    }
+
+    return _registerElement.apply(document, [name, opts]);
+  };
+}

node_modules/zone.js/lib/browser/utils.ts

@@ -0,0 +1,320 @@
+/**
+ * Suppress closure compiler errors about unknown 'process' variable
+ * @fileoverview
+ * @suppress {undefinedVars}
+ */
+
+// Hack since TypeScript isn't compiling this for a worker.
+declare var WorkerGlobalScope;
+export var zoneSymbol: (name: string) => string = Zone['__symbol__'];
+const _global = typeof window == 'undefined' ? global : window;
+
+export function bindArguments(args: any[], source: string): any[] {
+  for (var i = args.length - 1; i >= 0; i--) {
+    if (typeof args[i] === 'function') {
+      args[i] = Zone.current.wrap(args[i], source + '_' + i);
+    }
+  }
+  return args;
+};
+
+export function patchPrototype(prototype, fnNames) {
+  var source = prototype.constructor['name'];
+  for (var i = 0; i < fnNames.length; i++) {
+    var name = fnNames[i];
+    var delegate = prototype[name];
+    if (delegate) {
+      prototype[name] = ((delegate: Function) => {
+        return function() {
+          return delegate.apply(this, bindArguments(<any>arguments, source + '.' + name));
+        };
+      })(delegate);
+    }
+  }
+};
+
+export var isWebWorker: boolean =
+    (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope);
+
+export var isNode: boolean =
+  (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]');
+
+export var isBrowser: boolean =
+    !isNode && !isWebWorker && !!(window && window['HTMLElement']);
+
+
+export function patchProperty(obj, prop) {
+  var desc = Object.getOwnPropertyDescriptor(obj, prop) || {
+    enumerable: true,
+    configurable: true
+  };
+
+  // A property descriptor cannot have getter/setter and be writable
+  // deleting the writable and value properties avoids this error:
+  //
+  // TypeError: property descriptors must not specify a value or be writable when a
+  // getter or setter has been specified
+  delete desc.writable;
+  delete desc.value;
+
+  // substr(2) cuz 'onclick' -> 'click', etc
+  var eventName = prop.substr(2);
+  var _prop = '_' + prop;
+
+  desc.set = function (fn) {
+    if (this[_prop]) {
+      this.removeEventListener(eventName, this[_prop]);
+    }
+
+    if (typeof fn === 'function') {
+      var wrapFn = function (event) {
+        var result;
+        result = fn.apply(this, arguments);
+
+        if (result != undefined && !result)
+          event.preventDefault();
+      };
+
+      this[_prop] = wrapFn;
+      this.addEventListener(eventName, wrapFn, false);
+    } else {
+      this[_prop] = null;
+    }
+  };
+
+  desc.get = function () {
+    return this[_prop];
+  };
+
+  Object.defineProperty(obj, prop, desc);
+};
+
+export function patchOnProperties(obj: any, properties: string[]) {
+  var onProperties = [];
+  for (var prop in obj) {
+    if (prop.substr(0, 2) == 'on') {
+      onProperties.push(prop);
+    }
+  }
+  for(var j = 0; j < onProperties.length; j++) {
+    patchProperty(obj, onProperties[j]);
+  }
+  if (properties) {
+    for(var i = 0; i < properties.length; i++) {
+      patchProperty(obj, 'on' + properties[i]);
+    }
+  }
+};
+
+const EVENT_TASKS = zoneSymbol('eventTasks');
+const ADD_EVENT_LISTENER = 'addEventListener';
+const REMOVE_EVENT_LISTENER = 'removeEventListener';
+const SYMBOL_ADD_EVENT_LISTENER = zoneSymbol(ADD_EVENT_LISTENER);
+const SYMBOL_REMOVE_EVENT_LISTENER = zoneSymbol(REMOVE_EVENT_LISTENER);
+
+interface ListenerTaskMeta extends TaskData {
+  useCapturing: boolean,
+  eventName: string,
+  handler: any,
+  target: any,
+  name: any
+}
+
+function findExistingRegisteredTask(target: any, handler: any, name: string, capture: boolean,
+                                    remove: boolean): Task {
+  var eventTasks: Task[] = target[EVENT_TASKS];
+  if (eventTasks) {
+    for (var i = 0; i < eventTasks.length; i++) {
+      var eventTask = eventTasks[i];
+      var data = <ListenerTaskMeta>eventTask.data;
+      if (data.handler === handler
+          && data.useCapturing === capture
+          && data.eventName === name)
+      {
+        if (remove) {
+          eventTasks.splice(i, 1);
+        }
+        return eventTask;
+      }
+    }
+  }
+  return null;
+}
+
+
+function attachRegisteredEvent(target: any, eventTask: Task): void {
+  var eventTasks: Task[] = target[EVENT_TASKS];
+  if (!eventTasks) {
+    eventTasks = target[EVENT_TASKS] = [];
+  }
+  eventTasks.push(eventTask);
+}
+
+function scheduleEventListener(eventTask: Task): any {
+  var meta = <ListenerTaskMeta>eventTask.data;
+  attachRegisteredEvent(meta.target, eventTask);
+  return meta.target[SYMBOL_ADD_EVENT_LISTENER](meta.eventName, eventTask.invoke,
+      meta.useCapturing);
+}
+
+function cancelEventListener(eventTask: Task): void {
+  var meta = <ListenerTaskMeta>eventTask.data;
+  findExistingRegisteredTask(meta.target, eventTask.invoke, meta.eventName,
+      meta.useCapturing, true);
+  meta.target[SYMBOL_REMOVE_EVENT_LISTENER](meta.eventName, eventTask.invoke,
+      meta.useCapturing);
+}
+
+function zoneAwareAddEventListener(self: any, args: any[]) {
+  var eventName: string = args[0];
+  var handler: EventListenerOrEventListenerObject = args[1];
+  var useCapturing: boolean = args[2] || false;
+  // - Inside a Web Worker, `this` is undefined, the context is `global`
+  // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+  // see https://github.com/angular/zone.js/issues/190
+  var target = self || _global;
+  var delegate: EventListener = null;
+  if (typeof handler == 'function') {
+    delegate = <EventListener>handler;
+  } else if (handler && (<EventListenerObject>handler).handleEvent) {
+    delegate = (event) => (<EventListenerObject>handler).handleEvent(event);
+  }
+  // Ignore special listeners of IE11 & Edge dev tools, see https://github.com/angular/zone.js/issues/150
+  if (!delegate || handler && handler.toString() === "[object FunctionWrapper]") {
+    return target[SYMBOL_ADD_EVENT_LISTENER](eventName, handler, useCapturing);
+  }
+  var eventTask: Task
+      = findExistingRegisteredTask(target, handler, eventName, useCapturing, false);
+  if (eventTask) {
+    // we already registered, so this will have noop.
+    return target[SYMBOL_ADD_EVENT_LISTENER](eventName, eventTask.invoke, useCapturing);
+  }
+  var zone: Zone = Zone.current;
+  var source = target.constructor['name'] + '.addEventListener:' + eventName;
+  var data: ListenerTaskMeta = {
+    target: target,
+    eventName: eventName,
+    name: eventName,
+    useCapturing: useCapturing,
+    handler: handler
+  };
+  zone.scheduleEventTask(source, delegate, data, scheduleEventListener, cancelEventListener);
+}
+
+function zoneAwareRemoveEventListener(self: any, args: any[]) {
+  var eventName: string = args[0];
+  var handler: EventListenerOrEventListenerObject = args[1];
+  var useCapturing: boolean = args[2] || false;
+  // - Inside a Web Worker, `this` is undefined, the context is `global`
+  // - When `addEventListener` is called on the global context in strict mode, `this` is undefined
+  // see https://github.com/angular/zone.js/issues/190
+  var target = self || _global;
+  var eventTask = findExistingRegisteredTask(target, handler, eventName, useCapturing, true);
+  if (eventTask) {
+    eventTask.zone.cancelTask(eventTask);
+  } else {
+    target[SYMBOL_REMOVE_EVENT_LISTENER](eventName, handler, useCapturing);
+  }
+}
+
+export function patchEventTargetMethods(obj: any): boolean {
+  if (obj && obj.addEventListener) {
+    patchMethod(obj, ADD_EVENT_LISTENER, () => zoneAwareAddEventListener);
+    patchMethod(obj, REMOVE_EVENT_LISTENER, () => zoneAwareRemoveEventListener);
+    return true;
+  } else {
+    return false;
+  }
+};
+
+var originalInstanceKey = zoneSymbol('originalInstance');
+
+// wrap some native API on `window`
+export function patchClass(className) {
+  var OriginalClass = _global[className];
+  if (!OriginalClass) return;
+
+  _global[className] = function () {
+    var a = bindArguments(<any>arguments, className);
+    switch (a.length) {
+      case 0: this[originalInstanceKey] = new OriginalClass(); break;
+      case 1: this[originalInstanceKey] = new OriginalClass(a[0]); break;
+      case 2: this[originalInstanceKey] = new OriginalClass(a[0], a[1]); break;
+      case 3: this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2]); break;
+      case 4: this[originalInstanceKey] = new OriginalClass(a[0], a[1], a[2], a[3]); break;
+      default: throw new Error('Arg list too long.');
+    }
+  };
+
+  var instance = new OriginalClass(function () {});
+
+  var prop;
+  for (prop in instance) {
+    (function (prop) {
+      if (typeof instance[prop] === 'function') {
+        _global[className].prototype[prop] = function () {
+          return this[originalInstanceKey][prop].apply(this[originalInstanceKey], arguments);
+        };
+      } else {
+        Object.defineProperty(_global[className].prototype, prop, {
+          set: function (fn) {
+            if (typeof fn === 'function') {
+              this[originalInstanceKey][prop] = Zone.current.wrap(fn, className + '.' + prop);
+            } else {
+              this[originalInstanceKey][prop] = fn;
+            }
+          },
+          get: function () {
+            return this[originalInstanceKey][prop];
+          }
+        });
+      }
+    }(prop));
+  }
+
+  for (prop in OriginalClass) {
+    if (prop !== 'prototype' && OriginalClass.hasOwnProperty(prop)) {
+      _global[className][prop] = OriginalClass[prop];
+    }
+  }
+};
+
+export function createNamedFn(
+    name: string,
+    delegate: (self: any, args: any[]) => any): Function
+{
+  try {
+    return (Function(
+        'f',
+        `return function ${name}(){return f(this, arguments)}`)
+    )(delegate);
+  } catch (e) {
+    // if we fail, we must be CSP, just return delegate.
+    return function() {
+      return delegate(this, <any>arguments);
+    };
+  }
+}
+
+export function patchMethod(target: any, name: string,
+                            patchFn: (delegate: Function,
+                                      delegateName: string,
+                                      name: string) => (self: any, args: any[]) => any): Function
+{
+  var proto = target;
+  while (proto && !proto.hasOwnProperty(name)) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  if (!proto && target[name]) {
+    // somehow we did not find it, but we can see it. This happens on IE for Window properties.
+    proto = target;
+  }
+  var delegateName = zoneSymbol(name);
+  var delegate: Function;
+  if (proto && ! (delegate = proto[delegateName])) {
+    delegate = proto[delegateName] = proto[name];
+    proto[name] = createNamedFn(name, patchFn(delegate, delegateName, name));
+  }
+  return delegate;
+}
+

node_modules/zone.js/lib/browser/websocket.ts

@@ -0,0 +1,34 @@
+import {patchEventTargetMethods, patchOnProperties} from './utils';
+
+// we have to patch the instance since the proto is non-configurable
+export function apply(_global: any) {
+  var WS = (<any>_global).WebSocket;
+  // On Safari window.EventTarget doesn't exist so need to patch WS add/removeEventListener
+  // On older Chrome, no need since EventTarget was already patched
+  if (!(<any>_global).EventTarget) {
+    patchEventTargetMethods(WS.prototype);
+  }
+  (<any>_global).WebSocket = function(a, b) {
+    var socket = arguments.length > 1 ? new WS(a, b) : new WS(a);
+    var proxySocket;
+
+    // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance
+    var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage');
+    if (onmessageDesc && onmessageDesc.configurable === false) {
+      proxySocket = Object.create(socket);
+      ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function(propName) {
+        proxySocket[propName] = function() {
+          return socket[propName].apply(socket, arguments);
+        };
+      });
+    } else {
+      // we can patch the real socket
+      proxySocket = socket;
+    }
+
+    patchOnProperties(proxySocket, ['close', 'error', 'message', 'open']);
+
+    return proxySocket;
+  };
+  (<any>global).WebSocket.prototype = Object.create(WS.prototype, {constructor:{value: WebSocket}});
+}