function Writer() {
        /**
         * Current length.
         * @type {number}
         */
        this.len = 0;

        /**
         * Operations head.
         * @type {Object}
         */
        this.head = new Op(noop, 0, 0);

        /**
         * Operations tail
         * @type {Object}
         */
        this.tail = this.head;

        /**
         * Linked forked states.
         * @type {Object|null}
         */
        this.states = null;

        // When a value is written, the writer calculates its byte length and puts it into a linked
        // list of operations to perform when finish() is called. This both allows us to allocate
        // buffers of the exact required size and reduces the amount of work we have to do compared
        // to first calculating over objects and then encoding over objects. In our case, the encoding
        // part is just a linked list walk calling operations with already prepared values.
      }
/**
       * Constructs a new writer instance.
       * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
       * @constructor
       */
Constructs a new writer instance.
@classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.
@constructor
Constructs a new writer instance . @classdesc Wire format writer using ` Uint8Array ` if available otherwise ` Array ` . @constructor
function Writer() {
        this.len = 0;
        this.head = new Op(noop, 0, 0);
        this.tail = this.head;
        this.states = null;
      }
function Writer ( ) { this . len = 0 ; this . head = new Op ( noop , 0 , 0 ) ; this . tail = this . head ; this . states = null ; }
Constructs a new writer instance.
Constructs a new writer instance .
/**
         * Current length.
         * @type {number}
         */ /**
         * Operations head.
         * @type {Object}
         */ /**
         * Operations tail
         * @type {Object}
         */ /**
         * Linked forked states.
         * @type {Object|null}
         */ // When a value is written, the writer calculates its byte length and puts it into a linked // list of operations to perform when finish() is called. This both allows us to allocate // buffers of the exact required size and reduces the amount of work we have to do compared // to first calculating over objects and then encoding over objects. In our case, the encoding // part is just a linked list walk calling operations with already prepared values.