homebridge-tuya-powerstrip/pakmanaged.js

Tuya powerstrip control for homebridge. Based on codetheweb's Tuya API and tuya outlet plugins.

var global = Function("return this;")();
/*!
  * Ender: open module JavaScript framework (client-lib)
  * copyright Dustin Diaz & Jacob Thornton 2011 (@ded @fat)
  * http://ender.no.de
  * License MIT
  */
!function (context) {

  // a global object for node.js module compatiblity
  // ============================================

  context['global'] = context

  // Implements simple module system
  // losely based on CommonJS Modules spec v1.1.1
  // ============================================

  var modules = {}
    , old = context.$

  function require (identifier) {
    // modules can be required from ender's build system, or found on the window
    var module = modules[identifier] || window[identifier]
    if (!module) throw new Error("Requested module '" + identifier + "' has not been defined.")
    return module
  }

  function provide (name, what) {
    return (modules[name] = what)
  }

  context['provide'] = provide
  context['require'] = require

  function aug(o, o2) {
    for (var k in o2) k != 'noConflict' && k != '_VERSION' && (o[k] = o2[k])
    return o
  }

  function boosh(s, r, els) {
    // string || node || nodelist || window
    if (typeof s == 'string' || s.nodeName || (s.length && 'item' in s) || s == window) {
      els = ender._select(s, r)
      els.selector = s
    } else els = isFinite(s.length) ? s : [s]
    return aug(els, boosh)
  }

  function ender(s, r) {
    return boosh(s, r)
  }

  aug(ender, {
      _VERSION: '0.3.6'
    , fn: boosh // for easy compat to jQuery plugins
    , ender: function (o, chain) {
        aug(chain ? boosh : ender, o)
      }
    , _select: function (s, r) {
        return (r || document).querySelectorAll(s)
      }
  })

  aug(boosh, {
    forEach: function (fn, scope, i) {
      // opt out of native forEach so we can intentionally call our own scope
      // defaulting to the current item and be able to return self
      for (i = 0, l = this.length; i < l; ++i) i in this && fn.call(scope || this[i], this[i], i, this)
      // return self for chaining
      return this
    },
    $: ender // handy reference to self
  })

  ender.noConflict = function () {
    context.$ = old
    return this
  }

  if (typeof module !== 'undefined' && module.exports) module.exports = ender
  // use subscript notation as extern for Closure compilation
  context['ender'] = context['$'] = context['ender'] || ender

}(this);
// pakmanager:ms
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Helpers.
     */
    
    var s = 1000;
    var m = s * 60;
    var h = m * 60;
    var d = h * 24;
    var y = d * 365.25;
    
    /**
     * Parse or format the given `val`.
     *
     * Options:
     *
     *  - `long` verbose formatting [false]
     *
     * @param {String|Number} val
     * @param {Object} [options]
     * @throws {Error} throw an error if val is not a non-empty string or a number
     * @return {String|Number}
     * @api public
     */
    
    module.exports = function(val, options) {
      options = options || {};
      var type = typeof val;
      if (type === 'string' && val.length > 0) {
        return parse(val);
      } else if (type === 'number' && isNaN(val) === false) {
        return options.long ? fmtLong(val) : fmtShort(val);
      }
      throw new Error(
        'val is not a non-empty string or a valid number. val=' +
          JSON.stringify(val)
      );
    };
    
    /**
     * Parse the given `str` and return milliseconds.
     *
     * @param {String} str
     * @return {Number}
     * @api private
     */
    
    function parse(str) {
      str = String(str);
      if (str.length > 100) {
        return;
      }
      var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(
        str
      );
      if (!match) {
        return;
      }
      var n = parseFloat(match[1]);
      var type = (match[2] || 'ms').toLowerCase();
      switch (type) {
        case 'years':
        case 'year':
        case 'yrs':
        case 'yr':
        case 'y':
          return n * y;
        case 'days':
        case 'day':
        case 'd':
          return n * d;
        case 'hours':
        case 'hour':
        case 'hrs':
        case 'hr':
        case 'h':
          return n * h;
        case 'minutes':
        case 'minute':
        case 'mins':
        case 'min':
        case 'm':
          return n * m;
        case 'seconds':
        case 'second':
        case 'secs':
        case 'sec':
        case 's':
          return n * s;
        case 'milliseconds':
        case 'millisecond':
        case 'msecs':
        case 'msec':
        case 'ms':
          return n;
        default:
          return undefined;
      }
    }
    
    /**
     * Short format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */
    
    function fmtShort(ms) {
      if (ms >= d) {
        return Math.round(ms / d) + 'd';
      }
      if (ms >= h) {
        return Math.round(ms / h) + 'h';
      }
      if (ms >= m) {
        return Math.round(ms / m) + 'm';
      }
      if (ms >= s) {
        return Math.round(ms / s) + 's';
      }
      return ms + 'ms';
    }
    
    /**
     * Long format for `ms`.
     *
     * @param {Number} ms
     * @return {String}
     * @api private
     */
    
    function fmtLong(ms) {
      return plural(ms, d, 'day') ||
        plural(ms, h, 'hour') ||
        plural(ms, m, 'minute') ||
        plural(ms, s, 'second') ||
        ms + ' ms';
    }
    
    /**
     * Pluralization helper.
     */
    
    function plural(ms, n, name) {
      if (ms < n) {
        return;
      }
      if (ms < n * 1.5) {
        return Math.floor(ms / n) + ' ' + name;
      }
      return Math.ceil(ms / n) + ' ' + name + 's';
    }
    
  provide("ms", module.exports);
}(global));

