zmdms-utils 0.0.79 → 0.0.81

package/dist/es/node_modules/zt-sockjs-client/lib/transport/xdr-streaming.js

@@ -0,0 +1,38 @@
+import '../../../inherits/inherits.js';
+import ajaxBased from './lib/ajax-based.js';
+import xhr from './receiver/xhr.js';
+import xdr from './sender/xdr.js';
+import { exports as inheritsExports } from '../../../../_virtual/inherits.js';
+
+var inherits = inheritsExports
+  , AjaxBasedTransport = ajaxBased
+  , XhrReceiver = xhr
+  , XDRObject = xdr
+  ;
+
+// According to:
+//   http://stackoverflow.com/questions/1641507/detect-browser-support-for-cross-domain-xmlhttprequests
+//   http://hacks.mozilla.org/2009/07/cross-site-xmlhttprequest-with-cors/
+
+function XdrStreamingTransport(transUrl) {
+  if (!XDRObject.enabled) {
+    throw new Error('Transport created when disabled');
+  }
+  AjaxBasedTransport.call(this, transUrl, '/xhr_streaming', XhrReceiver, XDRObject);
+}
+
+inherits(XdrStreamingTransport, AjaxBasedTransport);
+
+XdrStreamingTransport.enabled = function(info) {
+  if (info.cookie_needed || info.nullOrigin) {
+    return false;
+  }
+  return XDRObject.enabled && info.sameScheme;
+};
+
+XdrStreamingTransport.transportName = 'xdr-streaming';
+XdrStreamingTransport.roundTrips = 2; // preflight, ajax
+
+var xdrStreaming = XdrStreamingTransport;
+
+export { xdrStreaming as default };

package/dist/es/node_modules/zt-sockjs-client/lib/transport/xhr-polling.js

@@ -0,0 +1,40 @@
+import '../../../inherits/inherits.js';
+import ajaxBased from './lib/ajax-based.js';
+import xhr from './receiver/xhr.js';
+import xhrCors from './sender/xhr-cors.js';
+import xhrLocal from './sender/xhr-local.js';
+import { exports as inheritsExports } from '../../../../_virtual/inherits.js';
+
+var inherits = inheritsExports
+  , AjaxBasedTransport = ajaxBased
+  , XhrReceiver = xhr
+  , XHRCorsObject = xhrCors
+  , XHRLocalObject = xhrLocal
+  ;
+
+function XhrPollingTransport(transUrl) {
+  if (!XHRLocalObject.enabled && !XHRCorsObject.enabled) {
+    throw new Error('Transport created when disabled');
+  }
+  AjaxBasedTransport.call(this, transUrl, '/xhr', XhrReceiver, XHRCorsObject);
+}
+
+inherits(XhrPollingTransport, AjaxBasedTransport);
+
+XhrPollingTransport.enabled = function(info) {
+  if (info.nullOrigin) {
+    return false;
+  }
+
+  if (XHRLocalObject.enabled && info.sameOrigin) {
+    return true;
+  }
+  return XHRCorsObject.enabled;
+};
+
+XhrPollingTransport.transportName = 'xhr-polling';
+XhrPollingTransport.roundTrips = 2; // preflight, ajax
+
+var xhrPolling = XhrPollingTransport;
+
+export { xhrPolling as default };

package/dist/es/node_modules/zt-sockjs-client/lib/transport/xhr-streaming.js

