Utilities to manipulate byte sequence
@param {(number|Uint8Array)} arg Initial size of this buffer (number), or buffer to set (Uint8Array)
@constructor
968475
function ByteBuffer(arg) {
    var initial_size;
    if (arg == null) {
        initial_size = 1024 * 1024;
    } else if (typeof arg === "number") {
        initial_size = arg;
    } else if (arg instanceof Uint8Array) {
        this.buffer = arg;
        this.position = 0;  // Overwrite
        return;
    } else {
        // typeof arg -> String
        throw typeof arg + " is invalid parameter type for ByteBuffer constructor";
    }
    // arg is null or number
    this.buffer = new Uint8Array(initial_size);
    this.position = 0;
}
796656
function _addBigIntegerToBuffer(buffer, val) {
  var hexVal = val.toString(16);
  // ensure 2s complement +ve
  if(hexVal[0] >= '8') {
    hexVal = '00' + hexVal;
  }
  var bytes = forge.util.hexToBytes(hexVal);
  buffer.putInt32(bytes.length);
  buffer.putBytes(bytes);
}
1255113
function from(arg, encodingOrOffset, length) {
  if (typeof arg === 'number') {
    throw new TypeError('Argument must not be a number')
  }
  return Buffer(arg, encodingOrOffset, length)
}
410595
function(arg, context) {
		if (gui.Type.isArray(arg)) {
			return this._breakarray(arg, context);
		} else {
			return this._breakother(arg, context);
		}
	}
865179
function onData( numValues ) {
		var i = -1, buffer;

		// Initialize the buffer array used for chunking:
		buffer = new Array( numValues );

		/**
		* FUNCTION: onData( newVal, encoding, clbk )
		*	Data event handler. Chunks data.
		*
		* @private
		* @param {Number} newVal - new streamed data value
		* @param {String} encoding
		* @param {Function} clbk - callback to invoke after handling streamed data. Function accepts two arguments: [ error, chunk ].
		*/
		return function onData( newVal, encoding, clbk ) {
			i += 1;
			buffer[ i ] = newVal;
			if ( i === numValues-1 ) {
				i = -1;
				clbk( null, buffer.slice() );
				return;
			}
			clbk();
		}; // end FUNCTION onData()
	}
1238225
function (arg) {
  if (arg instanceof Array) {
    if (arg.length === 0) return ok.call(this);
    if (arg.length === 1) return ok.call(this, arg[0]);
    if (arg.length >= 2) {
      var head = arg[0];
      var tail = arg.slice(1);
      return ok.call(this, head, tail);
    }
  }
  if (arg instanceof Object) {
    if ("x" in arg && "y" in arg) {
      return ok.call(this, arg.x, arg.y);
    }
  }
  if (typeof arg === "number") {
    return ok.call(this);
  }
}
1144448
protected void setByteArrayValue(byte[] input, int offset, int length) {
        if ((offset + length) > input.length) {
            throw new IllegalArgumentException(
                            "Invalid length: " + offset + "+" + length + " > " + input.length);
        }
        this.sValue = null;
        this.bValue = input;
        this.offset = offset;
        this.valueLength = length;
        if (ELEM_ADDED != this.status) {
            this.status = ELEM_CHANGED;
        }
    }
115183
function insertIntegerToByteArray (number, buffer, from, size) {
  let value = bigInt(number) // convert a number-like object into a big integer

  for (let pos = 0; pos < size; pos++) {
    const divmod = value.divmod(256)
    buffer[from + pos] = divmod.remainder.toJSNumber()
    value = divmod.quotient
  }

  return buffer
}
1140271
static public void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Supply a Base32-encoded argument.");
            return;
        }
        System.out.println(" Original: " + args[0]);
        byte[] decoded = Base32.decode(args[0]);
        System.out.print("      Hex: ");
        for (int i = 0; i < decoded.length; i++) {
            int b = decoded[i];
            if (b < 0) {
                b += 256;
            }
            System.out.print((Integer.toHexString(b + 256)).substring(1));
        }
        System.out.println();
        System.out.println("Reencoded: " + Base32.encode(decoded));
    }
