Lines Matching refs:offset
313 var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
324 this.nativeCol = decoded.col + offset;
326 this.nativeRow = decoded.row + offset;
334 this.col = address.col + offset;
335 this.row = address.row + offset;
1994 var offset = 0;
1998 offset = 1;
2002 _this2._worksheet.getCell(index + offset, colNumber).value = value;
3173 var offset = 0;
3177 offset = 1;
3183 address: colCache.encodeAddress(_this._number, index + offset),
3185 col: index + offset
6210 var offset = colCache.decode(fromCell);
6234 col += to.col - offset.col;
6238 row += to.row - offset.row;
6287 value: function copy(target, targetOffset, offset, length) {
6288 return this.toBuffer().copy(target, targetOffset, offset, length);
6319 value: function copy(target, targetOffset, offset, length) {
6321 return this._data._buf.copy(target, targetOffset, offset, length);
6348 value: function copy(target, targetOffset, offset, length) {
6349 this._data.copy(target, targetOffset, offset, length);
6417 value: function write(chunk, offset, length) {
6421 chunk.copy(this.buffer, this.iWrite, offset, offset + size);
28001 this.offset = 0;
28014 …r(data.base) && data.constructor.name === 'DecoderBuffer' && typeof data.offset === 'number' && ty…
28020 offset: this.offset,
28028 res.offset = save.offset;
28029 res.length = this.offset;
28030 this.offset = save.offset;
28036 return this.offset === this.length;
28040 …if (this.offset + 1 <= this.length) return this.base.readUInt8(this.offset++, true);else return th…
28044 if (!(this.offset + bytes <= this.length)) return this.error(fail || 'DecoderBuffer overrun');
28048 res.offset = this.offset;
28049 res.length = this.offset + bytes;
28050 this.offset += bytes;
28055 return this.base.slice(save ? save.offset : this.offset, this.length);
28093 EncoderBuffer.prototype.join = function join(out, offset) {
28095 if (!offset) offset = 0;
28100 item.join(out, offset);
28101 offset += item.length;
28104 …offset] = this.value;else if (typeof this.value === 'string') out.write(this.value, offset);else i…
28105 offset += this.length;
28389 var start = input.offset; // Unwrap implicit and normal values
28403 …if (options && options.track && state.tag !== null) options.track(input.path(), input.offset, inpu…
37582 var offset = start + i * blockSize;
37584 self._cache.writeUInt32BE(out[0], offset + 0);
37586 self._cache.writeUInt32BE(out[1], offset + 4);
37588 self._cache.writeUInt32BE(out[2], offset + 8);
37590 self._cache.writeUInt32BE(out[3], offset + 12);
39068 if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
39069 if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
39361 target = Buffer.from(target, target.offset, target.byteLength);
39566 function hexWrite(buf, string, offset, length) {
39567 offset = Number(offset) || 0;
39568 var remaining = buf.length - offset;
39589 buf[offset + i] = parsed;
39595 function utf8Write(buf, string, offset, length) {
39596 return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
39599 function asciiWrite(buf, string, offset, length) {
39600 return blitBuffer(asciiToBytes(string), buf, offset, length);
39603 function latin1Write(buf, string, offset, length) {
39604 return asciiWrite(buf, string, offset, length);
39607 function base64Write(buf, string, offset, length) {
39608 return blitBuffer(base64ToBytes(string), buf, offset, length);
39611 function ucs2Write(buf, string, offset, length) {
39612 return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
39615 Buffer.prototype.write = function write(string, offset, length, encoding) {
39617 if (offset === undefined) {
39620 offset = 0; // Buffer#write(string, encoding)
39621 } else if (length === undefined && typeof offset === 'string') {
39622 encoding = offset;
39624 offset = 0; // Buffer#write(string, offset[, length][, encoding])
39625 } else if (isFinite(offset)) {
39626 offset = offset >>> 0;
39639 var remaining = this.length - offset;
39642 if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
39652 return hexWrite(this, string, offset, length);
39656 return utf8Write(this, string, offset, length);
39659 return asciiWrite(this, string, offset, length);
39663 return latin1Write(this, string, offset, length);
39667 return base64Write(this, string, offset, length);
39673 return ucs2Write(this, string, offset, length);
39880 function checkOffset(offset, ext, length) {
39881 if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');
39882 if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');
39885 Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
39886 offset = offset >>> 0;
39888 if (!noAssert) checkOffset(offset, byteLength, this.length);
39889 var val = this[offset];
39894 val += this[offset + i] * mul;
39900 Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
39901 offset = offset >>> 0;
39905 checkOffset(offset, byteLength, this.length);
39908 var val = this[offset + --byteLength];
39912 val += this[offset + --byteLength] * mul;
39918 Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
39919 offset = offset >>> 0;
39920 if (!noAssert) checkOffset(offset, 1, this.length);
39921 return this[offset];
39924 Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
39925 offset = offset >>> 0;
39926 if (!noAssert) checkOffset(offset, 2, this.length);
39927 return this[offset] | this[offset + 1] << 8;
39930 Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
39931 offset = offset >>> 0;
39932 if (!noAssert) checkOffset(offset, 2, this.length);
39933 return this[offset] << 8 | this[offset + 1];
39936 Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
39937 offset = offset >>> 0;
39938 if (!noAssert) checkOffset(offset, 4, this.length);
39939 …return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000…
39942 Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
39943 offset = offset >>> 0;
39944 if (!noAssert) checkOffset(offset, 4, this.length);
39945 …return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + …
39948 Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
39949 offset = offset >>> 0;
39951 if (!noAssert) checkOffset(offset, byteLength, this.length);
39952 var val = this[offset];
39957 val += this[offset + i] * mul;
39965 Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
39966 offset = offset >>> 0;
39968 if (!noAssert) checkOffset(offset, byteLength, this.length);
39971 var val = this[offset + --i];
39974 val += this[offset + --i] * mul;
39982 Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
39983 offset = offset >>> 0;
39984 if (!noAssert) checkOffset(offset, 1, this.length);
39985 if (!(this[offset] & 0x80)) return this[offset];
39986 return (0xff - this[offset] + 1) * -1;
39989 Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
39990 offset = offset >>> 0;
39991 if (!noAssert) checkOffset(offset, 2, this.length);
39992 var val = this[offset] | this[offset + 1] << 8;
39996 Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
39997 offset = offset >>> 0;
39998 if (!noAssert) checkOffset(offset, 2, this.length);
39999 var val = this[offset + 1] | this[offset] << 8;
40003 Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
40004 offset = offset >>> 0;
40005 if (!noAssert) checkOffset(offset, 4, this.length);
40006 return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
40009 Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
40010 offset = offset >>> 0;
40011 if (!noAssert) checkOffset(offset, 4, this.length);
40012 return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
40015 Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
40016 offset = offset >>> 0;
40017 if (!noAssert) checkOffset(offset, 4, this.length);
40018 return ieee754.read(this, offset, true, 23, 4);
40021 Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
40022 offset = offset >>> 0;
40023 if (!noAssert) checkOffset(offset, 4, this.length);
40024 return ieee754.read(this, offset, false, 23, 4);
40027 Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
40028 offset = offset >>> 0;
40029 if (!noAssert) checkOffset(offset, 8, this.length);
40030 return ieee754.read(this, offset, true, 52, 8);
40033 Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
40034 offset = offset >>> 0;
40035 if (!noAssert) checkOffset(offset, 8, this.length);
40036 return ieee754.read(this, offset, false, 52, 8);
40039 function checkInt(buf, value, offset, ext, max, min) {
40042 if (offset + ext > buf.length) throw new RangeError('Index out of range');
40045 Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
40047 offset = offset >>> 0;
40052 checkInt(this, value, offset, byteLength, maxBytes, 0);
40057 this[offset] = value & 0xFF;
40060 this[offset + i] = value / mul & 0xFF;
40063 return offset + byteLength;
40066 Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
40068 offset = offset >>> 0;
40073 checkInt(this, value, offset, byteLength, maxBytes, 0);
40078 this[offset + i] = value & 0xFF;
40081 this[offset + i] = value / mul & 0xFF;
40084 return offset + byteLength;
40087 Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
40089 offset = offset >>> 0;
40090 if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
40091 this[offset] = value & 0xff;
40092 return offset + 1;
40095 Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
40097 offset = offset >>> 0;
40098 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
40099 this[offset] = value & 0xff;
40100 this[offset + 1] = value >>> 8;
40101 return offset + 2;
40104 Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
40106 offset = offset >>> 0;
40107 if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
40108 this[offset] = value >>> 8;
40109 this[offset + 1] = value & 0xff;
40110 return offset + 2;
40113 Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
40115 offset = offset >>> 0;
40116 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
40117 this[offset + 3] = value >>> 24;
40118 this[offset + 2] = value >>> 16;
40119 this[offset + 1] = value >>> 8;
40120 this[offset] = value & 0xff;
40121 return offset + 4;
40124 Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
40126 offset = offset >>> 0;
40127 if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
40128 this[offset] = value >>> 24;
40129 this[offset + 1] = value >>> 16;
40130 this[offset + 2] = value >>> 8;
40131 this[offset + 3] = value & 0xff;
40132 return offset + 4;
40135 Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
40137 offset = offset >>> 0;
40141 checkInt(this, value, offset, byteLength, limit - 1, -limit);
40147 this[offset] = value & 0xFF;
40150 if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
40154 this[offset + i] = (value / mul >> 0) - sub & 0xFF;
40157 return offset + byteLength;
40160 Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
40162 offset = offset >>> 0;
40166 checkInt(this, value, offset, byteLength, limit - 1, -limit);
40172 this[offset + i] = value & 0xFF;
40175 if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
40179 this[offset + i] = (value / mul >> 0) - sub & 0xFF;
40182 return offset + byteLength;
40185 Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
40187 offset = offset >>> 0;
40188 if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
40190 this[offset] = value & 0xff;
40191 return offset + 1;
40194 Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
40196 offset = offset >>> 0;
40197 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
40198 this[offset] = value & 0xff;
40199 this[offset + 1] = value >>> 8;
40200 return offset + 2;
40203 Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
40205 offset = offset >>> 0;
40206 if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
40207 this[offset] = value >>> 8;
40208 this[offset + 1] = value & 0xff;
40209 return offset + 2;
40212 Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
40214 offset = offset >>> 0;
40215 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
40216 this[offset] = value & 0xff;
40217 this[offset + 1] = value >>> 8;
40218 this[offset + 2] = value >>> 16;
40219 this[offset + 3] = value >>> 24;
40220 return offset + 4;
40223 Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
40225 offset = offset >>> 0;
40226 if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
40228 this[offset] = value >>> 24;
40229 this[offset + 1] = value >>> 16;
40230 this[offset + 2] = value >>> 8;
40231 this[offset + 3] = value & 0xff;
40232 return offset + 4;
40235 function checkIEEE754(buf, value, offset, ext, max, min) {
40236 if (offset + ext > buf.length) throw new RangeError('Index out of range');
40237 if (offset < 0) throw new RangeError('Index out of range');
40240 function writeFloat(buf, value, offset, littleEndian, noAssert) {
40242 offset = offset >>> 0;
40245 checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
40248 ieee754.write(buf, value, offset, littleEndian, 23, 4);
40249 return offset + 4;
40252 Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
40253 return writeFloat(this, value, offset, true, noAssert);
40256 Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
40257 return writeFloat(this, value, offset, false, noAssert);
40260 function writeDouble(buf, value, offset, littleEndian, noAssert) {
40262 offset = offset >>> 0;
40265 checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
40268 ieee754.write(buf, value, offset, littleEndian, 52, 8);
40269 return offset + 8;
40272 Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
40273 return writeDouble(this, value, offset, true, noAssert);
40276 Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
40277 return writeDouble(this, value, offset, false, noAssert);
40512 function blitBuffer(src, dst, offset, length) {
40514 if (i + offset >= dst.length || i >= src.length) break;
40515 dst[i + offset] = src[i];
44352 …(this.zone || (this.zone = {})).offset = (e = t.match(/([+-]|\d\d)/g), 0 === (n = 60 * e[1] + +e[2…
44469 …return l ? new Date(Date.UTC(p, y, v, D, M, g, Y + 60 * l.offset * 1e3)) : r ? new Date(Date.UTC(p…
49281 var offset = 0;
49283 while (this._blockOffset + data.length - offset >= this._blockSize) {
49285 block[i++] = data[offset++];
49293 while (offset < data.length) {
49294 block[this._blockOffset++] = data[offset++];
50497 exports.read = function (buffer, offset, isLE, mLen, nBytes) {
50505 var s = buffer[offset + i];
50511 for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
50517 for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
50531 exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
50576 for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
50581 for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
50583 buffer[offset + i - d] |= s * 128;
51235 …= function generateZipParts(streamInfo, streamedContent, streamingEnded, offset, platform, encodeF…
51374 decToHex(offset, 4) + // file name
52587 checkOffset: function checkOffset(offset) {
52588 this.checkIndex(this.index + offset);
54649 var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
54651 if (offset < 0) {
54666 this.reader.setIndex(offset);
54667 var endOfCentralDirOffset = offset;
54693 offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
54695 if (offset < 0) {
54699 this.reader.setIndex(offset);
58437 offset = array.length;
58440 array[offset + index] = values[index];
66014 this.offset = 0;
67516 state.offset = here_val;
67538 state.offset += hold & (1 << state.extra) - 1
67549 if (state.offset > state.dmax) {
67568 if (state.offset > copy) {
67570 copy = state.offset - copy;
67610 from = put - state.offset;
71194 function assertOffset(offset, length) {
71195 if (typeof offset !== 'number' || offset !== offset) {
71200 if (offset > kMaxUint32 || offset < 0) {
71204 if (offset > kBufferMaxLength || offset > length) {
71209 function assertSize(size, offset, length) {
71219 if (size + offset > length || size > kBufferMaxLength) {
71232 function randomFill(buf, offset, size, cb) {
71237 if (typeof offset === 'function') {
71238 cb = offset;
71239 offset = 0;
71243 size = buf.length - offset;
71248 assertOffset(offset, buf.length);
71249 assertSize(size, offset, buf.length);
71250 return actualFill(buf, offset, size, cb);
71253 function actualFill(buf, offset, size, cb) {
71256 var uint = new Uint8Array(ourBuf, offset, size);
71275 bytes.copy(buf, offset);
71282 bytes.copy(buf, offset);
71286 function randomFillSync(buf, offset, size) {
71287 if (typeof offset === 'undefined') {
71288 offset = 0;
71295 assertOffset(offset, buf.length);
71296 if (size === undefined) size = buf.length - offset;
71297 assertSize(size, offset, buf.length);
71298 return actualFill(buf, offset, size);
73962 function copyBuffer(src, target, offset) {
73963 Buffer.prototype.copy.call(src, target, offset);
78159 for (var offset = 0; offset < length;) {
78161 var remainder = Math.min(length - offset, blockSize - assigned);
78164 block[assigned + i] = data[offset + i];
78168 offset += remainder;
78651 function writeInt64BE(h, l, offset) {
78652 H.writeInt32BE(h, offset);
78653 H.writeInt32BE(l, offset + 4);
78855 function writeInt64BE(h, l, offset) {
78856 H.writeInt32BE(h, offset);
78857 H.writeInt32BE(l, offset + 4);
81114 function copyBuffer(src, target, offset) {
81115 src.copy(target, offset);
82979 var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
82982 …offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]…
83028 function v1(options, buf, offset) {
83029 var i = buf && offset || 0;
83170 function generateUUID(value, namespace, buf, offset) {
83194 offset = offset || 0;
83197 buf[offset + i] = bytes[i];
83235 function v4(options, buf, offset) {
83245 offset = offset || 0;
83248 buf[offset + i] = rnds[i];