// pakmanager:retry/retry_operation
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  function RetryOperation(timeouts, options) {
      // Compatibility for the old (timeouts, retryForever) signature
      if (typeof options === 'boolean') {
        options = { forever: options };
      }
    
      this._timeouts = timeouts;
      this._options = options || {};
      this._fn = null;
      this._errors = [];
      this._attempts = 1;
      this._operationTimeout = null;
      this._operationTimeoutCb = null;
      this._timeout = null;
    
      if (this._options.forever) {
        this._cachedTimeouts = this._timeouts.slice(0);
      }
    }
    module.exports = RetryOperation;
    
    RetryOperation.prototype.retry = function(err) {
      if (this._timeout) {
        clearTimeout(this._timeout);
      }
    
      if (!err) {
        return false;
      }
    
      this._errors.push(err);
    
      var timeout = this._timeouts.shift();
      if (timeout === undefined) {
        if (this._cachedTimeouts) {
          // retry forever, only keep last error
          this._errors.splice(this._errors.length - 1, this._errors.length);
          this._timeouts = this._cachedTimeouts.slice(0);
          timeout = this._timeouts.shift();
        } else {
          return false;
        }
      }
    
      var self = this;
      var timer = setTimeout(function() {
        self._attempts++;
    
        if (self._operationTimeoutCb) {
          self._timeout = setTimeout(function() {
            self._operationTimeoutCb(self._attempts);
          }, self._operationTimeout);
    
          if (this._options.unref) {
              self._timeout.unref();
          }
        }
    
        self._fn(self._attempts);
      }, timeout);
    
      if (this._options.unref) {
          timer.unref();
      }
    
      return true;
    };
    
    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
      this._fn = fn;
    
      if (timeoutOps) {
        if (timeoutOps.timeout) {
          this._operationTimeout = timeoutOps.timeout;
        }
        if (timeoutOps.cb) {
          this._operationTimeoutCb = timeoutOps.cb;
        }
      }
    
      var self = this;
      if (this._operationTimeoutCb) {
        this._timeout = setTimeout(function() {
          self._operationTimeoutCb();
        }, self._operationTimeout);
      }
    
      this._fn(this._attempts);
    };
    
    RetryOperation.prototype.try = function(fn) {
      console.log('Using RetryOperation.try() is deprecated');
      this.attempt(fn);
    };
    
    RetryOperation.prototype.start = function(fn) {
      console.log('Using RetryOperation.start() is deprecated');
      this.attempt(fn);
    };
    
    RetryOperation.prototype.start = RetryOperation.prototype.try;
    
    RetryOperation.prototype.errors = function() {
      return this._errors;
    };
    
    RetryOperation.prototype.attempts = function() {
      return this._attempts;
    };
    
    RetryOperation.prototype.mainError = function() {
      if (this._errors.length === 0) {
        return null;
      }
    
      var counts = {};
      var mainError = null;
      var mainErrorCount = 0;
    
      for (var i = 0; i < this._errors.length; i++) {
        var error = this._errors[i];
        var message = error.message;
        var count = (counts[message] || 0) + 1;
    
        counts[message] = count;
    
        if (count >= mainErrorCount) {
          mainError = error;
          mainErrorCount = count;
        }
      }
    
      return mainError;
    };
    
  provide("retry/retry_operation", module.exports);
}(global));

// pakmanager:retry/retry
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  var RetryOperation =  require('retry/retry_operation');
    
    exports.operation = function(options) {
      var timeouts = exports.timeouts(options);
      return new RetryOperation(timeouts, {
          forever: options && options.forever,
          unref: options && options.unref
      });
    };
    
    exports.timeouts = function(options) {
      if (options instanceof Array) {
        return [].concat(options);
      }
    
      var opts = {
        retries: 10,
        factor: 2,
        minTimeout: 1 * 1000,
        maxTimeout: Infinity,
        randomize: false
      };
      for (var key in options) {
        opts[key] = options[key];
      }
    
      if (opts.minTimeout > opts.maxTimeout) {
        throw new Error('minTimeout is greater than maxTimeout');
      }
    
      var timeouts = [];
      for (var i = 0; i < opts.retries; i++) {
        timeouts.push(this.createTimeout(i, opts));
      }
    
      // sort the array numerically ascending
      timeouts.sort(function(a,b) {
        return a - b;
      });
    
      return timeouts;
    };
    
    exports.createTimeout = function(attempt, opts) {
      var random = (opts.randomize)
        ? (Math.random() + 1)
        : 1;
    
      var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
      timeout = Math.min(timeout, opts.maxTimeout);
    
      return timeout;
    };
    
    exports.wrap = function(obj, options, methods) {
      if (options instanceof Array) {
        methods = options;
        options = null;
      }
    
      if (!methods) {
        methods = [];
        for (var key in obj) {
          if (typeof obj[key] === 'function') {
            methods.push(key);
          }
        }
      }
    
      for (var i = 0; i < methods.length; i++) {
        var method   = methods[i];
        var original = obj[method];
    
        obj[method] = function retryWrapper() {
          var op       = exports.operation(options);
          var args     = Array.prototype.slice.call(arguments);
          var callback = args.pop();
    
          args.push(function(err) {
            if (op.retry(err)) {
              return;
            }
            if (err) {
              arguments[0] = op.mainError();
            }
            callback.apply(this, arguments);
          });
    
          op.attempt(function() {
            original.apply(obj, args);
          });
        };
        obj[method].options = options;
      }
    };
    
  provide("retry/retry", module.exports);
}(global));

