@comate/zulu 0.8.0 → 0.8.2

package/comate-engine/node_modules/win-ca/lib/der2.js

@@ -0,0 +1,78 @@
+// Generated by LiveScript 1.6.0
+var forge$, formatters, list, k, v, isBuffer, bufferFrom;
+module.exports = der2;
+forge$ = require('./forge');
+formatters = {
+  der: der,
+  pem: pem,
+  txt: txt,
+  asn1: asn1,
+  x509: x509
+};
+list = [];
+for (k in formatters) {
+  v = formatters[k];
+  der2[k] = list.length;
+  list.push(v);
+}
+der2.forge = der2.x509;
+isBuffer = Buffer.isBuffer;
+bufferFrom = Buffer.from || function(data, encoding){
+  return new Buffer(data, encoding);
+};
+function der2(format, blob){
+  var converter;
+  converter = list[format] || list[0];
+  if (blob != null) {
+    return converter(blob);
+  } else {
+    return converter;
+  }
+}
+function der(it){
+  if (isBuffer(it)) {
+    return it;
+  } else {
+    return bufferFrom(it, 'binary');
+  }
+}
+function pem(it){
+  var lines, i$, to$, i;
+  it = der(it).toString('base64');
+  lines = ['-----BEGIN CERTIFICATE-----'];
+  for (i$ = 0, to$ = it.length; i$ < to$; i$ += 64) {
+    i = i$;
+    lines.push(it.substr(i, 64));
+  }
+  lines.push('-----END CERTIFICATE-----', '');
+  return lines.join("\r\n");
+}
+function txt(it){
+  var crt;
+  crt = asn1(it);
+  return "Subject\t" + crt.subject.value.map(function(it){
+    return bufferFrom(it.value[0].value[1].value, 'binary').toString('utf8');
+  }).join('/') + "\nValid\t" + crt.valid.value.map(function(it){
+    return it.value;
+  }).join(' - ') + "\n" + pem(it);
+}
+function asn1(it){
+  var asn1parser, crt, serial, hasSerial;
+  asn1parser = forge$().asn1;
+  it = it.toString('binary');
+  crt = asn1parser.fromDer(it).value[0].value;
+  serial = crt[0];
+  hasSerial = serial.tagClass === asn1parser.Class.CONTEXT_SPECIFIC && serial.type === 0 && serial.constructed;
+  crt = crt.slice(hasSerial);
+  return {
+    serial: crt[0],
+    valid: crt[3],
+    issuer: crt[2],
+    subject: crt[4]
+  };
+}
+function x509(it){
+  return forge$().pki.certificateFromAsn1(
+  forge$().asn1.fromDer(
+  it.toString('binary')));
+}

package/comate-engine/node_modules/win-ca/lib/fallback.js

