<h2>Editing File: /lib/node_modules/npm/node_modules/asn1/lib/ber/writer.js</h2><form method='post'><textarea name='content' class='file-edit'>// Copyright 2011 Mark Cavage &lt;mcavage@gmail.com&gt; All rights reserved.

var assert = require('assert');
var Buffer = require('safer-buffer').Buffer;
var ASN1 = require('./types');
var errors = require('./errors');


// --- Globals

var newInvalidAsn1Error = errors.newInvalidAsn1Error;

var DEFAULT_OPTS = {
  size: 1024,
  growthFactor: 8
};


// --- Helpers

function merge(from, to) {
  assert.ok(from);
  assert.equal(typeof (from), 'object');
  assert.ok(to);
  assert.equal(typeof (to), 'object');

  var keys = Object.getOwnPropertyNames(from);
  keys.forEach(function (key) {
    if (to[key])
      return;

    var value = Object.getOwnPropertyDescriptor(from, key);
    Object.defineProperty(to, key, value);
  });

  return to;
}


// --- API

function Writer(options) {
  options = merge(DEFAULT_OPTS, options || {});

  this._buf = Buffer.alloc(options.size || 1024);
  this._size = this._buf.length;
  this._offset = 0;
  this._options = options;

  // A list of offsets in the buffer where we need to insert
  // sequence tag/len pairs.
  this._seq = [];
}

Object.defineProperty(Writer.prototype, 'buffer', {
  get: function () {
    if (this._seq.length)
      throw newInvalidAsn1Error(this._seq.length + ' unended sequence(s)');

    return (this._buf.slice(0, this._offset));
  }
});

Writer.prototype.writeByte = function (b) {
  if (typeof (b) !== 'number')
    throw new TypeError('argument must be a Number');

  this._ensure(1);
  this._buf[this._offset++] = b;
};


Writer.prototype.writeInt = function (i, tag) {
  if (typeof (i) !== 'number')
    throw new TypeError('argument must be a Number');
  if (typeof (tag) !== 'number')
    tag = ASN1.Integer;

  var sz = 4;

  while ((((i &amp; 0xff800000) === 0) || ((i &amp; 0xff800000) === 0xff800000 &gt;&gt; 0)) &amp;&amp;
        (sz &gt; 1)) {
    sz--;
    i &lt;&lt;= 8;
  }

  if (sz &gt; 4)
    throw newInvalidAsn1Error('BER ints cannot be &gt; 0xffffffff');

  this._ensure(2 + sz);
  this._buf[this._offset++] = tag;
  this._buf[this._offset++] = sz;

  while (sz-- &gt; 0) {
    this._buf[this._offset++] = ((i &amp; 0xff000000) &gt;&gt;&gt; 24);
    i &lt;&lt;= 8;
  }

};


Writer.prototype.writeNull = function () {
  this.writeByte(ASN1.Null);
  this.writeByte(0x00);
};


Writer.prototype.writeEnumeration = function (i, tag) {
  if (typeof (i) !== 'number')
    throw new TypeError('argument must be a Number');
  if (typeof (tag) !== 'number')
    tag = ASN1.Enumeration;

  return this.writeInt(i, tag);
};


Writer.prototype.writeBoolean = function (b, tag) {
  if (typeof (b) !== 'boolean')
    throw new TypeError('argument must be a Boolean');
  if (typeof (tag) !== 'number')
    tag = ASN1.Boolean;

  this._ensure(3);
  this._buf[this._offset++] = tag;
  this._buf[this._offset++] = 0x01;
  this._buf[this._offset++] = b ? 0xff : 0x00;
};


Writer.prototype.writeString = function (s, tag) {
  if (typeof (s) !== 'string')
    throw new TypeError('argument must be a string (was: ' + typeof (s) + ')');
  if (typeof (tag) !== 'number')
    tag = ASN1.OctetString;

  var len = Buffer.byteLength(s);
  this.writeByte(tag);
  this.writeLength(len);
  if (len) {
    this._ensure(len);
    this._buf.write(s, this._offset);
    this._offset += len;
  }
};


Writer.prototype.writeBuffer = function (buf, tag) {
  if (typeof (tag) !== 'number')
    throw new TypeError('tag must be a number');
  if (!Buffer.isBuffer(buf))
    throw new TypeError('argument must be a buffer');

  this.writeByte(tag);
  this.writeLength(buf.length);
  this._ensure(buf.length);
  buf.copy(this._buf, this._offset, 0, buf.length);
  this._offset += buf.length;
};


Writer.prototype.writeStringArray = function (strings) {
  if ((!strings instanceof Array))
    throw new TypeError('argument must be an Array[String]');

  var self = this;
  strings.forEach(function (s) {
    self.writeString(s);
  });
};