// pakmanager:retry
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  module.exports =  require('retry/retry');
  provide("retry", module.exports);
}(global));

// pakmanager:escape-string-regexp
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  'use strict';
    
    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
    
    module.exports = function (str) {
    	if (typeof str !== 'string') {
    		throw new TypeError('Expected a string');
    	}
    
    	return str.replace(matchOperatorsRe, '\\$&');
    };
    
  provide("escape-string-regexp", module.exports);
}(global));

// pakmanager:regex-occurrence
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  'use strict';
    module.exports = function (input, search) {
    	if (typeof input !== 'string') {
    		throw new TypeError('The input should be a string');
    	}
    
    	return [].concat(search).reduce(function (count, search) {
    		return count + (input.match(search) || []).length;
    	}, 0);
    };
    
  provide("regex-occurrence", module.exports);
}(global));

// pakmanager:debug/src/debug
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  
    /**
     * This is the common logic for both the Node.js and web browser
     * implementations of `debug()`.
     *
     * Expose `debug()` as the module.
     */
    
    exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
    exports.coerce = coerce;
    exports.disable = disable;
    exports.enable = enable;
    exports.enabled = enabled;
    exports.humanize = require('ms');
    
    /**
     * Active `debug` instances.
     */
    exports.instances = [];
    
    /**
     * The currently active debug mode names, and names to skip.
     */
    
    exports.names = [];
    exports.skips = [];
    
    /**
     * Map of special "%n" handling functions, for the debug "format" argument.
     *
     * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
     */
    
    exports.formatters = {};
    
    /**
     * Select a color.
     * @param {String} namespace
     * @return {Number}
     * @api private
     */
    
    function selectColor(namespace) {
      var hash = 0, i;
    
      for (i in namespace) {
        hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);
        hash |= 0; // Convert to 32bit integer
      }
    
      return exports.colors[Math.abs(hash) % exports.colors.length];
    }
    
    /**
     * Create a debugger with the given `namespace`.
     *
     * @param {String} namespace
     * @return {Function}
     * @api public
     */
    
    function createDebug(namespace) {
    
      var prevTime;
    
      function debug() {
        // disabled?
        if (!debug.enabled) return;
    
        var self = debug;
    
        // set `diff` timestamp
        var curr = +new Date();
        var ms = curr - (prevTime || curr);
        self.diff = ms;
        self.prev = prevTime;
        self.curr = curr;
        prevTime = curr;
    
        // turn the `arguments` into a proper Array
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
    
        args[0] = exports.coerce(args[0]);
    
        if ('string' !== typeof args[0]) {
          // anything else let's inspect with %O
          args.unshift('%O');
        }
    
        // apply any `formatters` transformations
        var index = 0;
        args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
          // if we encounter an escaped % then don't increase the array index
          if (match === '%%') return match;
          index++;
          var formatter = exports.formatters[format];
          if ('function' === typeof formatter) {
            var val = args[index];
            match = formatter.call(self, val);
    
            // now we need to remove `args[index]` since it's inlined in the `format`
            args.splice(index, 1);
            index--;
          }
          return match;
        });
    
        // apply env-specific formatting (colors, etc.)
        exports.formatArgs.call(self, args);
    
        var logFn = debug.log || exports.log || console.log.bind(console);
        logFn.apply(self, args);
      }
    
      debug.namespace = namespace;
      debug.enabled = exports.enabled(namespace);
      debug.useColors = exports.useColors();
      debug.color = selectColor(namespace);
      debug.destroy = destroy;
    
      // env-specific initialization logic for debug instances
      if ('function' === typeof exports.init) {
        exports.init(debug);
      }
    
      exports.instances.push(debug);
    
      return debug;
    }
    
    function destroy () {
      var index = exports.instances.indexOf(this);
      if (index !== -1) {
        exports.instances.splice(index, 1);
        return true;
      } else {
        return false;
      }
    }
    
    /**
     * Enables a debug mode by namespaces. This can include modes
     * separated by a colon and wildcards.
     *
     * @param {String} namespaces
     * @api public
     */
    
    function enable(namespaces) {
      exports.save(namespaces);
    
      exports.names = [];
      exports.skips = [];
    
      var i;
      var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
      var len = split.length;
    
      for (i = 0; i < len; i++) {
        if (!split[i]) continue; // ignore empty strings
        namespaces = split[i].replace(/\*/g, '.*?');
        if (namespaces[0] === '-') {
          exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
        } else {
          exports.names.push(new RegExp('^' + namespaces + '$'));
        }
      }
    
      for (i = 0; i < exports.instances.length; i++) {
        var instance = exports.instances[i];
        instance.enabled = exports.enabled(instance.namespace);
      }
    }
    
    /**
     * Disable debug output.
     *
     * @api public
     */
    
    function disable() {
      exports.enable('');
    }
    
    /**
     * Returns true if the given mode name is enabled, false otherwise.
     *
     * @param {String} name
     * @return {Boolean}
     * @api public
     */
    
    function enabled(name) {
      if (name[name.length - 1] === '*') {
        return true;
      }
      var i, len;
      for (i = 0, len = exports.skips.length; i < len; i++) {
        if (exports.skips[i].test(name)) {
          return false;
        }
      }
      for (i = 0, len = exports.names.length; i < len; i++) {
        if (exports.names[i].test(name)) {
          return true;
        }
      }
      return false;
    }
    
    /**
     * Coerce `val`.
     *
     * @param {Mixed} val
     * @return {Mixed}
     * @api private
     */
    
    function coerce(val) {
      if (val instanceof Error) return val.stack || val.message;
      return val;
    }
    
  provide("debug/src/debug", module.exports);
}(global));

