/*
@api private
@param {Object|undefined} opts
516805
function BufferedStream(opts) {
  opts = opts || {}

  Stream.call(this)

  // up to subclasses to decide what kind of stream we are
  this.writable = false
  this.readable = false

  this.buffers = []
  this.paused = false
  this.concat = !!opts.concat //boolean indicating if we should emit separate buffers or concat buffers into one 'emit' event
}
1173440
function setOptName(opt, optKey) {
    var key$ = optKey + '$';
    opts[key$] = opts[key$] || {};
    var name = opt.name || fspath.basename(opt.path);
    while (opts[key$][name]) {
      name = '_' + name;
    }
    opts[key$][name] = opt;
    opt.name = name;
  }
989604
function envOpts(opts) {
  var optObj = _.extend({PORT: opts.cmdOptions.port},
			parser.parseEnvOpts(opts.cmdOptions),
			parser.parseInlineVariables(opts.command));
  var optArray = [];
  return _.each(optObj, function(val, key) {
    var upperCaseKey = key.toUpperCase();
    optArray.unshift({upperCaseKey: val});
  });
}
1054054
function opt(options, name, defaultValue){
    return options && options[name]!==undefined ? options[name] : defaultValue;
}
952268
function prepareArgs(opts) {
  var valueFromOpts = valueFrom.bind(null, opts);

  return Object.keys(opts).reduce(function(acc, item) {
    acc.splice(indexFromArgs(item), 0, valueFromOpts(item));

    return acc;
  }, []);
}
52995
function writeOpts(opts) {
  return utils.extend({
    flags: opts.flags || (opts.overwrite ? 'w' : 'wx')
  }, opts);
}
46183
function(opts) {
	opts = opts || {};
	this.root = opts.path;
	this.interval = opts.interval || DEFAULT_INTERVAL;
}
241255
function(opts) {
  opts = opts || {};

  this.params = {};
  this._params = [];
  this.caseSensitive = opts.caseSensitive;
  this.mergeParams = opts.mergeParams;
  this.strict = opts.strict;
  this.stack = [];
}
1159944
function (opts, id) {
        let uri = this.classUrl
        if (id) {
          uri += '/' + id
        }

        return new Promise(function (resolve, reject) {
          new Requestor({ api_version: instance.api_version }).request({
            method: 'post',
            url: [Conekta.api_base, uri].join(''),
            data: opts.data || {},
            next: function (error, response) {
              if (!error) {
                response = this.listObjectsToArray(response)
                this._json = response
                this._id = response.id
                this.build_children()
              }
              if (opts.next !== undefined) {
                opts.next(error, this)
              } else {
                if (error) {
                  reject(error)
                } else {
                  resolve(this)
                }
              }
            }.bind(this)
          })
        }.bind(this))
      }
869962
function opt(argv, arg, index, key) {
    var value = argv[index + 1], equals = arg.indexOf('=');
    if(equals > -1) {
      value = arg.substr(equals + 1);
    }
    if(value && ~keys.indexOf(value)) {
      return value;
    }
    if(arg === option[key]) {
      return modes[key];
    }
  }
585295
function(opts) {
				var o = opts || {};
				selectCheckbox && selectAllCheckbox.find('input').prop('checked', false);
				if (Object.keys(selectedFiles).length) {
					selectLock = false;
					selectedFiles = {};
					cwd.find('[id].'+clSelected).trigger(evtUnselect);
					selectCheckbox && cwd.find('input:checkbox').prop('checked', false);
				}
				!o.notrigger && trigger();
				selectCheckbox && selectAllCheckbox.data('pending', false);
				cwd.removeClass('elfinder-cwd-allselected');
			}
16545
function defaults(opts) {
  opts = opts || {}

  if (!opts.streamer) {
    throw new Error('No streamer found. Must pass a streamer to multipart-pipe')
  }

  opts.limit = opts.limit === undefined ? '128mb' : opts.limit;
  opts.limit = typeof opts.limit === 'string' ? parseBytes(opts.limit) : opts.limit;
  opts.allow = opts.allow instanceof RegExp ? opts.allow : new RegExp(opts.allow || '.*');

  if (!opts.filename || typeof opts.filename !== 'function') {
    opts.filename = function (filename, mime) { return filename; };
  }

  return opts
}
453303
function dto(opts, cb) {
  opts = 'string' == typeof opts
    ? {path: opts}
    : opts

  const path = opts.path || process.cwd()
  cb = cb || function(){}

  assert.equal(typeof path, 'string')
  assert.equal(typeof cb, 'function')

  saveDirs(path, {}, function(err, res) {
    if (err) return cb(err)
    saveFiles(path, opts, res, cb)
  })
}
390366
function(opts) {
            var table = {};
            var data  = this.getTimes(opts) || {};
            Object.keys(data).sort().forEach(function(k) {
                table[k] = {
                    ms: data[k],
                    s: +((data[k] / 1000).toFixed(2))
                };
            });
            console.table(table);
        }
686580
function normalizeOpts (opts) {
  if (!opts) { opts = {} }

  // hmr plugin expects us to be using watchify
  if (opts.hot) {
    opts.watch = true
  }

  // root directory for all source files
  // (assume that this is the same directory as package.json)
  if (!opts.rootDir) { opts.rootDir = process.cwd() }

  // use browserify-incremental?
  if (typeof opts.inc === 'undefined') { opts.inc = true }
  if (!opts.cacheFile) { opts.cacheFile = '.bcache.json' }

  const outputDefaults = {
    dir: 'dist',
    bundle: path.basename(opts.entry)
  }

  opts.output = Object.assign({}, outputDefaults, opts.output || {})
  opts.outFile = path.join(opts.rootDir, opts.output.dir, opts.output.bundle)

  if (!opts.vendor) { opts.vendor = [] }

  return opts
}
317307
function (opts) {
        var objectGroupName = opts.name,
            objectGroup = null

        this.objectGroups.forEach(function (item) {
            if (item.name == objectGroupName) {
                objectGroup = item
            }
        })
        if (objectGroup !== null) {
            return objectGroup
        }
    }
802380
function opt (option) {
  return function (value) {
    if (typeof value === 'undefined') {
      return nn.Getopt(this.binding, nn.NN_SOL_SOCKET, sol[option]);
    }

    if(nn.Setopt(this.binding, nn.NN_SOL_SOCKET, sol[option], value) > -1) {
      return true;
    }

    throw new Error(nn.Err() + ': ' + this.type + option + '@' + value + '\n');
  }
}