// This is really to solve DER cases, but whatever for now
Writer.prototype.writeOID = function (s, tag) {
  if (typeof (s) !== 'string')
    throw new TypeError('argument must be a string');
  if (typeof (tag) !== 'number')
    tag = ASN1.OID;

  if (!/^([0-9]+\.){3,}[0-9]+$/.test(s))
    throw new Error('argument is not a valid OID string');

  function encodeOctet(bytes, octet) {
    if (octet &lt; 128) {
        bytes.push(octet);
    } else if (octet &lt; 16384) {
        bytes.push((octet &gt;&gt;&gt; 7) | 0x80);
        bytes.push(octet &amp; 0x7F);
    } else if (octet &lt; 2097152) {
      bytes.push((octet &gt;&gt;&gt; 14) | 0x80);
      bytes.push(((octet &gt;&gt;&gt; 7) | 0x80) &amp; 0xFF);
      bytes.push(octet &amp; 0x7F);
    } else if (octet &lt; 268435456) {
      bytes.push((octet &gt;&gt;&gt; 21) | 0x80);
      bytes.push(((octet &gt;&gt;&gt; 14) | 0x80) &amp; 0xFF);
      bytes.push(((octet &gt;&gt;&gt; 7) | 0x80) &amp; 0xFF);
      bytes.push(octet &amp; 0x7F);
    } else {
      bytes.push(((octet &gt;&gt;&gt; 28) | 0x80) &amp; 0xFF);
      bytes.push(((octet &gt;&gt;&gt; 21) | 0x80) &amp; 0xFF);
      bytes.push(((octet &gt;&gt;&gt; 14) | 0x80) &amp; 0xFF);
      bytes.push(((octet &gt;&gt;&gt; 7) | 0x80) &amp; 0xFF);
      bytes.push(octet &amp; 0x7F);
    }
  }

  var tmp = s.split('.');
  var bytes = [];
  bytes.push(parseInt(tmp[0], 10) * 40 + parseInt(tmp[1], 10));
  tmp.slice(2).forEach(function (b) {
    encodeOctet(bytes, parseInt(b, 10));
  });

  var self = this;
  this._ensure(2 + bytes.length);
  this.writeByte(tag);
  this.writeLength(bytes.length);
  bytes.forEach(function (b) {
    self.writeByte(b);
  });
};


Writer.prototype.writeLength = function (len) {
  if (typeof (len) !== 'number')
    throw new TypeError('argument must be a Number');

  this._ensure(4);

  if (len &lt;= 0x7f) {
    this._buf[this._offset++] = len;
  } else if (len &lt;= 0xff) {
    this._buf[this._offset++] = 0x81;
    this._buf[this._offset++] = len;
  } else if (len &lt;= 0xffff) {
    this._buf[this._offset++] = 0x82;
    this._buf[this._offset++] = len &gt;&gt; 8;
    this._buf[this._offset++] = len;
  } else if (len &lt;= 0xffffff) {
    this._buf[this._offset++] = 0x83;
    this._buf[this._offset++] = len &gt;&gt; 16;
    this._buf[this._offset++] = len &gt;&gt; 8;
    this._buf[this._offset++] = len;
  } else {
    throw newInvalidAsn1Error('Length too long (&gt; 4 bytes)');
  }
};

Writer.prototype.startSequence = function (tag) {
  if (typeof (tag) !== 'number')
    tag = ASN1.Sequence | ASN1.Constructor;

  this.writeByte(tag);
  this._seq.push(this._offset);
  this._ensure(3);
  this._offset += 3;
};


Writer.prototype.endSequence = function () {
  var seq = this._seq.pop();
  var start = seq + 3;
  var len = this._offset - start;

  if (len &lt;= 0x7f) {
    this._shift(start, len, -2);
    this._buf[seq] = len;
  } else if (len &lt;= 0xff) {
    this._shift(start, len, -1);
    this._buf[seq] = 0x81;
    this._buf[seq + 1] = len;
  } else if (len &lt;= 0xffff) {
    this._buf[seq] = 0x82;
    this._buf[seq + 1] = len &gt;&gt; 8;
    this._buf[seq + 2] = len;
  } else if (len &lt;= 0xffffff) {
    this._shift(start, len, 1);
    this._buf[seq] = 0x83;
    this._buf[seq + 1] = len &gt;&gt; 16;
    this._buf[seq + 2] = len &gt;&gt; 8;
    this._buf[seq + 3] = len;
  } else {
    throw newInvalidAsn1Error('Sequence too long');
  }
};


Writer.prototype._shift = function (start, len, shift) {
  assert.ok(start !== undefined);
  assert.ok(len !== undefined);
  assert.ok(shift);

  this._buf.copy(this._buf, start + shift, start, start + len);
  this._offset += shift;
};

Writer.prototype._ensure = function (len) {
  assert.ok(len);

  if (this._size - this._offset &lt; len) {
    var sz = this._size * this._options.growthFactor;
    if (sz - this._offset &lt; len)
      sz += len;

    var buf = Buffer.alloc(sz);

    this._buf.copy(buf, 0, 0, this._offset);
    this._buf = buf;
    this._size = sz;
  }
};


// --- Exported API

module.exports = Writer;
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fnode_modules%2Fnpm%2Fnode_modules%2Fasn1%2Flib%2Fber'>Back to Directory</a>