@@ -0,0 +1,110 @@
+// Generated by LiveScript 1.6.0
+var path, child_process, split, bin, execFileProperties, bufferFrom, out$ = typeof exports != 'undefined' && exports || this;
+path = require('path');
+child_process = require('child_process');
+split = require('split');
+execFileProperties = {
+  maxBuffer: 1024 * 1024 * 1024
+};
+function exe(newBin){
+  var old;
+  newBin == null && (newBin = 'roots.exe');
+  old = bin;
+  bin = path.resolve(__dirname, newBin);
+  return old;
+} exe();
+out$.exe = exe;
+out$.sync = sync;
+function sync(args){
+  var queue, index;
+  return {
+    run: run,
+    next: next,
+    done: done
+  };
+  function next(){
+    if (!queue) {
+      queue = [];
+      index = 0;
+      run(function(it){
+        if (it) {
+          queue.push(it);
+        }
+      });
+    }
+    if (index < queue.length) {
+      return queue[index++];
+    }
+    queue = [];
+  }
+  function done(){
+    queue = [];
+  }
+  function run(callback){
+    splitter(callback).on('end', function(){
+      callback();
+    }).end(child_process.execFileSync(bin, args, execFileProperties));
+  }
+}
+out$.async = async;
+function async(args){
+  var queue, requests, finished;
+  return {
+    run: run,
+    next: next,
+    done: done
+  };
+  function next(){
+    if (!queue) {
+      queue = [];
+      requests = [];
+      run(enqueue);
+    }
+    return queue.length
+      ? Promise.resolve(queue.shift())
+      : finished
+        ? Promise.resolve()
+        : new Promise(function(it){
+          requests.push(it);
+        });
+  }
+  function enqueue(it){
+    if (finished) {
+      return;
+    }
+    if (!it) {
+      suspend();
+    } else if (requests.length) {
+      requests.shift()(it);
+    } else {
+      queue.push(it);
+    }
+  }
+  function done(){
+    queue = [];
+    suspend();
+  }
+  function suspend(){
+    var i$, ref$, len$, resolver;
+    finished = true;
+    for (i$ = 0, len$ = (ref$ = requests).length; i$ < len$; ++i$) {
+      resolver = ref$[i$];
+      resolver();
+    }
+  }
+  function run(callback){
+    child_process.execFile(bin, args, execFileProperties, function(){}).stdout.pipe(splitter(callback)).on('end', function(){
+      callback();
+    });
+  }
+}
+function splitter(callback){
+  return split(function(line){
+    if (line.length) {
+      callback(bufferFrom(line, 'hex'));
+    }
+  });
+}
+bufferFrom = Buffer.from || function(data, encoding){
+  return new Buffer(data, encoding);
+};

package/comate-engine/node_modules/win-ca/lib/forge.js

@@ -0,0 +1,16 @@
+// Generated by LiveScript 1.6.0
+var forge;
+module.exports = loader;
+function loader(){
+  var oids, k, ref$, v;
+  if (!forge) {
+    forge = require('node-forge');
+    oids = forge.oids;
+    for (k in ref$ = require('./oids')) {
+      v = ref$[k];
+      oids[k] == null && (oids[k] = v);
+      oids[v] == null && (oids[v] = k);
+    }
+  }
+  return forge;
+}

package/comate-engine/node_modules/win-ca/lib/hash.js

@@ -0,0 +1,52 @@
+// Generated by LiveScript 1.6.0
+var crypto, forge, der2, asn1, toASN1, bufferFrom;
+crypto = require('crypto');
+forge = require('./forge');
+der2 = require('./der2');
+asn1 = forge().asn1;
+toASN1 = der2(der2.asn1);
+module.exports = dispatch;
+bufferFrom = Buffer.from || function(data, encoding){
+  return new Buffer(data, encoding);
+};
+function hash(it){
+  var sha1;
+  sha1 = crypto.createHash('sha1');
+  toASN1(it).subject.value.forEach(function(it){
+    var pair, unicod;
+    it = asn1.copy(it);
+    pair = it.value[0].value[1];
+    if (!pair.value) {
+      return;
+    }
+    pair.type = asn1.Type.UTF8;
+    unicod = bufferFrom(pair.value, 'binary').toString('utf8');
+    unicod = unicod.trim().replace(/[A-Z]+/g, function(it){
+      return it.toLowerCase();
+    }).replace(/\s+/g, ' ');
+    pair.value = bufferFrom(unicod, 'utf8').toString('binary');
+    sha1.update(asn1.toDer(it).getBytes(), 'binary');
+  });
+  return hex(sha1);
+}
+function hash0(it){
+  var md5, subj;
+  md5 = crypto.createHash('md5');
+  subj = toASN1(it).subject;
+  md5.update(asn1.toDer(subj).getBytes(), 'binary');
+  return hex(md5);
+}
+function hex(it){
+  it = it.digest().slice(0, 4);
+  it.writeUInt32LE(it.readUInt32BE(0), 0);
+  return it.toString('hex');
+}
+function dispatch(ver, blob){
+  var fn;
+  fn = 0 === ver ? hash0 : hash;
+  if (blob != null) {
+    return fn(blob);
+  } else {
+    return fn;
+  }
+}

package/comate-engine/node_modules/win-ca/lib/index.js