@@ -0,0 +1,50 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+import '../../../inherits/inherits.js';
+import ajaxBased from './lib/ajax-based.js';
+import xhr from './receiver/xhr.js';
+import xhrCors from './sender/xhr-cors.js';
+import xhrLocal from './sender/xhr-local.js';
+import browser$1 from '../utils/browser.js';
+import { exports as inheritsExports } from '../../../../_virtual/inherits.js';
+
+var inherits = inheritsExports
+  , AjaxBasedTransport = ajaxBased
+  , XhrReceiver = xhr
+  , XHRCorsObject = xhrCors
+  , XHRLocalObject = xhrLocal
+  , browser = browser$1
+  ;
+
+function XhrStreamingTransport(transUrl) {
+  if (!XHRLocalObject.enabled && !XHRCorsObject.enabled) {
+    throw new Error('Transport created when disabled');
+  }
+  AjaxBasedTransport.call(this, transUrl, '/xhr_streaming', XhrReceiver, XHRCorsObject);
+}
+
+inherits(XhrStreamingTransport, AjaxBasedTransport);
+
+XhrStreamingTransport.enabled = function(info) {
+  if (info.nullOrigin) {
+    return false;
+  }
+  // Opera doesn't support xhr-streaming #60
+  // But it might be able to #92
+  if (browser.isOpera()) {
+    return false;
+  }
+
+  return XHRCorsObject.enabled;
+};
+
+XhrStreamingTransport.transportName = 'xhr-streaming';
+XhrStreamingTransport.roundTrips = 2; // preflight, ajax
+
+// Safari gets confused when a streaming ajax request is started
+// before onload. This causes the load indicator to spin indefinetely.
+// Only require body when used in a browser
+XhrStreamingTransport.needBody = !!commonjsGlobal.document;
+
+var xhrStreaming = XhrStreamingTransport;
+
+export { xhrStreaming as default };

package/dist/es/node_modules/zt-sockjs-client/lib/transport-list.js

