Creates a new `DOTHAT` object.
@constructor
172572
function DOTHAT() {
    if (!(this instanceof DOTHAT)) {
        return new DOTHAT();
    }
    
    this.displayOTron = new DisplayOTron('HAT');
    this.lcd = new LCD(this.displayOTron);
    this.backlight = new Backlight(this.displayOTron);
    this.barGraph = new BarGraph(this.displayOTron);
    this.touch = new Touch(this.displayOTron);
}
896748
function mask( obj ){
	if ( Object.create ){
		var T = function Masked(){};

		T.prototype = obj;

		return new T();
	}else{
		return Object.create( obj );
	}
}
1074818
function Hub() {
        log.info("instantiate hub");
        // get non-ambiguous this
        var self = this;
        // Call parent constructor
        Hub.super_.call(self);
        // Internal structures
        self._subscribers = {};
        // subsribers is { source._id: {'source': source, patterns: [pattern*]}}
        self._transport = undefined;
        self._closed = false;
        // state listeners
        self.once('close', function handleClosed() {
            self._closed = true;
        });
        // Constructor.  Return undefined.
        return undefined;
    }
1092829
function create() {
  var out = new glMatrix.ARRAY_TYPE(9);
  if (glMatrix.ARRAY_TYPE != Float32Array) {
    out[1] = 0;
    out[2] = 0;
    out[3] = 0;
    out[5] = 0;
    out[6] = 0;
    out[7] = 0;
  }
  out[0] = 1;
  out[4] = 1;
  out[8] = 1;
  return out;
}
1161501
function Dotfile(basename, options) {
  this.basename = basename;
  this.extname = '.json';
  this.dirname = (options && typeof options.dirname === 'string') ? options.dirname : Dotfile._tilde;
  this.filepath = path.join(this.dirname, '.' + this.basename + this.extname);
}
147136
function (className,config,modulePath,npmPath)
		{
			var module = this.createClass(className,config,modulePath,npmPath);
			return module;
		}
352990
function peg$subclass(child, parent) {
  function ctor() {
    this.constructor = child;
  }
  ctor.prototype = parent.prototype;
  child.prototype = new ctor();
}
611797
function createHttp() {
    if (typeof options.http === 'undefined') {
      log('http | no options.http; no server');
      return onListen('http');
    }

    if (typeof options.http !== 'object') {
      options.http = {
        port: options.http
      };
    }

    var server = http.createServer(options.http.handler || handler),
        timeout = options.timeout || options.http.timeout,
        port   = !isNaN(options.http.port) ? +options.http.port : 80, // accepts string or number
        args;

    if (typeof timeout === 'number') server.setTimeout(timeout);

    args = [server, port];
    if (options.http.host) {
      args.push(options.http.host);
    }

    log('http | try listen ' + port);
    args.push(function listener(err) { onListen('http', err, this); });
    connected.apply(null, args);
  }
79643
function createInstance(datum, index) {
    const selection = select(this);
    setInstance(this, {
      component, selection, destroy, datum, index,
    });
    create(selection, datum, index);
  }
360969
function createNewDebugger(scopename, opts = {}) {
    const handler = {

        get(target, propKey, receiver) {

            return function (...args) {

                const origMethod = target[propKey];

                // Always return immediately all but the specified console methods.
                if (!propKey.match(/debug|log|info|group|groupEnd/)) {
                    if(opts.quiet) {return}
                    const result = origMethod.apply(this, args);
                    return result
                }
                
                if (typeof localStorage === "undefined") {
                    // "Your environment does not have localStorage"
                    return
                } else if (!localStorage['cth-debug']) {
                    // Returning because no cth-debug variable is set
                    return
                }

                const pattern = globToRegexp(localStorage['cth-debug'])

                if (pattern.test(scopename)) {
                    if(opts.quiet) {return}
                    const result = origMethod.apply(this, args);
                    return result
                } else {
                    // Return null when a call was rejected (mainly for unit tests)
                    return null
                }
            }
        }
    }
    return new Proxy(console, handler)
}
1001139
function createDBAdapter() {
  var returnObj = {
    getMeta,
    patchMeta
  };

  for (const key in db) {
    /* istanbul ignore else */
    if (db.hasOwnProperty(key) && key.indexOf('Meta') === -1) {
      returnObj[key] = db[key];
    }
  }

  return returnObj;
}
193438
function construct(ctor, args) {
  function F() {
    return ctor.apply(this, args);
  }
  F.prototype = ctor.prototype;
  return new F();
}
339251
function createContainer(module) {
  var mapStateToProps = function mapStateToProps(state) {
    return state[module.name];
  };
  var mapDispatchToProps = function mapDispatchToProps(dispatch) {
    return Object.keys(module.actions).map(function (key) {
      var action = module.actions[key];
      return dispatch(action());
    });
  };

  var Container = function Container(props) {
    return props.children(props);
  };
  return (0, _reactRedux.connect)(mapStateToProps, module.actions || {})(Container);
}
1090088
function DOT3k() {
    if (!(this instanceof DOT3k)) {
        return new DOT3k();
    }
    
    this.displayOTron = new DisplayOTron('3k');
    this.lcd = new LCD(this.displayOTron);
    this.backlight = new Backlight(this.displayOTron);
    this.barGraph = new BarGraph(this.displayOTron);
    this.joystick = new Joystick(this.displayOTron);
}
997031
function create() {
  function app(stanza) { app.handle(stanza); }
  utils.merge(app, application);
  app._stack = [];
  app._filters = [];
  for (var i = 0; i < arguments.length; ++i) {
    app.use(arguments[i]);
  }
  return app;
}
765872
function(n){
        var mult = Math.sqrt(n*n/this.dot(this));
        return new Vec2(this.x*mult, this.y*mult);
    }
1172996
function create({
    pending = false, // eslint-disable-line no-shadow
    refreshing = false, // eslint-disable-line no-shadow
    fulfilled = false, // eslint-disable-line no-shadow
    rejected = false, // eslint-disable-line no-shadow
    value = null,
    reason = null,
}) {
    return {
        pending,
        refreshing,
        fulfilled,
        rejected,
        value,
        reason,
    };
}