411186
function toUTCDateString(arg) {
    var d = dateify(arg);
    var date = new Date(d.getTime() + d.getTimezoneOffset() * 60 * 1000);

    var _destructure3 = destructure(date);

    var _destructure4 = _slicedToArray(_destructure3, 6);

    var yr = _destructure4[0];
    var mn = _destructure4[1];
    var dy = _destructure4[2];
    var hr = _destructure4[3];
    var min = _destructure4[4];
    var sec = _destructure4[5];

    return yr + '-' + _padInt(mn + 1) + '-' + _padInt(dy) + ('T' + _padInt(hr) + ':' + _padInt(min) + ':' + _padInt(sec) + 'Z');
  }
1326147
function unwrapArray(arg, defaultValue) {
  const _arg = Array.isArray(arg)
    ? /* istanbul ignore next (preact) */ arg[0]
    : arg
  if (!_arg && defaultValue) {
    return defaultValue
  } else {
    return _arg
  }
}
996796
@Configurable
  public void setArgs(String arg)
  {
    int i = 0;
    int len = arg.length();

    CharBuffer cb = new CharBuffer();
    
    while (i < len) {
      char ch;
      for (; i < len && Character.isWhitespace(ch = arg.charAt(i)); i++) {
      }

      if (len <= i)
        return;

      cb.clear();

      for (; i < len && ! Character.isWhitespace(ch = arg.charAt(i)); i++)
        cb.append(ch);

      addArg(cb.toString());
    }
  }
966332
private void evalNumber(MessageArg arg) {
    initDecimalArgsParser();
    parseArgs(decimalArgsParser);
    
    BigDecimal number = arg.asBigDecimal();
    NumberFormatter formatter = CLDR_INSTANCE.getNumberFormatter(locale);
    formatter.formatDecimal(number, buf, decimalArgsParser.options());
  }
1011438
function(bufferOrArray, callback) {
    var self = this,
        ix = this.offset,
        frame = [],
        isArray = Object.prototype.toString.call( bufferOrArray) === '[object Array]';

    self.frameIx = 0;

    while (ix < bufferOrArray.length) {
      var value = isArray ? bufferOrArray[ix] : bufferOrArray['read' + self.sampleType](ix); 

      frame.push(this.map ? this.map[value] : value);

      if (frame.length == this.frameSize || ix+self.wordSize == bufferOrArray.length) finishFrame(frame);

      ix += self.wordSize;
    }

    // Did we not process any frames at all for some reason?
    if (this.frameIx == 0) callback(undefined);

    function finishFrame(frame) {
      if (this.scale) frame = frame.map(function (s, ix) {return s * self.scale[ix];});

      callback(frame, self.frameIx);

      if (ix != bufferOrArray.length - self.wordSize)
      {
          ix -= (self.frameSize - self.frameStep) * self.wordSize;

          self.frameIx++;
          frame.length = 0;
      }
    }
  }
918849
function setBytes(node, bytes) {
    if (typeof bytes === 'string') {
        bytes = ByteUtils.base64ToBytes(bytes);
    }
    setText(node, bytes ? ByteUtils.bytesToBase64(ByteUtils.arrayToBuffer(bytes)) : undefined);
}
167668
function() {
		this.prgRead = new Uint8Array( 0x8000 );
		this.prgRead.set( this.prgData.subarray( 0, 0x2000 ) );

		this.chrRead = new Uint8Array( 0x2000 );
		this.chrRead.set( this.chrData.subarray( 0, 0x2000 ) );

		mappers.init( this );
	}
598424
function (arg) {
						if ( ! arg.allow ){
							return;
						}

						var exist = false;
						for (var i in data.allow) {
							if (data.allow[i] === arg.allow) {
								exist = true;
							}
						}
						if ( exist === false ) {
							data.allow[data.allow.length] = arg.allow;
						}
					}