@@ -0,0 +1,28 @@
+import websocket from './transport/websocket.js';
+import xhrStreaming from './transport/xhr-streaming.js';
+import xdrStreaming from './transport/xdr-streaming.js';
+import eventsource from './transport/eventsource.js';
+import iframeWrap from './transport/lib/iframe-wrap.js';
+import htmlfile from './transport/htmlfile.js';
+import xhrPolling from './transport/xhr-polling.js';
+import xdrPolling from './transport/xdr-polling.js';
+import jsonpPolling from './transport/jsonp-polling.js';
+
+var transportList = [
+  // streaming transports
+  websocket
+, xhrStreaming
+, xdrStreaming
+, eventsource
+, iframeWrap(eventsource)
+
+  // polling transports
+, htmlfile
+, iframeWrap(htmlfile)
+, xhrPolling
+, xdrPolling
+, iframeWrap(xhrPolling)
+, jsonpPolling
+];
+
+export { transportList as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/browser.js

@@ -0,0 +1,29 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+
+var browser = {
+  isOpera: function() {
+    return commonjsGlobal.navigator &&
+      /opera/i.test(commonjsGlobal.navigator.userAgent);
+  }
+
+, isKonqueror: function() {
+    return commonjsGlobal.navigator &&
+      /konqueror/i.test(commonjsGlobal.navigator.userAgent);
+  }
+
+  // #187 wrap document.domain in try/catch because of WP8 from file:///
+, hasDomain: function () {
+    // non-browser client always has a domain
+    if (!commonjsGlobal.document) {
+      return true;
+    }
+
+    try {
+      return !!commonjsGlobal.document.domain;
+    } catch (e) {
+      return false;
+    }
+  }
+};
+
+export { browser as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/escape.js

@@ -0,0 +1,53 @@
+import '../../../json3/lib/json3.js';
+import { exports as json3Exports } from '../../../../_virtual/json3.js';
+
+var JSON3 = json3Exports;
+
+// Some extra characters that Chrome gets wrong, and substitutes with
+// something else on the wire.
+// eslint-disable-next-line no-control-regex, no-misleading-character-class
+var extraEscapable = /[\x00-\x1f\ud800-\udfff\ufffe\uffff\u0300-\u0333\u033d-\u0346\u034a-\u034c\u0350-\u0352\u0357-\u0358\u035c-\u0362\u0374\u037e\u0387\u0591-\u05af\u05c4\u0610-\u0617\u0653-\u0654\u0657-\u065b\u065d-\u065e\u06df-\u06e2\u06eb-\u06ec\u0730\u0732-\u0733\u0735-\u0736\u073a\u073d\u073f-\u0741\u0743\u0745\u0747\u07eb-\u07f1\u0951\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e38-\u0e39\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f72-\u0f76\u0f78\u0f80-\u0f83\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1939-\u193a\u1a17\u1b6b\u1cda-\u1cdb\u1dc0-\u1dcf\u1dfc\u1dfe\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u20d0-\u20d1\u20d4-\u20d7\u20e7-\u20e9\u2126\u212a-\u212b\u2329-\u232a\u2adc\u302b-\u302c\uaab2-\uaab3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa2d\ufa30-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\ufff0-\uffff]/g
+  , extraLookup;
+
+// This may be quite slow, so let's delay until user actually uses bad
+// characters.
+var unrollLookup = function(escapable) {
+  var i;
+  var unrolled = {};
+  var c = [];
+  for (i = 0; i < 65536; i++) {
+    c.push( String.fromCharCode(i) );
+  }
+  escapable.lastIndex = 0;
+  c.join('').replace(escapable, function(a) {
+    unrolled[ a ] = '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+    return '';
+  });
+  escapable.lastIndex = 0;
+  return unrolled;
+};
+
+// Quote string, also taking care of unicode characters that browsers
+// often break. Especially, take care of unicode surrogates:
+// http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Surrogates
+var _escape = {
+  quote: function(string) {
+    var quoted = JSON3.stringify(string);
+
+    // In most cases this should be very fast and good enough.
+    extraEscapable.lastIndex = 0;
+    if (!extraEscapable.test(quoted)) {
+      return quoted;
+    }
+
+    if (!extraLookup) {
+      extraLookup = unrollLookup(extraEscapable);
+    }
+
+    return quoted.replace(extraEscapable, function(a) {
+      return extraLookup[a];
+    });
+  }
+};
+
+export { _escape as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/event.js

@@ -0,0 +1,78 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+import { __module as event } from '../../../../_virtual/event.js';
+import random from './random.js';
+
+(function (module) {
+
+	var random$1 = random;
+
+	var onUnload = {}
+	  , afterUnload = false
+	    // detect google chrome packaged apps because they don't allow the 'unload' event
+	  , isChromePackagedApp = commonjsGlobal.chrome && commonjsGlobal.chrome.app && commonjsGlobal.chrome.app.runtime
+	  ;
+
+	module.exports = {
+	  attachEvent: function(event, listener) {
+	    if (typeof commonjsGlobal.addEventListener !== 'undefined') {
+	      commonjsGlobal.addEventListener(event, listener, false);
+	    } else if (commonjsGlobal.document && commonjsGlobal.attachEvent) {
+	      // IE quirks.
+	      // According to: http://stevesouders.com/misc/test-postmessage.php
+	      // the message gets delivered only to 'document', not 'window'.
+	      commonjsGlobal.document.attachEvent('on' + event, listener);
+	      // I get 'window' for ie8.
+	      commonjsGlobal.attachEvent('on' + event, listener);
+	    }
+	  }
+
+	, detachEvent: function(event, listener) {
+	    if (typeof commonjsGlobal.addEventListener !== 'undefined') {
+	      commonjsGlobal.removeEventListener(event, listener, false);
+	    } else if (commonjsGlobal.document && commonjsGlobal.detachEvent) {
+	      commonjsGlobal.document.detachEvent('on' + event, listener);
+	      commonjsGlobal.detachEvent('on' + event, listener);
+	    }
+	  }
+
+	, unloadAdd: function(listener) {
+	    if (isChromePackagedApp) {
+	      return null;
+	    }
+
+	    var ref = random$1.string(8);
+	    onUnload[ref] = listener;
+	    if (afterUnload) {
+	      setTimeout(this.triggerUnloadCallbacks, 0);
+	    }
+	    return ref;
+	  }
+
+	, unloadDel: function(ref) {
+	    if (ref in onUnload) {
+	      delete onUnload[ref];
+	    }
+	  }
+
+	, triggerUnloadCallbacks: function() {
+	    for (var ref in onUnload) {
+	      onUnload[ref]();
+	      delete onUnload[ref];
+	    }
+	  }
+	};
+
+	var unloadTriggered = function() {
+	  if (afterUnload) {
+	    return;
+	  }
+	  afterUnload = true;
+	  module.exports.triggerUnloadCallbacks();
+	};
+
+	// 'unload' alone is not reliable in opera within an iframe, but we
+	// can't use `beforeunload` as IE fires it on javascript: links.
+	if (!isChromePackagedApp) {
+	  module.exports.attachEvent('unload', unloadTriggered);
+	}
+} (event));

package/dist/es/node_modules/zt-sockjs-client/lib/utils/iframe.js

@@ -0,0 +1,205 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+import { exports as iframeExports, __module as iframe } from '../../../../_virtual/iframe.js';
+import './event.js';
+import '../../../json3/lib/json3.js';
+import browser from './browser.js';
+import { __require as requireSrc } from '../../../debug/src/index.js';
+import { exports as eventExports } from '../../../../_virtual/event.js';
+import { exports as json3Exports } from '../../../../_virtual/json3.js';
+
+var hasRequiredIframe;
+
+function requireIframe () {
+	if (hasRequiredIframe) return iframeExports;
+	hasRequiredIframe = 1;
+	(function (module) {
+
+		var eventUtils = eventExports
+		  , JSON3 = json3Exports
+		  , browser$1 = browser
+		  ;
+
+		var debug = function() {};
+		if (process.env.NODE_ENV !== 'production') {
+		  debug = requireSrc()('sockjs-client:utils:iframe');
+		}
+
+		module.exports = {
+		  WPrefix: '_jp'
+		, currentWindowId: null
+
+		, polluteGlobalNamespace: function() {
+		    if (!(module.exports.WPrefix in commonjsGlobal)) {
+		      commonjsGlobal[module.exports.WPrefix] = {};
+		    }
+		  }
+
+		, postMessage: function(type, data) {
+		    if (commonjsGlobal.parent !== commonjsGlobal) {
+		      commonjsGlobal.parent.postMessage(JSON3.stringify({
+		        windowId: module.exports.currentWindowId
+		      , type: type
+		      , data: data || ''
+		      }), '*');
+		    } else {
+		      debug('Cannot postMessage, no parent window.', type, data);
+		    }
+		  }
+
+		, createIframe: function(iframeUrl, errorCallback) {
+		    var iframe = commonjsGlobal.document.createElement('iframe');
+		    var tref, unloadRef;
+		    var unattach = function() {
+		      debug('unattach');
+		      clearTimeout(tref);
+		      // Explorer had problems with that.
+		      try {
+		        iframe.onload = null;
+		      } catch (x) {
+		        // intentionally empty
+		      }
+		      iframe.onerror = null;
+		    };
+		    var cleanup = function() {
+		      debug('cleanup');
+		      if (iframe) {
+		        unattach();
+		        // This timeout makes chrome fire onbeforeunload event
+		        // within iframe. Without the timeout it goes straight to
+		        // onunload.
+		        setTimeout(function() {
+		          if (iframe) {
+		            iframe.parentNode.removeChild(iframe);
+		          }
+		          iframe = null;
+		        }, 0);
+		        eventUtils.unloadDel(unloadRef);
+		      }
+		    };
+		    var onerror = function(err) {
+		      debug('onerror', err);
+		      if (iframe) {
+		        cleanup();
+		        errorCallback(err);
+		      }
+		    };
+		    var post = function(msg, origin) {
+		      debug('post', msg, origin);
+		      setTimeout(function() {
+		        try {
+		          // When the iframe is not loaded, IE raises an exception
+		          // on 'contentWindow'.
+		          if (iframe && iframe.contentWindow) {
+		            iframe.contentWindow.postMessage(msg, origin);
+		          }
+		        } catch (x) {
+		          // intentionally empty
+		        }
+		      }, 0);
+		    };
+
+		    iframe.src = iframeUrl;
+		    iframe.style.display = 'none';
+		    iframe.style.position = 'absolute';
+		    iframe.onerror = function() {
+		      onerror('onerror');
+		    };
+		    iframe.onload = function() {
+		      debug('onload');
+		      // `onload` is triggered before scripts on the iframe are
+		      // executed. Give it few seconds to actually load stuff.
+		      clearTimeout(tref);
+		      tref = setTimeout(function() {
+		        onerror('onload timeout');
+		      }, 2000);
+		    };
+		    commonjsGlobal.document.body.appendChild(iframe);
+		    tref = setTimeout(function() {
+		      onerror('timeout');
+		    }, 15000);
+		    unloadRef = eventUtils.unloadAdd(cleanup);
+		    return {
+		      post: post
+		    , cleanup: cleanup
+		    , loaded: unattach
+		    };
+		  }
+
+		/* eslint no-undef: "off", new-cap: "off" */
+		, createHtmlfile: function(iframeUrl, errorCallback) {
+		    var axo = ['Active'].concat('Object').join('X');
+		    var doc = new commonjsGlobal[axo]('htmlfile');
+		    var tref, unloadRef;
+		    var iframe;
+		    var unattach = function() {
+		      clearTimeout(tref);
+		      iframe.onerror = null;
+		    };
+		    var cleanup = function() {
+		      if (doc) {
+		        unattach();
+		        eventUtils.unloadDel(unloadRef);
+		        iframe.parentNode.removeChild(iframe);
+		        iframe = doc = null;
+		        CollectGarbage();
+		      }
+		    };
+		    var onerror = function(r) {
+		      debug('onerror', r);
+		      if (doc) {
+		        cleanup();
+		        errorCallback(r);
+		      }
+		    };
+		    var post = function(msg, origin) {
+		      try {
+		        // When the iframe is not loaded, IE raises an exception
+		        // on 'contentWindow'.
+		        setTimeout(function() {
+		          if (iframe && iframe.contentWindow) {
+		              iframe.contentWindow.postMessage(msg, origin);
+		          }
+		        }, 0);
+		      } catch (x) {
+		        // intentionally empty
+		      }
+		    };
+
+		    doc.open();
+		    doc.write('<html><s' + 'cript>' +
+		              'document.domain="' + commonjsGlobal.document.domain + '";' +
+		              '</s' + 'cript></html>');
+		    doc.close();
+		    doc.parentWindow[module.exports.WPrefix] = commonjsGlobal[module.exports.WPrefix];
+		    var c = doc.createElement('div');
+		    doc.body.appendChild(c);
+		    iframe = doc.createElement('iframe');
+		    c.appendChild(iframe);
+		    iframe.src = iframeUrl;
+		    iframe.onerror = function() {
+		      onerror('onerror');
+		    };
+		    tref = setTimeout(function() {
+		      onerror('timeout');
+		    }, 15000);
+		    unloadRef = eventUtils.unloadAdd(cleanup);
+		    return {
+		      post: post
+		    , cleanup: cleanup
+		    , loaded: unattach
+		    };
+		  }
+		};
+
+		module.exports.iframeEnabled = false;
+		if (commonjsGlobal.document) {
+		  // postMessage misbehaves in konqueror 4.6.5 - the messages are delivered with
+		  // huge delay, or not at all.
+		  module.exports.iframeEnabled = (typeof commonjsGlobal.postMessage === 'function' ||
+		    typeof commonjsGlobal.postMessage === 'object') && (!browser$1.isKonqueror());
+		}
+} (iframe));
+	return iframeExports;
+}
+
+export { requireIframe as __require };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/log.js

@@ -0,0 +1,20 @@
+import { commonjsGlobal } from '../../../../_virtual/_commonjsHelpers.js';
+
+var logObject = {};
+['log', 'debug', 'warn'].forEach(function (level) {
+  var levelExists;
+
+  try {
+    levelExists = commonjsGlobal.console && commonjsGlobal.console[level] && commonjsGlobal.console[level].apply;
+  } catch(e) {
+    // do nothing
+  }
+
+  logObject[level] = levelExists ? function () {
+    return commonjsGlobal.console[level].apply(commonjsGlobal.console, arguments);
+  } : (level === 'log' ? function () {} : logObject.log);
+});
+
+var log = logObject;
+
+export { log as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/object.js

@@ -0,0 +1,24 @@
+var object = {
+  isObject: function(obj) {
+    var type = typeof obj;
+    return type === 'function' || type === 'object' && !!obj;
+  }
+
+, extend: function(obj) {
+    if (!this.isObject(obj)) {
+      return obj;
+    }
+    var source, prop;
+    for (var i = 1, length = arguments.length; i < length; i++) {
+      source = arguments[i];
+      for (prop in source) {
+        if (Object.prototype.hasOwnProperty.call(source, prop)) {
+          obj[prop] = source[prop];
+        }
+      }
+    }
+    return obj;
+  }
+};
+
+export { object as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/random.js

@@ -0,0 +1,30 @@
+import require$$0 from 'crypto';
+
+var crypto = require$$0;
+
+// This string has length 32, a power of 2, so the modulus doesn't introduce a
+// bias.
+var _randomStringChars = 'abcdefghijklmnopqrstuvwxyz012345';
+var random = {
+  string: function(length) {
+    var max = _randomStringChars.length;
+    var bytes = crypto.randomBytes(length);
+    var ret = [];
+    for (var i = 0; i < length; i++) {
+      ret.push(_randomStringChars.substr(bytes[i] % max, 1));
+    }
+    return ret.join('');
+  }
+
+, number: function(max) {
+    return Math.floor(Math.random() * max);
+  }
+
+, numberString: function(max) {
+    var t = ('' + (max - 1)).length;
+    var p = new Array(t + 1).join('0');
+    return (p + this.number(max)).slice(-t);
+  }
+};
+
+export { random as default };

package/dist/es/node_modules/zt-sockjs-client/lib/utils/transport.js

@@ -0,0 +1,52 @@
+import { __require as requireSrc } from '../../../debug/src/index.js';
+
+var debug = function() {};
+if (process.env.NODE_ENV !== 'production') {
+  debug = requireSrc()('sockjs-client:utils:transport');
+}
+
+var transport = function(availableTransports) {
+  return {
+    filterToEnabled: function(transportsWhitelist, info) {
+      var transports = {
+        main: []
+      , facade: []
+      };
+      if (!transportsWhitelist) {
+        transportsWhitelist = [];
+      } else if (typeof transportsWhitelist === 'string') {
+        transportsWhitelist = [transportsWhitelist];
+      }
+
+      availableTransports.forEach(function(trans) {
+        if (!trans) {
+          return;
+        }
+
+        if (trans.transportName === 'websocket' && info.websocket === false) {
+          debug('disabled from server', 'websocket');
+          return;
+        }
+
+        if (transportsWhitelist.length &&
+            transportsWhitelist.indexOf(trans.transportName) === -1) {
+          debug('not in whitelist', trans.transportName);
+          return;
+        }
+
+        if (trans.enabled(info)) {
+          debug('enabled', trans.transportName);
+          transports.main.push(trans);
+          if (trans.facadeTransport) {
+            transports.facade.push(trans.facadeTransport);
+          }
+        } else {
+          debug('disabled', trans.transportName);
+        }
+      });
+      return transports;
+    }
+  };
+};
+
+export { transport as default };