bireader 3.1.2 → 3.1.4

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.
@@ -1,5 +1,5 @@
1
1
  /// <reference types="node" />
2
- import { BiOptions, endian, stringOptions } from "./common.js";
2
+ import { BigValue, BiOptions, endian, stringOptions } from "./common.js";
3
3
  import { BiBase } from './core/BiBase.js';
4
4
  import { BinaryAliasWriter } from "./aliases/BinaryAliasWriter.js";
5
5
  declare const BiWriterBase: typeof BiBase;
@@ -283,24 +283,24 @@ export declare class BiWriter extends BiWriterBase implements BinaryAliasWriter
283
283
  set float(value: number);
284
284
  set floatle(value: number);
285
285
  set floatbe(value: number);
286
- set int64(value: number);
287
- set quad(value: number);
288
- set bigint(value: number);
289
- set uint64(value: number);
290
- set ubigint(value: number);
291
- set uquad(value: number);
292
- set int64le(value: number);
293
- set bigintle(value: number);
294
- set quadle(value: number);
295
- set uint64le(value: number);
296
- set ubigintle(value: number);
297
- set uquadle(value: number);
298
- set int64be(value: number);
299
- set bigintbe(value: number);
300
- set quadbe(value: number);
301
- set uint64be(value: number);
302
- set ubigintbe(value: number);
303
- set uquadbe(value: number);
286
+ set int64(value: BigValue);
287
+ set quad(value: BigValue);
288
+ set bigint(value: BigValue);
289
+ set uint64(value: BigValue);
290
+ set ubigint(value: BigValue);
291
+ set uquad(value: BigValue);
292
+ set int64le(value: BigValue);
293
+ set bigintle(value: BigValue);
294
+ set quadle(value: BigValue);
295
+ set uint64le(value: BigValue);
296
+ set ubigintle(value: BigValue);
297
+ set uquadle(value: BigValue);
298
+ set int64be(value: BigValue);
299
+ set bigintbe(value: BigValue);
300
+ set quadbe(value: BigValue);
301
+ set uint64be(value: BigValue);
302
+ set ubigintbe(value: BigValue);
303
+ set uquadbe(value: BigValue);
304
304
  set doublefloat(value: number);
305
305
  set dfloat(value: number);
306
306
  set dfloatbe(value: number);
@@ -1,4 +1,4 @@
1
- import { BiOptions, endian, stringOptions } from "./common.js";
1
+ import { BigValue, BiOptions, endian, stringOptions } from "./common.js";
2
2
  import { BiBaseStreamer } from './core/BiBaseStream.js';
3
3
  import { BinaryAliasWriterStreamer } from "./aliases/BinaryAliasWriter.js";
4
4
  declare const BiWriterStreamer: typeof BiBaseStreamer;
@@ -286,24 +286,24 @@ export declare class BiWriterStream extends BiWriterStreamer implements BinaryAl
286
286
  set float(value: number);
287
287
  set floatle(value: number);
288
288
  set floatbe(value: number);
289
- set int64(value: number);
290
- set quad(value: number);
291
- set bigint(value: number);
292
- set uint64(value: number);
293
- set ubigint(value: number);
294
- set uquad(value: number);
295
- set int64le(value: number);
296
- set bigintle(value: number);
297
- set quadle(value: number);
298
- set uint64le(value: number);
299
- set ubigintle(value: number);
300
- set uquadle(value: number);
301
- set int64be(value: number);
302
- set bigintbe(value: number);
303
- set quadbe(value: number);
304
- set uint64be(value: number);
305
- set ubigintbe(value: number);
306
- set uquadbe(value: number);
289
+ set int64(value: BigValue);
290
+ set quad(value: BigValue);
291
+ set bigint(value: BigValue);
292
+ set uint64(value: BigValue);
293
+ set ubigint(value: BigValue);
294
+ set uquad(value: BigValue);
295
+ set int64le(value: BigValue);
296
+ set bigintle(value: BigValue);
297
+ set quadle(value: BigValue);
298
+ set uint64le(value: BigValue);
299
+ set ubigintle(value: BigValue);
300
+ set uquadle(value: BigValue);
301
+ set int64be(value: BigValue);
302
+ set bigintbe(value: BigValue);
303
+ set quadbe(value: BigValue);
304
+ set uint64be(value: BigValue);
305
+ set ubigintbe(value: BigValue);
306
+ set uquadbe(value: BigValue);
307
307
  set doublefloat(value: number);
308
308
  set dfloat(value: number);
309
309
  set dfloatbe(value: number);
@@ -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
  *
package/dist/common.d.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  /// <reference types="node" />
2
2
  export type endian = "little" | "big";
3
+ export type BigValue = number | bigint;
3
4
  export type BiOptions = {
4
5
  /**
5
6
  * Byte offset to start writer, default is 0