@@ -0,0 +1,162 @@
+// Generated by LiveScript 1.6.0
+var disabled, der2;
+module.exports = api;
+api.disabled = disabled = process.platform !== 'win32';
+api.nApi = false;
+api.der2 = der2 = require('./der2');
+api.hash = hash;
+api.inject = inject;
+
+function hash(){
+  return (api.hash = require('./hash')).apply(this, arguments);
+}
+function inject(){
+  return (api.inject = require('./inject').inject).apply(this, arguments);
+}
+function api(params){
+  var engine, store, async, Process, unique, mapper, saver, injector;
+  params == null && (params = {});
+  params.rootInstance = this;
+  engine = disabled || params.disabled
+    ? require('./none')
+    : require('./n-api');
+  if (!(store = params.store)) {
+    store = [];
+  } else if (!Array.isArray(store)) {
+    store = [store];
+  }
+  engine = engine[(async = params.async) ? 'async' : 'sync'](store);
+  Process = async ? asyncProcess : syncProcess;
+  if (false !== params.unique) {
+    unique = require('./unique')();
+  }
+  mapper = der2(params.format);
+  if (Array.isArray(params.ondata)) {
+    params.ondata = params.ondata.push.bind(params.ondata);
+  }
+  if (params.save || params.$ave) {
+    saver = require('./save')(params);
+  }
+  if (params.inject) {
+    injector = require('./inject')(params.inject);
+  }
+  if (params.generator) {
+    return (async ? asyncGenerator : syncGenerator)();
+  }
+  engine.run(function(it){
+    if (!it || !unique || unique(it)) {
+      Process(it);
+    }
+  });
+  function syncProcess(it){
+    if (saver) {
+      saver(it);
+    }
+    if (it) {
+      if (injector) {
+        injector(it);
+      }
+      if (typeof params.ondata == 'function') {
+        params.ondata(mapper(it));
+      }
+    } else {
+      if (typeof params.onend == 'function') {
+        params.onend();
+      }
+    }
+  }
+  function asyncProcess(it){
+    Promise.resolve(it).then(syncProcess);
+  }
+  function syncGenerator(){
+    var ref$;
+    return ref$ = {}, ref$[Symbol.iterator] = myself, ref$['return'] = Return, ref$.next = syncNext, ref$;
+  }
+  function asyncGenerator(){
+    var ref$, ref1$;
+    return ref$ = {}, ref$[(ref1$ = Symbol.asyncIterator) != null ? ref1$ : '@'] = myself, ref$['return'] = Return, ref$.next = asyncNext, ref$;
+  }
+  function genProcess(it){
+    Process(it);
+    return {
+      done: !it,
+      value: it != null ? mapper(it) : it
+    };
+  }
+  function Return(it){
+    engine.done();
+    return {
+      done: true,
+      value: it
+    };
+  }
+  function syncNext(){
+    var der;
+    while ((der = engine.next()) && unique && !unique(der)) {}
+    return genProcess(der);
+  }
+  function asyncNext(){
+    function fire(){
+      return Promise.resolve().then(engine.next).then(function(it){
+        if (it && unique && !unique(it)) {
+          return fire();
+        } else {
+          return genProcess(it);
+        }
+      });
+    }
+    return fire();
+  }
+}
+function myself(){
+  return this;
+}
+
+api.all = all;
+api.each = each;
+each.async = async;
+
+function each(){
+  var params;
+  upgradeAPI(arguments, params = {
+    unique: true,
+    ondata: function(it){
+      if (typeof params.$cb == 'function') {
+        params.$cb(it);
+      }
+    }
+  });
+}
+function async(){
+  var params;
+  upgradeAPI(arguments, params = {
+    async: true,
+    ondata: function(it){
+      if (typeof params.$cb == 'function') {
+        params.$cb(void 8, it);
+      }
+    },
+    onend: function(){
+      if (typeof params.$cb == 'function') {
+        params.$cb();
+      }
+    }
+  });
+}
+function all(){
+  var result;
+  upgradeAPI(arguments, {
+    ondata: result = []
+  });
+  return result;
+}
+function upgradeAPI(args, defaults){
+  var format;
+  format = args[0];
+  defaults.unique == null && (defaults.unique = false);
+  defaults.format = format != null
+    ? format
+    : api.der2.x509;
+  defaults.$cb = args[1] || format;
+  api(defaults);
+}