// pakmanager:debug/src/browser.js
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * This is the web browser implementation of `debug()`.
     *
     * Expose `debug()` as the module.
     */
    
    exports = module.exports =  require('debug/src/debug');
    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    exports.storage = 'undefined' != typeof chrome
                   && 'undefined' != typeof chrome.storage
                      ? chrome.storage.local
                      : localstorage();
    
    /**
     * Colors.
     */
    
    exports.colors = [
      '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',
      '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',
      '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',
      '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',
      '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',
      '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',
      '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',
      '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',
      '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',
      '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',
      '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'
    ];
    
    /**
     * Currently only WebKit-based Web Inspectors, Firefox >= v31,
     * and the Firebug extension (any Firefox version) are known
     * to support "%c" CSS customizations.
     *
     * TODO: add a `localStorage` variable to explicitly enable/disable colors
     */
    
    function useColors() {
      // NB: In an Electron preload script, document will be defined but not fully
      // initialized. Since we know we're in Chrome, we'll just detect this case
      // explicitly
      if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {
        return true;
      }
    
      // Internet Explorer and Edge do not support colors.
      if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
        return false;
      }
    
      // is webkit? http://stackoverflow.com/a/16459606/376773
      // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
      return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
        // is firebug? http://stackoverflow.com/a/398120/376773
        (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
        // is firefox >= v31?
        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
        (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
        // double check webkit in userAgent just in case we are in a worker
        (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
    }
    
    /**
     * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
     */
    
    exports.formatters.j = function(v) {
      try {
        return JSON.stringify(v);
      } catch (err) {
        return '[UnexpectedJSONParseError]: ' + err.message;
      }
    };
    
    
    /**
     * Colorize log arguments if enabled.
     *
     * @api public
     */
    
    function formatArgs(args) {
      var useColors = this.useColors;
    
      args[0] = (useColors ? '%c' : '')
        + this.namespace
        + (useColors ? ' %c' : ' ')
        + args[0]
        + (useColors ? '%c ' : ' ')
        + '+' + exports.humanize(this.diff);
    
      if (!useColors) return;
    
      var c = 'color: ' + this.color;
      args.splice(1, 0, c, 'color: inherit')
    
      // the final "%c" is somewhat tricky, because there could be other
      // arguments passed either before or after the %c, so we need to
      // figure out the correct index to insert the CSS into
      var index = 0;
      var lastC = 0;
      args[0].replace(/%[a-zA-Z%]/g, function(match) {
        if ('%%' === match) return;
        index++;
        if ('%c' === match) {
          // we only are interested in the *last* %c
          // (the user may have provided their own)
          lastC = index;
        }
      });
    
      args.splice(lastC, 0, c);
    }
    
    /**
     * Invokes `console.log()` when available.
     * No-op when `console.log` is not a "function".
     *
     * @api public
     */
    
    function log() {
      // this hackery is required for IE8/9, where
      // the `console.log` function doesn't have 'apply'
      return 'object' === typeof console
        && console.log
        && Function.prototype.apply.call(console.log, console, arguments);
    }
    
    /**
     * Save `namespaces`.
     *
     * @param {String} namespaces
     * @api private
     */
    
    function save(namespaces) {
      try {
        if (null == namespaces) {
          exports.storage.removeItem('debug');
        } else {
          exports.storage.debug = namespaces;
        }
      } catch(e) {}
    }
    
    /**
     * Load `namespaces`.
     *
     * @return {String} returns the previously persisted debug modes
     * @api private
     */
    
    function load() {
      var r;
      try {
        r = exports.storage.debug;
      } catch(e) {}
    
      // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
      if (!r && typeof process !== 'undefined' && 'env' in process) {
        r = process.env.DEBUG;
      }
    
      return r;
    }
    
    /**
     * Enable namespaces listed in `localStorage.debug` initially.
     */
    
    exports.enable(load());
    
    /**
     * Localstorage attempts to return the localstorage.
     *
     * This is necessary because safari throws
     * when a user disables cookies/localstorage
     * and you attempt to access it.
     *
     * @return {LocalStorage}
     * @api private
     */
    
    function localstorage() {
      try {
        return window.localStorage;
      } catch (e) {}
    }
    
  provide("debug/src/browser.js", module.exports);
}(global));

