Lines Matching full:input
27996 this.error('Input not Buffer');
28345 Node.prototype._decode = function decode(input, options) {
28348 if (state.parent === null) return input.wrapResult(state.children[0]._decode(input, options));
28352 if (state.key !== null) prevKey = input.enterKey(state.key); // Check if tag is there
28360 var save = input.save();
28363 …state.choice === null) this._decodeGeneric(state.tag, input, options);else this._decodeChoice(inpu…
28369 input.restore(save);
28371 present = this._peekTag(input, tag, state.any);
28372 if (input.isError(present)) return present;
28378 if (state.obj && present) prevObj = input.enterObject();
28383 var explicit = this._decodeTag(input, state.explicit);
28385 if (input.isError(explicit)) return explicit;
28386 input = explicit;
28389 var start = input.offset; // Unwrap implicit and normal values
28394 if (state.any) _save = input.save();
28396 …var body = this._decodeTag(input, state.implicit !== null ? state.implicit : state.tag, state.any);
28398 if (input.isError(body)) return body;
28399 if (state.any) result = input.raw(_save);else input = body;
28402 …if (options && options.track && state.tag !== null) options.track(input.path(), start, input.lengt…
28403 …tions && options.track && state.tag !== null) options.track(input.path(), input.offset, input.leng…
28407 result = this._decodeGeneric(state.tag, input, options);
28409 result = this._decodeChoice(input, options);
28412 if (input.isError(result)) return result; // Decode children
28418 child._decode(input, options);
28425 result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
28430 if (state.obj && present) result = input.leaveObject(prevObj); // Set key
28432 …(result !== null || present === true)) input.leaveKey(prevKey, state.key, result);else if (prevKey…
28436 Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
28439 …input, tag, state.args[0], options);else if (/str$/.test(tag)) return this._decodeStr(input, tag, …
28442 return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
28444 return input.error('unknown tag: ' + tag);
28463 Node.prototype._decodeChoice = function decodeChoice(input, options) {
28468 var save = input.save();
28472 var value = node._decode(input, options);
28474 if (input.isError(value)) return false;
28481 input.restore(save);
28487 if (!match) return input.error('Choice not matched');
28538 … if (_typeof(data) !== 'object') return reporter.error('Child expected, but input is not object');
29134 var input = Buffer.from(base64, 'base64');
29135 return DERDecoder.prototype.decode.call(this, input, options);
32443 MPrime.prototype.split = function split(input, out) {
32444 input.iushrn(this.n, 0, out);
32457 K256.prototype.split = function split(input, output) {
32460 var outLen = Math.min(input.length, 9);
32463 output.words[i] = input.words[i];
32468 if (input.length <= 9) {
32469 input.words[0] = 0;
32470 input.length = 1;
32475 var prev = input.words[9];
32478 for (i = 10; i < input.length; i++) {
32479 var next = input.words[i] | 0;
32480 input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
32485 input.words[i - 10] = prev;
32487 if (prev === 0 && input.length > 10) {
32488 input.length -= 10;
32490 input.length -= 9;
36145 MPrime.prototype.split = function split(input, out) {
36146 input.iushrn(this.n, 0, out);
36159 K256.prototype.split = function split(input, output) {
36162 var outLen = Math.min(input.length, 9);
36165 output.words[i] = input.words[i];
36170 if (input.length <= 9) {
36171 input.words[0] = 0;
36172 input.length = 1;
36177 var prev = input.words[9];
36180 for (i = 10; i < input.length; i++) {
36181 var next = input.words[i] | 0;
36182 input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
36187 input.words[i - 10] = prev;
36189 if (prev === 0 && input.length > 10) {
36190 input.length -= 10;
36192 input.length -= 9;
42477 module.exports = function (input, PREFERRED_STRING) {
42478 if (!isObject(input)) return input;
42480 …if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(inpu…
42481 if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
42482 …if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(inp…
43013 fetch: function fetch(input /* , init */) {
44759 } // Buffer rest of the input
48618 // check whether the input is a positive number (whose value is zero or
50741 exports.encode = function (input) {
50745 len = input.length,
50747 var isArray = utils.getTypeOf(input) !== "string";
50749 while (i < input.length) {
50753 chr1 = input.charCodeAt(i++);
50754 chr2 = i < len ? input.charCodeAt(i++) : 0;
50755 chr3 = i < len ? input.charCodeAt(i++) : 0;
50757 chr1 = input[i++];
50758 chr2 = i < len ? input[i++] : 0;
50759 chr3 = i < len ? input[i++] : 0;
50773 exports.decode = function (input) {
50780 if (input.substr(0, dataUrlPrefix.length) === dataUrlPrefix) {
50784 // We can detect that the string input looks like a data url but we
50787 throw new Error("Invalid base64 input, it looks like a data url.");
50790 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
50791 var totalLength = input.length * 3 / 4;
50793 if (input.charAt(input.length - 1) === _keyStr.charAt(64)) {
50797 if (input.charAt(input.length - 2) === _keyStr.charAt(64)) {
50804 // - the input is not a base64 content
50805 // - the input is *almost* a base64 content, with a extra chars at the
50807 // - the input uses a base64 variant (base64url for example)
50808 throw new Error("Invalid base64 input, bad content length.");
50819 while (i < input.length) {
50820 enc1 = _keyStr.indexOf(input.charAt(i++));
50821 enc2 = _keyStr.indexOf(input.charAt(i++));
50822 enc3 = _keyStr.indexOf(input.charAt(i++));
50823 enc4 = _keyStr.indexOf(input.charAt(i++));
50994 module.exports = function crc32wrapper(input, crc) {
50995 if (typeof input === "undefined" || !input.length) {
50999 var isArray = utils.getTypeOf(input) !== "string";
51002 return crc32(crc | 0, input, input.length, 0);
51004 return crc32str(crc | 0, input, input.length, 0);
51862 var input = files[i];
51863 zip.file(input.fileNameStr, input.decompressed, {
51866 date: input.date,
51867 dir: input.dir,
51868 comment: input.fileCommentStr.length ? input.fileCommentStr : null,
51869 unixPermissions: input.unixPermissions,
51870 dosPermissions: input.dosPermissions,
51898 GenericWorker.call(this, "Nodejs stream input adapter for " + filename);
54038 * @param {Object} input the input.
54039 * @return {Object} the same input.
54043 function identity(input) {
54044 return input;
54203 "array": function array(input) {
54204 return stringToArrayLike(input, new Array(input.length));
54206 "arraybuffer": function arraybuffer(input) {
54207 return transform["string"]["uint8array"](input).buffer;
54209 "uint8array": function uint8array(input) {
54210 return stringToArrayLike(input, new Uint8Array(input.length));
54212 "nodebuffer": function nodebuffer(input) {
54213 return stringToArrayLike(input, nodejsUtils.allocBuffer(input.length));
54220 "arraybuffer": function arraybuffer(input) {
54221 return new Uint8Array(input).buffer;
54223 "uint8array": function uint8array(input) {
54224 return new Uint8Array(input);
54226 "nodebuffer": function nodebuffer(input) {
54227 return nodejsUtils.newBufferFrom(input);
54232 "string": function string(input) {
54233 return arrayLikeToString(new Uint8Array(input));
54235 "array": function array(input) {
54236 return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
54239 "uint8array": function uint8array(input) {
54240 return new Uint8Array(input);
54242 "nodebuffer": function nodebuffer(input) {
54243 return nodejsUtils.newBufferFrom(new Uint8Array(input));
54249 "array": function array(input) {
54250 return arrayLikeToArrayLike(input, new Array(input.length));
54252 "arraybuffer": function arraybuffer(input) {
54253 return input.buffer;
54256 "nodebuffer": function nodebuffer(input) {
54257 return nodejsUtils.newBufferFrom(input);
54263 "array": function array(input) {
54264 return arrayLikeToArrayLike(input, new Array(input.length));
54266 "arraybuffer": function arraybuffer(input) {
54267 return transform["nodebuffer"]["uint8array"](input).buffer;
54269 "uint8array": function uint8array(input) {
54270 return arrayLikeToArrayLike(input, new Uint8Array(input.length));
54275 * Transform an input into any type.
54277 * If no output type is specified, the unmodified input will be returned.
54279 * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
54283 exports.transformTo = function (outputType, input) {
54284 if (!input) {
54287 input = "";
54291 return input;
54295 var inputType = exports.getTypeOf(input);
54296 var result = transform[inputType][outputType](input);
54300 * Return the type of the input.
54302 * @param {Object} input the input to identify.
54303 * @return {String} the (lowercase) type of the input.
54307 exports.getTypeOf = function (input) {
54308 if (typeof input === "string") {
54312 if (Object.prototype.toString.call(input) === "[object Array]") {
54316 if (support.nodebuffer && nodejsUtils.isBuffer(input)) {
54320 if (support.uint8array && input instanceof Uint8Array) {
54324 if (support.arraybuffer && input instanceof ArrayBuffer) {
61947 * - data (Uint8Array|Array|ArrayBuffer|String): input data. Strings will be
61952 * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with
61960 * We strongly recommend to use `Uint8Array` on input for best speed (output
61990 strm.input = strings.string2buf(data);
61992 strm.input = new Uint8Array(data);
61994 strm.input = data;
61998 strm.avail_in = strm.input.length;
62061 * Called once after you tell deflate that the input stream is
62084 * - data (Uint8Array|Array|String): input data to compress.
62118 function deflate(input, options) {
62120 deflator.push(input, true); // That will never happens, if you don't cheat with options :)
62130 * - data (Uint8Array|Array|String): input data to compress.
62138 function deflateRaw(input, options) {
62141 return deflate(input, options);
62145 * - data (Uint8Array|Array|String): input data to compress.
62153 function gzip(input, options) {
62156 return deflate(input, options);
62333 * - data (Uint8Array|Array|ArrayBuffer|String): input data
62337 * Sends input data to inflate pipe, generating [[Inflate#onData]] calls with
62345 * We strongly recommend to use `Uint8Array` on input for best speed (output
62381 strm.input = strings.binstring2buf(data);
62383 strm.input = new Uint8Array(data);
62385 strm.input = data;
62389 strm.avail_in = strm.input.length;
62435 } // When no more input data, we should check that internal inflate buffers
62489 * Called either after you tell inflate that the input stream is
62514 * - data (Uint8Array|Array|String): input data to decompress.
62541 * , input = pako.deflate([1,2,3,4,5,6,7,8,9])
62545 * output = pako.inflate(input);
62553 function inflate(input, options) {
62555 inflator.push(input, true); // That will never happens, if you don't cheat with options :)
62565 * - data (Uint8Array|Array|String): input data to decompress.
62573 function inflateRaw(input, options) {
62576 return inflate(input, options);
62580 * - data (Uint8Array|Array|String): input data to decompress.
63222 /* block not completed, need more input or more output */
63231 /* finish done, accept no more input or output */
63308 * Read a new buffer from the current input stream, update the adler32
63309 * and total number of bytes read. All deflate() input goes through
63311 * allocating a large strm->input buffer and copying from it.
63329 utils.arraySet(buf, strm.input, strm.next_in, len, start);
63395 /* Do not look for matches beyond the end of the input. This is necessary
63488 // * strstart == 0 && lookahead == 1 (input done a byte at time)
63553 /* Initialize the hash value now that we have some input: */
63577 /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
63621 * Copy without compression as much as possible from the input stream, return
63640 /* Copy as much as possible from input to output: */
63733 * Compress as much as possible from the input stream, return the current
63750 * at the end of the input file. We need MAX_MATCH bytes
63792 * of the string with itself at the start of the input file).
63909 /* Process the input block. */
63913 * at the end of the input file. We need MAX_MATCH bytes
63961 * of the string with itself at the start of the input file).
64112 * at the end of the input file. We need MAX_MATCH bytes
64397 /* Sliding window. Input bytes are read into the second half of the window,
64405 /* Actual size of window: 2*wSize, except when the user input buffer
64431 /* Number of bits by which ins_h must be shifted at each input
64552 * - if compression is not successful for the first block, all input
64554 * when input comes from standard input. (This can also be done for
64560 * adaptation to changes in the input data statistics. (Take for
64604 * longest match routines access bytes past the input. This is then
64743 …if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z…
65001 /* User must not provide more input after the first FINISH: */
65143 var input;
65198 input = strm.input;
65201 strm.input = dictionary;
65228 strm.input = input;
65350 literal and match bytes until either not enough input or output is
65352 When large enough input and output buffers are supplied to inflate(), for
65353 example, a 16K input buffer and a 64K output buffer, more than 95% of the
65366 LEN -- ran out of enough output space or enough available input
65372 - The maximum input bits used by a length/distance pair is 15 bits for the
65375 Therefore if strm.avail_in >= 6, then there is enough input to avoid
65376 checking for available input while decoding.
65388 /* local strm.input */
65392 /* have enough input while in < last */
65458 var input, output; // JS specific, because we have no pointers
65465 input = strm.input;
65485 input data or output space */
65489 hold += input[_in++] << bits;
65491 hold += input[_in++] << bits;
65526 hold += input[_in++] << bits;
65537 hold += input[_in++] << bits;
65539 hold += input[_in++] << bits;
65565 hold += input[_in++] << bits;
65569 hold += input[_in++] << bits;
65891 /* i/o: waiting for input or output to copy stored block */
66004 /* input bit accumulator */
66333 var input, output; // input/output buffers
66336 /* next input INDEX */
66342 /* available input and output */
66351 /* save starting available input and output */
66385 if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
66402 input = strm.input;
66427 hold += input[next++] << bits;
66511 hold += input[next++] << bits;
66557 hold += input[next++] << bits;
66591 hold += input[next++] << bits;
66625 hold += input[next++] << bits;
66673 utils.arraySet(state.head.extra, input, next, // extra field is limited to 65536 bytes
66683 state.check = crc32(state.check, input, copy, next);
66711 len = input[next + copy++];
66722 state.check = crc32(state.check, input, copy, next);
66749 len = input[next + copy++];
66760 state.check = crc32(state.check, input, copy, next);
66786 hold += input[next++] << bits;
66819 hold += input[next++] << bits;
66877 hold += input[next++] << bits;
66946 hold += input[next++] << bits;
66994 utils.arraySet(output, input, next, copy, put); //---//
67016 hold += input[next++] << bits;
67065 hold += input[next++] << bits;
67125 hold += input[next++] << bits;
67146 hold += input[next++] << bits;
67177 hold += input[next++] << bits;
67202 hold += input[next++] << bits;
67312 input = strm.input;
67344 hold += input[next++] << bits;
67371 hold += input[next++] << bits;
67426 hold += input[next++] << bits;
67466 hold += input[next++] << bits;
67493 hold += input[next++] << bits;
67533 hold += input[next++] << bits;
67651 hold |= input[next++] << bits;
67693 hold += input[next++] << bits;
69056 //charf *buf; /* the input data */
69694 //charf *buf; /* input block */
69695 //ulg stored_len; /* length of input block */
69722 //charf *buf; /* input block, or NULL if too old */
69723 //ulg stored_len; /* length of input block */
69777 * Otherwise we can't have processed more than WSIZE input bytes since
69893 /* next input byte */
69894 this.input = null; // JS specific, because we have no pointers
69897 /* number of bytes available at input */
69900 /* total number of input bytes read so far */
72777 // While the output is causally related to the input, it's not a
72800 // here. For example, imagine a stream where every byte of input is
72804 // amount of input, and end up with a very large amount of output. In
72892 // 'chunk' is an input chunk.
80242 // While the output is causally related to the input, it's not a
80265 // here. For example, imagine a stream where every byte of input is
80269 // amount of input, and end up with a very large amount of output. In
80357 // 'chunk' is an input chunk.
82573 function md5ToHexEncodedArray(input) {
82575 var length32 = input.length * 32;
82579 var x = input[i >> 5] >>> i % 32 & 0xff;
82691 function bytesToWords(input) {
82692 if (input.length === 0) {
82696 var length8 = input.length * 8;
82700 output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
82984 // - One or more input array values don't map to a hex octet (leading to
82986 // - Invalid input values for the RFC `version` or `variant` fields