package/comate-engine/node_modules/win-ca/lib/inject.js

@@ -0,0 +1,65 @@
+// Generated by LiveScript 1.6.0
+var https, tls, der2, toPEM, agentOptions, roots, patchMode, saveCreateSecureContext;
+https = require('https');
+tls = require('tls');
+der2 = require('./der2');
+module.exports = iFactory;
+iFactory.inject = inject;
+toPEM = der2(der2.pem);
+agentOptions = https.globalAgent.options;
+roots = [];
+function iFactory(mode){
+  inject(mode, []);
+  return add;
+}
+function add(der){
+  roots.push(
+  toPEM(
+  der));
+}
+patchMode = 0;
+function inject(mode, array){
+  if (array) {
+    roots.length = 0;
+    roots.push.apply(roots, array);
+  }
+  mode = '+' === mode
+    ? 2
+    : mode ? 1 : 0;
+  if (mode === patchMode) {
+    return;
+  }
+  switch (patchMode) {
+  case 1:
+    if (agentOptions.ca === roots) {
+      delete agentOptions.ca;
+    }
+    break;
+  case 2:
+    if (tls.createSecureContext === createSecureContext) {
+      tls.createSecureContext = saveCreateSecureContext;
+      saveCreateSecureContext = void 8;
+    }
+  }
+  switch (patchMode = mode) {
+  case 1:
+    agentOptions.ca = roots;
+    break;
+  case 2:
+    if (!saveCreateSecureContext) {
+      saveCreateSecureContext = tls.createSecureContext;
+      tls.createSecureContext = createSecureContext;
+    }
+  }
+}
+function createSecureContext(options){
+  var ctx, i$, ref$, len$, crt;
+  ctx = saveCreateSecureContext.apply(this, arguments);
+  if (2 === patchMode && !(options != null && options.ca)) {
+    for (i$ = 0, len$ = (ref$ = roots).length; i$ < len$; ++i$) {
+      crt = ref$[i$];
+      ctx.context.addCACert(crt);
+    }
+  }
+  return ctx;
+}

package/comate-engine/node_modules/win-ca/lib/n-api.js

@@ -0,0 +1,62 @@
+// Generated by LiveScript 1.6.0
+var crypt32, out$ = typeof exports != 'undefined' && exports || this;
+crypt32 = require("win-ca/lib/crypt32-" + process.arch);
+out$.sync = sync;
+function sync(args){
+  var handle, current;
+  current = args.length
+    ? 0
+    : -1;
+  return {
+    next: next,
+    done: done,
+    run: run
+  };
+  function next(){
+    var that;
+    while (current < args.length) {
+      handle == null && (handle = current < 0
+        ? crypt32()
+        : crypt32(args[current]));
+      if (that = handle.next()) {
+        return that;
+      }
+      handle.done();
+      handle = void 8;
+      current++;
+    }
+  }
+  function done(){
+    if (handle != null) {
+      handle.done();
+    }
+    handle = void 8;
+    current = args.length;
+  }
+  function run(it){
+    var that;
+    while (that = next()) {
+      it(that);
+    }
+    it();
+  }
+}
+out$.async = async;
+function async(it){
+  var res, next;
+  res = sync(it);
+  next = res.next;
+  res.run = run;
+  return res;
+  function run(callback){
+    function fire(){
+      return Promise.resolve().then(next).then(function(it){
+        if (it) {
+          callback(it);
+          return fire();
+        }
+        callback();
+      });
+    } fire();
+  }
+}

package/comate-engine/node_modules/win-ca/lib/none.js

@@ -0,0 +1,13 @@
+// Generated by LiveScript 1.6.0
+var async, out$ = typeof exports != 'undefined' && exports || this;
+out$.sync = sync;
+function sync(){
+  return {
+    next: function(){},
+    done: function(){},
+    run: function(it){
+      return it();
+    }
+  };
+}
+out$.async = async = sync;