// pakmanager:debug/src/node.js
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Module dependencies.
     */
    
    var tty = require('tty');
    var util = require('util');
    
    /**
     * This is the Node.js implementation of `debug()`.
     *
     * Expose `debug()` as the module.
     */
    
    exports = module.exports =  require('debug/src/debug');
    exports.init = init;
    exports.log = log;
    exports.formatArgs = formatArgs;
    exports.save = save;
    exports.load = load;
    exports.useColors = useColors;
    
    /**
     * Colors.
     */
    
    exports.colors = [ 6, 2, 3, 4, 5, 1 ];
    
    try {
      var supportsColor = require('supports-color');
      if (supportsColor && supportsColor.level >= 2) {
        exports.colors = [
          20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68,
          69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134,
          135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
          172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204,
          205, 206, 207, 208, 209, 214, 215, 220, 221
        ];
      }
    } catch (err) {
      // swallow - we only care if `supports-color` is available; it doesn't have to be.
    }
    
    /**
     * Build up the default `inspectOpts` object from the environment variables.
     *
     *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
     */
    
    exports.inspectOpts = Object.keys(process.env).filter(function (key) {
      return /^debug_/i.test(key);
    }).reduce(function (obj, key) {
      // camel-case
      var prop = key
        .substring(6)
        .toLowerCase()
        .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() });
    
      // coerce string value into JS value
      var val = process.env[key];
      if (/^(yes|on|true|enabled)$/i.test(val)) val = true;
      else if (/^(no|off|false|disabled)$/i.test(val)) val = false;
      else if (val === 'null') val = null;
      else val = Number(val);
    
      obj[prop] = val;
      return obj;
    }, {});
    
    /**
     * Is stdout a TTY? Colored output is enabled when `true`.
     */
    
    function useColors() {
      return 'colors' in exports.inspectOpts
        ? Boolean(exports.inspectOpts.colors)
        : tty.isatty(process.stderr.fd);
    }
    
    /**
     * Map %o to `util.inspect()`, all on a single line.
     */
    
    exports.formatters.o = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util.inspect(v, this.inspectOpts)
        .split('\n').map(function(str) {
          return str.trim()
        }).join(' ');
    };
    
    /**
     * Map %o to `util.inspect()`, allowing multiple lines if needed.
     */
    
    exports.formatters.O = function(v) {
      this.inspectOpts.colors = this.useColors;
      return util.inspect(v, this.inspectOpts);
    };
    
    /**
     * Adds ANSI color escape codes if enabled.
     *
     * @api public
     */
    
    function formatArgs(args) {
      var name = this.namespace;
      var useColors = this.useColors;
    
      if (useColors) {
        var c = this.color;
        var colorCode = '\u001b[3' + (c < 8 ? c : '8;5;' + c);
        var prefix = '  ' + colorCode + ';1m' + name + ' ' + '\u001b[0m';
    
        args[0] = prefix + args[0].split('\n').join('\n' + prefix);
        args.push(colorCode + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
      } else {
        args[0] = getDate() + name + ' ' + args[0];
      }
    }
    
    function getDate() {
      if (exports.inspectOpts.hideDate) {
        return '';
      } else {
        return new Date().toISOString() + ' ';
      }
    }
    
    /**
     * Invokes `util.format()` with the specified arguments and writes to stderr.
     */
    
    function log() {
      return process.stderr.write(util.format.apply(util, arguments) + '\n');
    }
    
    /**
     * Save `namespaces`.
     *
     * @param {String} namespaces
     * @api private
     */
    
    function save(namespaces) {
      if (null == namespaces) {
        // If you set a process.env field to null or undefined, it gets cast to the
        // string 'null' or 'undefined'. Just delete instead.
        delete process.env.DEBUG;
      } else {
        process.env.DEBUG = namespaces;
      }
    }
    
    /**
     * Load `namespaces`.
     *
     * @return {String} returns the previously persisted debug modes
     * @api private
     */
    
    function load() {
      return process.env.DEBUG;
    }
    
    /**
     * Init logic for `debug` instances.
     *
     * Create a new `inspectOpts` object in case `useColors` is set
     * differently for a particular `debug` instance.
     */
    
    function init (debug) {
      debug.inspectOpts = {};
    
      var keys = Object.keys(exports.inspectOpts);
      for (var i = 0; i < keys.length; i++) {
        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
      }
    }
    
    /**
     * Enable namespaces listed in `process.env.DEBUG` initially.
     */
    
    exports.enable(load());
    
  provide("debug/src/node.js", module.exports);
}(global));

