bireader 3.1.2 → 3.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1930,109 +1930,109 @@ export interface BinaryAliasReader extends BiBase {
1930
1930
  /**
1931
1931
  * Read signed 64 bit integer
1932
1932
  *
1933
- * @returns {number}
1933
+ * @returns {bigint}
1934
1934
  */
1935
1935
  get int64(): bigint;
1936
1936
  /**
1937
1937
  * Read signed 64 bit integer.
1938
1938
  *
1939
- * @returns {number}
1939
+ * @returns {bigint}
1940
1940
  */
1941
1941
  get bigint(): bigint;
1942
1942
  /**
1943
1943
  * Read signed 64 bit integer.
1944
1944
  *
1945
- * @returns {number}
1945
+ * @returns {bigint}
1946
1946
  */
1947
1947
  get quad(): bigint;
1948
1948
  /**
1949
1949
  * Read unsigned 64 bit integer.
1950
1950
  *
1951
- * @returns {number}
1951
+ * @returns {bigint}
1952
1952
  */
1953
1953
  get uint64(): bigint;
1954
1954
  /**
1955
1955
  * Read unsigned 64 bit integer.
1956
1956
  *
1957
- * @returns {number}
1957
+ * @returns {bigint}
1958
1958
  */
1959
1959
  get ubigint(): bigint;
1960
1960
  /**
1961
1961
  * Read unsigned 64 bit integer.
1962
1962
  *
1963
- * @returns {number}
1963
+ * @returns {bigint}
1964
1964
  */
1965
1965
  get uquad(): bigint;
1966
1966
  /**
1967
1967
  * Read signed 64 bit integer.
1968
1968
  *
1969
- * @returns {number}
1969
+ * @returns {bigint}
1970
1970
  */
1971
1971
  get int64be(): bigint;
1972
1972
  /**
1973
1973
  * Read signed 64 bit integer.
1974
1974
  *
1975
- * @returns {number}
1975
+ * @returns {bigint}
1976
1976
  */
1977
1977
  get bigintbe(): bigint;
1978
1978
  /**
1979
1979
  * Read signed 64 bit integer.
1980
1980
  *
1981
- * @returns {number}
1981
+ * @returns {bigint}
1982
1982
  */
1983
1983
  get quadbe(): bigint;
1984
1984
  /**
1985
1985
  * Read unsigned 64 bit integer.
1986
1986
  *
1987
- * @returns {number}
1987
+ * @returns {bigint}
1988
1988
  */
1989
1989
  get uint64be(): bigint;
1990
1990
  /**
1991
1991
  * Read unsigned 64 bit integer.
1992
1992
  *
1993
- * @returns {number}
1993
+ * @returns {bigint}
1994
1994
  */
1995
1995
  get ubigintbe(): bigint;
1996
1996
  /**
1997
1997
  * Read unsigned 64 bit integer.
1998
1998
  *
1999
- * @returns {number}
1999
+ * @returns {bigint}
2000
2000
  */
2001
2001
  get uquadbe(): bigint;
2002
2002
  /**
2003
2003
  * Read signed 64 bit integer.
2004
2004
  *
2005
- * @returns {number}
2005
+ * @returns {bigint}
2006
2006
  */
2007
2007
  get int64le(): bigint;
2008
2008
  /**
2009
2009
  * Read signed 64 bit integer.
2010
2010
  *
2011
- * @returns {number}
2011
+ * @returns {bigint}
2012
2012
  */
2013
2013
  get bigintle(): bigint;
2014
2014
  /**
2015
2015
  * Read signed 64 bit integer.
2016
2016
  *
2017
- * @returns {number}
2017
+ * @returns {bigint}
2018
2018
  */
2019
2019
  get quadle(): bigint;
2020
2020
  /**
2021
2021
  * Read unsigned 64 bit integer.
2022
2022
  *
2023
- * @returns {number}
2023
+ * @returns {bigint}
2024
2024
  */
2025
2025
  get uint64le(): bigint;
2026
2026
  /**
2027
2027
  * Read unsigned 64 bit integer.
2028
2028
  *
2029
- * @returns {number}
2029
+ * @returns {bigint}
2030
2030
  */
2031
2031
  get ubigintle(): bigint;
2032
2032
  /**
2033
2033
  * Read unsigned 64 bit integer.
2034
2034
  *
2035
- * @returns {number}
2035
+ * @returns {bigint}
2036
2036
  */
2037
2037
  get uquadle(): bigint;
2038
2038
  /**
@@ -4267,109 +4267,109 @@ export interface BinaryAliasReaderStreamer extends BiBaseStreamer {
4267
4267
  /**
4268
4268
  * Read signed 64 bit integer
4269
4269
  *
4270
- * @returns {number}
4270
+ * @returns {bigint}
4271
4271
  */
4272
4272
  get int64(): bigint;
4273
4273
  /**
4274
4274
  * Read signed 64 bit integer.
4275
4275
  *
4276
- * @returns {number}
4276
+ * @returns {bigint}
4277
4277
  */
4278
4278
  get bigint(): bigint;
4279
4279
  /**
4280
4280
  * Read signed 64 bit integer.
4281
4281
  *
4282
- * @returns {number}
4282
+ * @returns {bigint}
4283
4283
  */
4284
4284
  get quad(): bigint;
4285
4285
  /**
4286
4286
  * Read unsigned 64 bit integer.
4287
4287
  *
4288
- * @returns {number}
4288
+ * @returns {bigint}
4289
4289
  */
4290
4290
  get uint64(): bigint;
4291
4291
  /**
4292
4292
  * Read unsigned 64 bit integer.
4293
4293
  *
4294
- * @returns {number}
4294
+ * @returns {bigint}
4295
4295
  */
4296
4296
  get ubigint(): bigint;
4297
4297
  /**
4298
4298
  * Read unsigned 64 bit integer.
4299
4299
  *
4300
- * @returns {number}
4300
+ * @returns {bigint}
4301
4301
  */
4302
4302
  get uquad(): bigint;
4303
4303
  /**
4304
4304
  * Read signed 64 bit integer.
4305
4305
  *
4306
- * @returns {number}
4306
+ * @returns {bigint}
4307
4307
  */
4308
4308
  get int64be(): bigint;
4309
4309
  /**
4310
4310
  * Read signed 64 bit integer.
4311
4311
  *
4312
- * @returns {number}
4312
+ * @returns {bigint}
4313
4313
  */
4314
4314
  get bigintbe(): bigint;
4315
4315
  /**
4316
4316
  * Read signed 64 bit integer.
4317
4317
  *
4318
- * @returns {number}
4318
+ * @returns {bigint}
4319
4319
  */
4320
4320
  get quadbe(): bigint;
4321
4321
  /**
4322
4322
  * Read unsigned 64 bit integer.
4323
4323
  *
4324
- * @returns {number}
4324
+ * @returns {bigint}
4325
4325
  */
4326
4326
  get uint64be(): bigint;
4327
4327
  /**
4328
4328
  * Read unsigned 64 bit integer.
4329
4329
  *
4330
- * @returns {number}
4330
+ * @returns {bigint}
4331
4331
  */
4332
4332
  get ubigintbe(): bigint;
4333
4333
  /**
4334
4334
  * Read unsigned 64 bit integer.
4335
4335
  *
4336
- * @returns {number}
4336
+ * @returns {bigint}
4337
4337
  */
4338
4338
  get uquadbe(): bigint;
4339
4339
  /**
4340
4340
  * Read signed 64 bit integer.
4341
4341
  *
4342
- * @returns {number}
4342
+ * @returns {bigint}
4343
4343
  */
4344
4344
  get int64le(): bigint;
4345
4345
  /**
4346
4346
  * Read signed 64 bit integer.
4347
4347
  *
4348
- * @returns {number}
4348
+ * @returns {bigint}
4349
4349
  */
4350
4350
  get bigintle(): bigint;
4351
4351
  /**
4352
4352
  * Read signed 64 bit integer.
4353
4353
  *
4354
- * @returns {number}
4354
+ * @returns {bigint}
4355
4355
  */
4356
4356
  get quadle(): bigint;
4357
4357
  /**
4358
4358
  * Read unsigned 64 bit integer.
4359
4359
  *
4360
- * @returns {number}
4360
+ * @returns {bigint}
4361
4361
  */
4362
4362
  get uint64le(): bigint;
4363
4363
  /**
4364
4364
  * Read unsigned 64 bit integer.
4365
4365
  *
4366
- * @returns {number}
4366
+ * @returns {bigint}
4367
4367
  */
4368
4368
  get ubigintle(): bigint;
4369
4369
  /**
4370
4370
  * Read unsigned 64 bit integer.
4371
4371
  *
4372
- * @returns {number}
4372
+ * @returns {bigint}
4373
4373
  */
4374
4374
  get uquadle(): bigint;
4375
4375
  /**
@@ -1942,111 +1942,111 @@ export interface BinaryAliasWriter extends BiBase {
1942
1942
  /**
1943
1943
  * Write 64 bit integer.
1944
1944
  *
1945
- * @param {number} value - value as int
1945
+ * @param {number|bigint} value - value as int
1946
1946
  */
1947
- set int64(value: number);
1947
+ set int64(value: number | bigint);
1948
1948
  /**
1949
1949
  * Write 64 bit integer.
1950
1950
  *
1951
- * @param {number} value - value as int
1951
+ * @param {number|bigint} value - value as int
1952
1952
  */
1953
- set quad(value: number);
1953
+ set quad(value: number | bigint);
1954
1954
  /**
1955
1955
  * Write 64 bit integer.
1956
1956
  *
1957
- * @param {number} value - value as int
1957
+ * @param {number|bigint} value - value as int
1958
1958
  */
1959
- set bigint(value: number);
1959
+ set bigint(value: number | bigint);
1960
1960
  /**
1961
1961
  * Write unsigned 64 bit integer.
1962
1962
  *
1963
- * @param {number} value - value as int
1963
+ * @param {number|bigint} value - value as int
1964
1964
  */
1965
- set uint64(value: number);
1965
+ set uint64(value: number | bigint);
1966
1966
  /**
1967
1967
  * Write unsigned 64 bit integer.
1968
1968
  *
1969
- * @param {number} value - value as int
1969
+ * @param {number|bigint} value - value as int
1970
1970
  */
1971
- set ubigint(value: number);
1971
+ set ubigint(value: number | bigint);
1972
1972
  /**
1973
1973
  * Write unsigned 64 bit integer.
1974
1974
  *
1975
- * @param {number} value - value as int
1975
+ * @param {number|bigint} value - value as int
1976
1976
  */
1977
- set uquad(value: number);
1977
+ set uquad(value: number | bigint);
1978
1978
  /**
1979
1979
  * Write signed 64 bit integer.
1980
1980
  *
1981
- * @param {number} value - value as int
1981
+ * @param {number|bigint} value - value as int
1982
1982
  */
1983
- set int64le(value: number);
1983
+ set int64le(value: number | bigint);
1984
1984
  /**
1985
1985
  * Write signed 64 bit integer.
1986
1986
  *
1987
- * @param {number} value - value as int
1987
+ * @param {number|bigint} value - value as int
1988
1988
  */
1989
- set bigintle(value: number);
1989
+ set bigintle(value: number | bigint);
1990
1990
  /**
1991
1991
  * Write signed 64 bit integer.
1992
1992
  *
1993
- * @param {number} value - value as int
1993
+ * @param {number|bigint} value - value as int
1994
1994
  */
1995
- set quadle(value: number);
1995
+ set quadle(value: number | bigint);
1996
1996
  /**
1997
1997
  * Write unsigned 64 bit integer.
1998
1998
  *
1999
- * @param {number} value - value as int
1999
+ * @param {number|bigint} value - value as int
2000
2000
  */
2001
- set uint64le(value: number);
2001
+ set uint64le(value: number | bigint);
2002
2002
  /**
2003
2003
  * Write unsigned 64 bit integer.
2004
2004
  *
2005
- * @param {number} value - value as int
2005
+ * @param {number|bigint} value - value as int
2006
2006
  */
2007
- set ubigintle(value: number);
2007
+ set ubigintle(value: number | bigint);
2008
2008
  /**
2009
2009
  * Write unsigned 64 bit integer.
2010
2010
  *
2011
- * @param {number} value - value as int
2011
+ * @param {number|bigint} value - value as int
2012
2012
  */
2013
- set uquadle(value: number);
2013
+ set uquadle(value: number | bigint);
2014
2014
  /**
2015
2015
  * Write signed 64 bit integer.
2016
2016
  *
2017
- * @param {number} value - value as int
2017
+ * @param {number|bigint} value - value as int
2018
2018
  */
2019
- set int64be(value: number);
2019
+ set int64be(value: number | bigint);
2020
2020
  /**
2021
2021
  * Write signed 64 bit integer.
2022
2022
  *
2023
- * @param {number} value - value as int
2023
+ * @param {number|bigint} value - value as int
2024
2024
  */
2025
- set bigintbe(value: number);
2025
+ set bigintbe(value: number | bigint);
2026
2026
  /**
2027
2027
  * Write signed 64 bit integer.
2028
2028
  *
2029
- * @param {number} value - value as int
2029
+ * @param {number|bigint} value - value as int
2030
2030
  */
2031
- set quadbe(value: number);
2031
+ set quadbe(value: number | bigint);
2032
2032
  /**
2033
2033
  * Write unsigned 64 bit integer.
2034
2034
  *
2035
- * @param {number} value - value as int
2035
+ * @param {number|bigint} value - value as int
2036
2036
  */
2037
- set uint64be(value: number);
2037
+ set uint64be(value: number | bigint);
2038
2038
  /**
2039
2039
  * Write unsigned 64 bit integer.
2040
2040
  *
2041
- * @param {number} value - value as int
2041
+ * @param {number|bigint} value - value as int
2042
2042
  */
2043
- set ubigintbe(value: number);
2043
+ set ubigintbe(value: number | bigint);
2044
2044
  /**
2045
2045
  * Write unsigned 64 bit integer.
2046
2046
  *
2047
- * @param {number} value - value as int
2047
+ * @param {number|bigint} value - value as int
2048
2048
  */
2049
- set uquadbe(value: number);
2049
+ set uquadbe(value: number | bigint);
2050
2050
  /**
2051
2051
  * Writes double float.
2052
2052
  *
@@ -4264,111 +4264,111 @@ export interface BinaryAliasWriterStreamer extends BiBaseStreamer {
4264
4264
  /**
4265
4265
  * Write 64 bit integer.
4266
4266
  *
4267
- * @param {number} value - value as int
4267
+ * @param {number|bigint} value - value as int
4268
4268
  */
4269
- set int64(value: number);
4269
+ set int64(value: number | bigint);
4270
4270
  /**
4271
4271
  * Write 64 bit integer.
4272
4272
  *
4273
- * @param {number} value - value as int
4273
+ * @param {number|bigint} value - value as int
4274
4274
  */
4275
- set quad(value: number);
4275
+ set quad(value: number | bigint);
4276
4276
  /**
4277
4277
  * Write 64 bit integer.
4278
4278
  *
4279
- * @param {number} value - value as int
4279
+ * @param {number|bigint} value - value as int
4280
4280
  */
4281
- set bigint(value: number);
4281
+ set bigint(value: number | bigint);
4282
4282
  /**
4283
4283
  * Write unsigned 64 bit integer.
4284
4284
  *
4285
- * @param {number} value - value as int
4285
+ * @param {number|bigint} value - value as int
4286
4286
  */
4287
- set uint64(value: number);
4287
+ set uint64(value: number | bigint);
4288
4288
  /**
4289
4289
  * Write unsigned 64 bit integer.
4290
4290
  *
4291
- * @param {number} value - value as int
4291
+ * @param {number|bigint} value - value as int
4292
4292
  */
4293
- set ubigint(value: number);
4293
+ set ubigint(value: number | bigint);
4294
4294
  /**
4295
4295
  * Write unsigned 64 bit integer.
4296
4296
  *
4297
- * @param {number} value - value as int
4297
+ * @param {number|bigint} value - value as int
4298
4298
  */
4299
- set uquad(value: number);
4299
+ set uquad(value: number | bigint);
4300
4300
  /**
4301
4301
  * Write signed 64 bit integer.
4302
4302
  *
4303
- * @param {number} value - value as int
4303
+ * @param {number|bigint} value - value as int
4304
4304
  */
4305
- set int64le(value: number);
4305
+ set int64le(value: number | bigint);
4306
4306
  /**
4307
4307
  * Write signed 64 bit integer.
4308
4308
  *
4309
- * @param {number} value - value as int
4309
+ * @param {number|bigint} value - value as int
4310
4310
  */
4311
- set bigintle(value: number);
4311
+ set bigintle(value: number | bigint);
4312
4312
  /**
4313
4313
  * Write signed 64 bit integer.
4314
4314
  *
4315
- * @param {number} value - value as int
4315
+ * @param {number|bigint} value - value as int
4316
4316
  */
4317
- set quadle(value: number);
4317
+ set quadle(value: number | bigint);
4318
4318
  /**
4319
4319
  * Write unsigned 64 bit integer.
4320
4320
  *
4321
- * @param {number} value - value as int
4321
+ * @param {number|bigint} value - value as int
4322
4322
  */
4323
- set uint64le(value: number);
4323
+ set uint64le(value: number | bigint);
4324
4324
  /**
4325
4325
  * Write unsigned 64 bit integer.
4326
4326
  *
4327
- * @param {number} value - value as int
4327
+ * @param {number|bigint} value - value as int
4328
4328
  */
4329
- set ubigintle(value: number);
4329
+ set ubigintle(value: number | bigint);
4330
4330
  /**
4331
4331
  * Write unsigned 64 bit integer.
4332
4332
  *
4333
- * @param {number} value - value as int
4333
+ * @param {number|bigint} value - value as int
4334
4334
  */
4335
- set uquadle(value: number);
4335
+ set uquadle(value: number | bigint);
4336
4336
  /**
4337
4337
  * Write signed 64 bit integer.
4338
4338
  *
4339
- * @param {number} value - value as int
4339
+ * @param {number|bigint} value - value as int
4340
4340
  */
4341
- set int64be(value: number);
4341
+ set int64be(value: number | bigint);
4342
4342
  /**
4343
4343
  * Write signed 64 bit integer.
4344
4344
  *
4345
- * @param {number} value - value as int
4345
+ * @param {number|bigint} value - value as int
4346
4346
  */
4347
- set bigintbe(value: number);
4347
+ set bigintbe(value: number | bigint);
4348
4348
  /**
4349
4349
  * Write signed 64 bit integer.
4350
4350
  *
4351
- * @param {number} value - value as int
4351
+ * @param {number|bigint} value - value as int
4352
4352
  */
4353
- set quadbe(value: number);
4353
+ set quadbe(value: number | bigint);
4354
4354
  /**
4355
4355
  * Write unsigned 64 bit integer.
4356
4356
  *
4357
- * @param {number} value - value as int
4357
+ * @param {number|bigint} value - value as int
4358
4358
  */
4359
- set uint64be(value: number);
4359
+ set uint64be(value: number | bigint);
4360
4360
  /**
4361
4361
  * Write unsigned 64 bit integer.
4362
4362
  *
4363
- * @param {number} value - value as int
4363
+ * @param {number|bigint} value - value as int
4364
4364
  */
4365
- set ubigintbe(value: number);
4365
+ set ubigintbe(value: number | bigint);
4366
4366
  /**
4367
4367
  * Write unsigned 64 bit integer.
4368
4368
  *
4369
- * @param {number} value - value as int
4369
+ * @param {number|bigint} value - value as int
4370
4370
  */
4371
- set uquadbe(value: number);
4371
+ set uquadbe(value: number | bigint);
4372
4372
  /**
4373
4373
  * Writes double float.
4374
4374
  *
@@ -393,11 +393,11 @@ export declare class BiBase {
393
393
  *
394
394
  * Does not change current read position.
395
395
  *
396
- * @param {number} value - Number to search for.
396
+ * @param {number|bigint} value - Number to search for.
397
397
  * @param {boolean} unsigned - If the number is unsigned (default true)
398
398
  * @param {endian} endian - endianness of value (default set endian).
399
399
  */
400
- findInt64(value: number, unsigned?: boolean, endian?: endian): number;
400
+ findInt64(value: number | bigint, unsigned?: boolean, endian?: endian): number;
401
401
  /**
402
402
  * Searches for half float value position from current read position.
403
403
  *
@@ -1189,76 +1189,76 @@ export declare class BiBase {
1189
1189
  *
1190
1190
  * @param {boolean} unsigned - if value is unsigned or not
1191
1191
  * @param {endian?} endian - ``big`` or ``little``
1192
- * @returns {number}
1192
+ * @returns {bigint}
1193
1193
  */
1194
1194
  readInt64(unsigned?: boolean, endian?: endian): bigint;
1195
1195
  /**
1196
1196
  * Write 64 bit integer.
1197
1197
  *
1198
- * @param {number} value - value as int
1198
+ * @param {number|bigint} value - value as int
1199
1199
  * @param {boolean} unsigned - if the value is unsigned
1200
1200
  * @param {endian} endian - ``big`` or ``little``
1201
1201
  */
1202
- writeInt64(value: number, unsigned?: boolean, endian?: endian): void;
1202
+ writeInt64(value: number | bigint, unsigned?: boolean, endian?: endian): void;
1203
1203
  /**
1204
1204
  * Write unsigned 64 bit integer.
1205
1205
  *
1206
- * @param {number} value - value as int
1206
+ * @param {number|bigint} value - value as int
1207
1207
  * @param {endian} endian - ``big`` or ``little``
1208
1208
  */
1209
- writeUInt64(value: number, endian?: endian): void;
1209
+ writeUInt64(value: number | bigint, endian?: endian): void;
1210
1210
  /**
1211
1211
  * Write signed 64 bit integer.
1212
1212
  *
1213
- * @param {number} value - value as int
1213
+ * @param {number|bigint} value - value as int
1214
1214
  */
1215
- writeInt64LE(value: number): void;
1215
+ writeInt64LE(value: number | bigint): void;
1216
1216
  /**
1217
1217
  * Write unsigned 64 bit integer.
1218
1218
  *
1219
- * @param {number} value - value as int
1219
+ * @param {number|bigint} value - value as int
1220
1220
  */
1221
- writeUInt64LE(value: number): void;
1221
+ writeUInt64LE(value: number | bigint): void;
1222
1222
  /**
1223
1223
  * Write signed 64 bit integer.
1224
1224
  *
1225
- * @param {number} value - value as int
1225
+ * @param {number|bigint} value - value as int
1226
1226
  */
1227
- writeInt64BE(value: number): void;
1227
+ writeInt64BE(value: number | bigint): void;
1228
1228
  /**
1229
1229
  * Write unsigned 64 bit integer.
1230
1230
  *
1231
- * @param {number} value - value as int
1231
+ * @param {number|bigint} value - value as int
1232
1232
  */
1233
- writeUInt64BE(value: number): void;
1233
+ writeUInt64BE(value: number | bigint): void;
1234
1234
  /**
1235
1235
  * Read unsigned 64 bit integer.
1236
1236
  *
1237
- * @returns {number}
1237
+ * @returns {bigint}
1238
1238
  */
1239
1239
  readUInt64(): bigint;
1240
1240
  /**
1241
1241
  * Read signed 64 bit integer.
1242
1242
  *
1243
- * @returns {number}
1243
+ * @returns {bigint}
1244
1244
  */
1245
1245
  readInt64BE(): bigint;
1246
1246
  /**
1247
1247
  * Read unsigned 64 bit integer.
1248
1248
  *
1249
- * @returns {number}
1249
+ * @returns {bigint}
1250
1250
  */
1251
1251
  readUInt64BE(): bigint;
1252
1252
  /**
1253
1253
  * Read signed 64 bit integer.
1254
1254
  *
1255
- * @returns {number}
1255
+ * @returns {bigint}
1256
1256
  */
1257
1257
  readInt64LE(): bigint;
1258
1258
  /**
1259
1259
  * Read unsigned 64 bit integer.
1260
1260
  *
1261
- * @returns {number}
1261
+ * @returns {bigint}
1262
1262
  */
1263
1263
  readUInt64LE(): bigint;
1264
1264
  /**