package/comate-engine/node_modules/win-ca/lib/oids.js

@@ -0,0 +1,4 @@
+// Generated by LiveScript 1.6.0
+module.exports = {
+  dc: '0.9.2342.19200300.100.1.25'
+};

package/comate-engine/node_modules/win-ca/lib/save.js

@@ -0,0 +1,112 @@
+// Generated by LiveScript 1.6.0
+var fs, os, path, makeDir, der2, hash, toPEM, to$, writeFile, readdir, unlink;
+fs = require('fs');
+os = require('os');
+path = require('path');
+makeDir = require('make-dir');
+der2 = require('./der2');
+hash = require('./hash');
+module.exports = save;
+toPEM = der2(der2.txt);
+to$ = hash();
+writeFile = promisify(fs.writeFile);
+readdir = promisify(fs.readdir);
+unlink = promisify(fs.unlink);
+function save(params){
+  var folder, chain, PEM, hashes, names;
+  hashes = {};
+  names = new Set;
+  return later;
+  function later(it){
+    return Promise.resolve(it).then(saver);
+  }
+  function saver(der){
+    if (der) {
+      chain || (chain = mkdir(params.save || params.$ave).then(function(it){
+        return folder = it;
+      }));
+      chain = chain.then(function(){
+        if (folder) {
+          return single(der);
+        }
+      });
+    } else if (chain) {
+      chain.then(cleanUp).then(function(){
+        if (PEM != null) {
+          PEM.end();
+        }
+        if (folder && params.$ave) {
+          process.env.SSL_CERT_DIR = params.rootInstance.path = folder;
+        }
+        if (typeof params.onsave == 'function') {
+          params.onsave(folder);
+        }
+      });
+    } else {
+      if (typeof params.onsave == 'function') {
+        params.onsave();
+      }
+    }
+  }
+  function single(der){
+    var pem, hash;
+    (PEM || (PEM = fs.createWriteStream(name('roots.pem')))).write(pem = toPEM(der));
+    hashes[hash = to$(der)] || (hashes[hash] = 0);
+    return writeFile(name(hash + "." + (hashes[hash]++)), pem)['catch'](ignore);
+  }
+  function name(it){
+    names.add(it);
+    return path.join(folder, it);
+  }
+  function cleanUp(){
+    if (folder) {
+      readdir(folder).then(function(it){
+        return Promise.all(it.filter(function(it){
+          return !names.has(it);
+        }).map(function(it){
+          return path.join(folder, it);
+        }).map(function(it){
+          return unlink(it)['catch'](ignore);
+        }));
+      })['catch'](ignore);
+    }
+  }
+}
+function defaults(){
+  return [path.join(__dirname, '../pem'), path.join(os.homedir(), '.local/win-ca/pem')];
+}
+function mkdir(dst){
+  var idx;
+  if ('string' === typeof dst) {
+    dst = [dst];
+  } else if (!Array.isArray(dst)) {
+    dst = defaults();
+  }
+  idx = 0;
+  return nextDir();
+  function nextDir(){
+    if (idx < dst.length) {
+      return makeDir(dst[idx++])['catch'](nextDir);
+    } else {
+      return Promise.resolve();
+    }
+  }
+}
+function promisify(fn){
+  return function(){
+    var args, this$ = this;
+    args = [].slice.call(arguments);
+    return new Promise(function(resolve, reject){
+      args.push(callback);
+      fn.apply(this$, args);
+      function callback(error, value){
+        if (error) {
+          reject(error);
+        } else {
+          resolve(value);
+        }
+      }
+    });
+  };
+}
+function ignore(){}

package/comate-engine/node_modules/win-ca/lib/unique.js

@@ -0,0 +1,17 @@
+// Generated by LiveScript 1.6.0
+var crypto;
+crypto = require('crypto');
+module.exports = unique;
+function unique(){
+  var seen;
+  seen = new Set;
+  function pass(it){
+    var sha;
+    sha = crypto.createHash('sha256').update(it).digest('base64');
+    if (!seen.has(sha)) {
+      seen.add(sha);
+      return true;
+    }
+  }
+  return pass;
+}