// pakmanager:debug
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Detect Electron renderer process, which is node, but we should
     * treat as a browser.
     */
    
    if (typeof process === 'undefined' || process.type === 'renderer') {
      module.exports =  require('debug/src/browser.js');
    } else {
      module.exports =  require('debug/src/node.js');
    }
    
  provide("debug", module.exports);
}(global));

// pakmanager:net-retry-connect
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  var net = require('net');
    var retry = require('retry');
    
    function Connection() {
    }
    
    Connection.prototype.to = function(options, cb) {
    
        var host = options.host || 'localhost';
        var port = options.port;
        var retryOptions = options.retryOptions;
    
        var client = new net.Socket();
        var operation = retry.operation(retryOptions);
        var cbCalled = false;
    
        client.on('error', handleError);
    
        function handleError(err) {
            if (!operation.retry(err)) {
                cb(err, null)
            }
        }
    
        operation.attempt(function () {
            client.connect(port, host, function(){
                if(!cbCalled) {
                    client.removeListener('error', handleError);
                    cb(null, client);
                    cbCalled = true;
                }
            });
        });
    };
    
    
    module.exports = new Connection();
    
  provide("net-retry-connect", module.exports);
}(global));

// pakmanager:node-forge/lib/forge
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Node.js module for Forge.
     *
     * @author Dave Longley
     *
     * Copyright 2011-2016 Digital Bazaar, Inc.
     */
    module.exports = {
      // default options
      options: {
        usePureJavaScript: false
      }
    };
    
  provide("node-forge/lib/forge", module.exports);
}(global));

// pakmanager:node-forge/lib/baseN
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Base-N/Base-X encoding/decoding functions.
     *
     * Original implementation from base-x:
     * https://github.com/cryptocoinjs/base-x
     *
     * Which is MIT licensed:
     *
     * The MIT License (MIT)
     *
     * Copyright base-x contributors (c) 2016
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
     * DEALINGS IN THE SOFTWARE.
     */
    var api = {};
    module.exports = api;
    
    // baseN alphabet indexes
    var _reverseAlphabets = {};
    
    /**
     * BaseN-encodes a Uint8Array using the given alphabet.
     *
     * @param input the Uint8Array to encode.
     * @param maxline the maximum number of encoded characters per line to use,
     *          defaults to none.
     *
     * @return the baseN-encoded output string.
     */
    api.encode = function(input, alphabet, maxline) {
      if(typeof alphabet !== 'string') {
        throw new TypeError('"alphabet" must be a string.');
      }
      if(maxline !== undefined && typeof maxline !== 'number') {
        throw new TypeError('"maxline" must be a number.');
      }
    
      var output = '';
    
      if(!(input instanceof Uint8Array)) {
        // assume forge byte buffer
        output = _encodeWithByteBuffer(input, alphabet);
      } else {
        var i = 0;
        var base = alphabet.length;
        var first = alphabet.charAt(0);
        var digits = [0];
        for(i = 0; i < input.length; ++i) {
          for(var j = 0, carry = input[i]; j < digits.length; ++j) {
            carry += digits[j] << 8;
            digits[j] = carry % base;
            carry = (carry / base) | 0;
          }
    
          while(carry > 0) {
            digits.push(carry % base);
            carry = (carry / base) | 0;
          }
        }
    
        // deal with leading zeros
        for(i = 0; input[i] === 0 && i < input.length - 1; ++i) {
          output += first;
        }
        // convert digits to a string
        for(i = digits.length - 1; i >= 0; --i) {
          output += alphabet[digits[i]];
        }
      }
    
      if(maxline) {
        var regex = new RegExp('.{1,' + maxline + '}', 'g');
        output = output.match(regex).join('\r\n');
      }
    
      return output;
    };
    
    /**
     * Decodes a baseN-encoded (using the given alphabet) string to a
     * Uint8Array.
     *
     * @param input the baseN-encoded input string.
     *
     * @return the Uint8Array.
     */
    api.decode = function(input, alphabet) {
      if(typeof input !== 'string') {
        throw new TypeError('"input" must be a string.');
      }
      if(typeof alphabet !== 'string') {
        throw new TypeError('"alphabet" must be a string.');
      }
    
      var table = _reverseAlphabets[alphabet];
      if(!table) {
        // compute reverse alphabet
        table = _reverseAlphabets[alphabet] = [];
        for(var i = 0; i < alphabet.length; ++i) {
          table[alphabet.charCodeAt(i)] = i;
        }
      }
    
      // remove whitespace characters
      input = input.replace(/\s/g, '');
    
      var base = alphabet.length;
      var first = alphabet.charAt(0);
      var bytes = [0];
      for(var i = 0; i < input.length; i++) {
        var value = table[input.charCodeAt(i)];
        if(value === undefined) {
          return;
        }
    
        for(var j = 0, carry = value; j < bytes.length; ++j) {
          carry += bytes[j] * base;
          bytes[j] = carry & 0xff;
          carry >>= 8;
        }
    
        while(carry > 0) {
          bytes.push(carry & 0xff);
          carry >>= 8;
        }
      }
    
      // deal with leading zeros
      for(var k = 0; input[k] === first && k < input.length - 1; ++k) {
        bytes.push(0);
      }
    
      if(typeof Buffer !== 'undefined') {
        return Buffer.from(bytes.reverse());
      }
    
      return new Uint8Array(bytes.reverse());
    };
    
    function _encodeWithByteBuffer(input, alphabet) {
      var i = 0;
      var base = alphabet.length;
      var first = alphabet.charAt(0);
      var digits = [0];
      for(i = 0; i < input.length(); ++i) {
        for(var j = 0, carry = input.at(i); j < digits.length; ++j) {
          carry += digits[j] << 8;
          digits[j] = carry % base;
          carry = (carry / base) | 0;
        }
    
        while(carry > 0) {
          digits.push(carry % base);
          carry = (carry / base) | 0;
        }
      }
    
      var output = '';
    
      // deal with leading zeros
      for(i = 0; input.at(i) === 0 && i < input.length() - 1; ++i) {
        output += first;
      }
      // convert digits to a string
      for(i = digits.length - 1; i >= 0; --i) {
        output += alphabet[digits[i]];
      }
    
      return output;
    }
    
  provide("node-forge/lib/baseN", module.exports);
}(global));

// pakmanager:node-forge/lib/util
(function (context) {
  
  var module = { exports: {} }, exports = module.exports
    , $ = require("ender")
    ;
  
  /**
     * Utility functions for web applications.
     *
     * @author Dave Longley
     *
     * Copyright (c) 2010-2018 Digital Bazaar, Inc.
     */
    var forge =  require('node-forge/lib/forge');
    var baseN =  require('node-forge/lib/baseN');
    
    /* Utilities API */
    var util = module.exports = forge.util = forge.util || {};
    
    // define setImmediate and nextTick
    (function() {
      // use native nextTick
      if(typeof process !== 'undefined' && process.nextTick) {
        util.nextTick = process.nextTick;
        if(typeof setImmediate === 'function') {
          util.setImmediate = setImmediate;
        } else {
          // polyfill setImmediate with nextTick, older versions of node
          // (those w/o setImmediate) won't totally starve IO
          util.setImmediate = util.nextTick;
        }
        return;
      }
    
      // polyfill nextTick with native setImmediate
      if(typeof setImmediate === 'function') {
        util.setImmediate = function() { return setImmediate.apply(undefined, arguments); };
        util.nextTick = function(callback) {
          return setImmediate(callback);
        };
        return;
      }
    
      /* Note: A polyfill upgrade pattern is used here to allow combining
      polyfills. For example, MutationObserver is fast, but blocks UI updates,
      so it needs to allow UI updates periodically, so it falls back on
      postMessage or setTimeout. */
    
      // polyfill with setTimeout
      util.setImmediate = function(callback) {
        setTimeout(callback, 0);
      };
    
      // upgrade polyfill to use postMessage
      if(typeof window !== 'undefined' &&
        typeof window.postMessage === 'function') {
        var msg = 'forge.setImmediate';
        var callbacks = [];
        util.setImmediate = function(callback) {
          callbacks.push(callback);
          // only send message when one hasn't been sent in
          // the current turn of the event loop
          if(callbacks.length === 1) {
            window.postMessage(msg, '*');
          }
        };
        function handler(event) {
          if(event.source === window && event.data === msg) {
            event.stopPropagation();
            var copy = callbacks.slice();
            callbacks.length = 0;
            copy.forEach(function(callback) {
              callback();
            });
          }
        }
        window.addEventListener('message', handler, true);
      }
    
      // upgrade polyfill to use MutationObserver
      if(typeof MutationObserver !== 'undefined') {
        // polyfill with MutationObserver
        var now = Date.now();
        var attr = true;
        var div = document.createElement('div');
        var callbacks = [];
        new MutationObserver(function() {
          var copy = callbacks.slice();
          callbacks.length = 0;
          copy.forEach(function(callback) {
            callback();
          });
        }).observe(div, {attributes: true});
        var oldSetImmediate = util.setImmediate;
        util.setImmediate = function(callback) {
          if(Date.now() - now > 15) {
            now = Date.now();
            oldSetImmediate(callback);
          } else {
            callbacks.push(callback);
            // only trigger observer when it hasn't been triggered in
            // the current turn of the event loop
            if(callbacks.length === 1) {
              div.setAttribute('a', attr = !attr);
            }
          }
        };
      }
    
      util.nextTick = util.setImmediate;
    })();
    
    // check if running under Node.js
    util.isNodejs =
      typeof process !== 'undefined' && process.versions && process.versions.node;
    
    // define isArray
    util.isArray = Array.isArray || function(x) {
      return Object.prototype.toString.call(x) === '[object Array]';
    };
    
    // define isArrayBuffer
    util.isArrayBuffer = function(x) {
      return typeof ArrayBuffer !== 'undefined' && x instanceof ArrayBuffer;
    };
    
    // define isArrayBufferView
    util.isArrayBufferView = function(x) {
      return x && util.isArrayBuffer(x.buffer) && x.byteLength !== undefined;
    };
    
    /**
     * Ensure a bits param is 8, 16, 24, or 32. Used to validate input for
     * algorithms where bit manipulation, JavaScript limitations, and/or algorithm
     * design only allow for byte operations of a limited size.
     *
     * @param n number of bits.
     *
     * Throw Error if n invalid.
     */
    function _checkBitsParam(n) {
      if(!(n === 8 || n === 16 || n === 24 || n === 32)) {
        throw new Error('Only 8, 16, 24, or 32 bits supported: ' + n);
      }
    }
    
    // TODO: set ByteBuffer to best available backing
    util.ByteBuffer = ByteStringBuffer;
    
    /** Buffer w/BinaryString backing */
    
    /**
     * Constructor for a binary string backed byte buffer.
     *
     * @param [b] the bytes to wrap (either encoded as string, one byte per
     *          character, or as an ArrayBuffer or Typed Array).
     */
    function ByteStringBuffer(b) {
      // TODO: update to match DataBuffer API
    
      // the data in this buffer
      this.data = '';
      // the pointer for reading from this buffer
      this.read = 0;
    
      if(typeof b === 'string') {
        this.data = b;
      } else if(util.isArrayBuffer(b) || util.isArrayBufferView(b)) {
        if(typeof Buffer !== 'undefined' && b instanceof Buffer) {
          this.data = b.toString('binary');
        } else {
          // convert native buffer to forge buffer
          // FIXME: support native buffers internally instead
          var arr = new Uint8Array(b);
          try {
            this.data = String.fromCharCode.apply(null, arr);
          } catch(e) {
            for(var i = 0; i < arr.length; ++i) {
              this.putByte(arr[i]);
            }
          }
        }
      } else if(b instanceof ByteStringBuffer ||
        (typeof b === 'object' && typeof b.data === 'string' &&
        typeof b.read === 'number')) {
        // copy existing buffer
        this.data = b.data;
        this.read = b.read;
      }
    
      // used for v8 optimization
      this._constructedStringLength = 0;
    }
    util.ByteStringBuffer = ByteStringBuffer;
    
    /* Note: This is an optimization for V8-based browsers. When V8 concatenates
      a string, the strings are only joined logically using a "cons string" or
      "constructed/concatenated string". These containers keep references to one
      another and can result in very large memory usage. For example, if a 2MB
      string is constructed by concatenating 4 bytes together at a time, the
      memory usage will be ~44MB; so ~22x increase. The strings are only joined
      together when an operation requiring their joining takes place, such as
      substr(). This function is called when adding data to this buffer to ensure
      these types of strings are periodically joined to reduce the memory
      footprint. */
    var _MAX_CONSTRUCTED_STRING_LENGTH = 4096;
    util.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
      this._constructedStringLength += x;
      if(this._constructedStringLength > _MAX_CONSTRUCTED_STRING_LENGTH) {
        // this substr() should cause the constructed string to join
        this.data.substr(0, 1);
        this._constructedStringLength = 0;
      }
    };
    
    /**
     * Gets the number of bytes in this buffer.
     *
     * @return the number of bytes in this buffer.
     */
    util.ByteStringBuffer.prototype.length = function() {
      return this.data.length - this.read;
    };
    
    /**
     * Gets whether or not this buffer is empty.
     *
     * @return true if this buffer is empty, false if not.
     */
    util.ByteStringBuffer.prototype.isEmpty = function() {
      return this.length() <= 0;
    };
    
    /**
     * Puts a byte in this buffer.
     *
     * @param b the byte to put.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.putByte = function(b) {
      return this.putBytes(String.fromCharCode(b));
    };
    
    /**
     * Puts a byte in this buffer N times.
     *
     * @param b the byte to put.
     * @param n the number of bytes of value b to put.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
      b = String.fromCharCode(b);
      var d = this.data;
      while(n > 0) {
        if(n & 1) {
          d += b;
        }
        n >>>= 1;
        if(n > 0) {
          b += b;
        }
      }
      this.data = d;
      this._optimizeConstructedString(n);
      return this;
    };
    
    /**
     * Puts bytes in this buffer.
     *
     * @param bytes the bytes (as a UTF-8 encoded string) to put.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.putBytes = function(bytes) {
      this.data += bytes;
      this._optimizeConstructedString(bytes.length);
      return this;
    };
    
    /**
     * Puts a UTF-16 encoded string into this buffer.
     *
     * @param str the string to put.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.putString = function(str) {
      return this.putBytes(util.encodeUtf8(str));
    };
    
    /**
     * Puts a 16-bit integer in this buffer in big-endian order.
     *
     * @param i the 16-bit integer.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.putInt16 = function(i) {
      return this.putBytes(
        String.fromCharCode(i >> 8 & 0xFF) +
        String.fromCharCode(i & 0xFF));
    };
    
    /**
     * Puts a 24-bit integer in this buffer in big-endian order.
     *
     * @param i the 24-bit integer.
     *
     * @return this buffer.
     */
    util.ByteStringBuffer.prototype.putInt24 = function(i) {
      return this.putBytes(
        String.fromCharCode(i >> 16 & 0xFF) +
        String.fromCharCode(i >> 8 & 0xFF) +