cborg 2.0.5 → 3.0.0-alpha.1

package/esm/browser-test/test-json.js

@@ -1,279 +0,0 @@
-import { assert } from 'chai';
-import {
-  decode,
-  encode
-} from '../lib/json/json.js';
-const toBytes = str => new TextEncoder().encode(str);
-function verifyRoundTrip(obj, sorting) {
-  const encoded = new TextDecoder().decode(encode(obj, sorting === false ? { mapSorter: null } : undefined));
-  const json = JSON.stringify(obj);
-  assert.strictEqual(encoded, json);
-  const decoded = decode(toBytes(JSON.stringify(obj)));
-  assert.deepStrictEqual(decoded, obj);
-}
-function verifyEncodedForm(testCase) {
-  const obj = JSON.parse(testCase);
-  const encoded = encode(obj);
-  assert.strictEqual(new TextDecoder().decode(encoded), JSON.stringify(obj));
-  const decoded = decode(encoded);
-  assert.deepStrictEqual(decoded, obj);
-  const decoded2 = decode(toBytes(testCase));
-  assert.deepStrictEqual(decoded2, obj);
-}
-describe('json basics', () => {
-  it('can round-trip basic literals', () => {
-    const testCases = [
-      'null',
-      'true',
-      'false',
-      '0',
-      '9007199254740991',
-      '-9007199254740991',
-      JSON.stringify(Number.MAX_VALUE),
-      JSON.stringify(Number.MIN_VALUE)
-    ];
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase);
-    }
-    assert.strictEqual(decode(toBytes('1E1')), 10);
-    assert.strictEqual(decode(toBytes('0.1e1')), 1);
-    assert.strictEqual(decode(toBytes('1e-1')), 0.1);
-    assert.strictEqual(decode(toBytes('1e+00')), 1);
-    assert.strictEqual(decode(toBytes('10.0')), 10);
-    assert.deepStrictEqual(decode(toBytes('[-10.0,1.0,0.0,100.0]')), [
-      -10,
-      1,
-      0,
-      100
-    ]);
-    verifyRoundTrip(true);
-    verifyRoundTrip(false);
-    verifyRoundTrip(null);
-    verifyRoundTrip(100);
-    verifyRoundTrip(-100);
-    verifyRoundTrip(1.11);
-    verifyRoundTrip(-100.11111);
-    verifyRoundTrip(11100000000);
-    verifyRoundTrip(1.0011111e-18);
-  });
-  it('handles large integers as BigInt', () => {
-    const verify = (inp, str) => {
-      if (str === undefined) {
-        str = String(inp);
-      }
-      assert.strictEqual(decode(toBytes(str), { allowBigInt: true }), inp);
-      assert.strictEqual(decode(toBytes(str)), parseFloat(str));
-    };
-    verify(Number.MAX_SAFE_INTEGER);
-    verify(-Number.MAX_SAFE_INTEGER);
-    verify(BigInt('9007199254740992'));
-    verify(BigInt('9007199254740993'));
-    verify(BigInt('11959030306112471731'));
-    verify(BigInt('18446744073709551615'));
-    verify(BigInt('9223372036854775807'));
-    verify(BigInt('-9007199254740992'));
-    verify(BigInt('-9007199254740993'));
-    verify(BigInt('-9223372036854776000'));
-    verify(BigInt('-11959030306112471732'));
-    verify(BigInt('-18446744073709551616'));
-    verify(-9007199254740992, '-9007199254740992.0');
-    verify(-9223372036854776000, '-9223372036854776000.0');
-    verify(-18446744073709552000, '-18446744073709551616.0');
-  });
-  it('can round-trip string literals', () => {
-    const testCases = [
-      JSON.stringify(''),
-      JSON.stringify(' '),
-      JSON.stringify('"'),
-      JSON.stringify('\\'),
-      JSON.stringify('\b\f\n\r\t'),
-      JSON.stringify('"'),
-      JSON.stringify('" %22 0x22 034 "'),
-      '"\uD83D\uDE00"'
-    ];
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase);
-    }
-    assert.strictEqual(decode(toBytes('"/ & \\/"')), '/ & /');
-    verifyRoundTrip('this is a string');
-    verifyRoundTrip('this \uD834\uDD1E is a \u263A\u263A \u2663 string ̐ ̀\n\r');
-    verifyRoundTrip('');
-    verifyRoundTrip('foo\\bar\nbaz\tbop\rbing"bip\'bang');
-  });
-  it('can round-trip array literals', () => {
-    const testCases = [
-      '[]',
-      '[null]',
-      '[true, false]',
-      '[ \n 0,1, 2\n ,  3,\n4] \n ',
-      '[-10.0, 1.0, 0.0, 100.0]',
-      '[["2 deep"]]'
-    ];
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase);
-    }
-    verifyRoundTrip([
-      1,
-      2,
-      3,
-      'string',
-      true,
-      4
-    ]);
-    verifyRoundTrip([
-      1,
-      2,
-      3,
-      'string',
-      true,
-      [
-        'and',
-        'a',
-        'nested',
-        'array',
-        true
-      ],
-      4
-    ]);
-  });
-  it('can round-trip object literals', () => {
-    const testCases = [
-      '{}',
-      '\n {\n "\\b"\n :\n""\n }\n ',
-      '{"":""}',
-      '{"1":{"2":0,"3":"deep"}}'
-    ];
-    for (const testCase of testCases) {
-      verifyEncodedForm(testCase);
-    }
-  });
-  it('will sort map keys', () => {
-    const unsorted = {
-      one: 1,
-      two: 2,
-      three: 3.1,
-      str: 'string',
-      bool: true,
-      four: 4
-    };
-    verifyRoundTrip(unsorted, false);
-    assert.strictEqual(new TextDecoder().decode(encode(unsorted)), '{"bool":true,"four":4,"one":1,"str":"string","three":3.1,"two":2}');
-  });
-  it('can handle novel cases', () => {
-    assert.strictEqual(decode(toBytes('"this \\uD834\\uDD1E is a \\u263a\\u263a string"')), 'this \uD834\uDD1E is a \u263A\u263A string');
-    verifyRoundTrip({
-      one: 1,
-      two: 2,
-      three: 3.1,
-      str: 'string',
-      arr: [
-        'and',
-        'a',
-        'nested',
-        [],
-        'array',
-        [
-          true,
-          1
-        ],
-        false
-      ],
-      bool: true,
-      obj: {
-        nested: 'object',
-        a: [],
-        o: {}
-      },
-      four: 4
-    }, false);
-    verifyRoundTrip([
-      false,
-      [
-        {
-          '#nFzU': {},
-          '\\w>': -0.9441451951197325,
-          '\t\'': '\'JB+2Wg\tw"IrM*#e^L/d&4rrzUuwq(1mH6aVRredB&Bfs]S"KqK(Tz1Q"URBAfw',
-          '\n@FrfM': 'M[D]q&'
-        },
-        'J4>\'Xdc+u2$%',
-        4227406737130333
-      ]
-    ], false);
-    verifyRoundTrip([
-      0.12995619865708727,
-      -4973404279772543,
-      {
-        drG2: [true],
-        ';#K^Qf>V': null,
-        '`2=': 'ecc<e/$+-.;U>Gr5RdZDJ\n5+:{=QHNN.tVVN~dX$FWFwu`6>"&=tW!*1*^\u263A)JFM1p|}&X.B|${*\\f@!w2\u263A+'
-      }
-    ], false);
-    assert.strictEqual(`${ decode(encode(9007199254740991)) }`, '9007199254740991');
-    assert.strictEqual(`${ decode(encode(9007199254740992)) }`, '9007199254740992');
-    assert.strictEqual(`${ decode(encode(900719925474099100n)) }`, '900719925474099100');
-  });
-  it('should throw on bad types', () => {
-    assert.throws(() => encode(new Uint8Array([
-      1,
-      2
-    ])), /CBOR encode error: unsupported type: Uint8Array/);
-    assert.throws(() => encode({
-      boop: new Uint8Array([
-        1,
-        2
-      ])
-    }), /CBOR encode error: unsupported type: Uint8Array/);
-    assert.throws(() => encode(undefined), /CBOR encode error: unsupported type: undefined/);
-    assert.throws(() => encode(new Map([
-      [
-        1,
-        2
-      ],
-      [
-        2,
-        3
-      ]
-    ])), /CBOR encode error: non-string map keys are not supported/);
-    assert.throws(() => encode(new Map([
-      [
-        [
-          'foo',
-          'bar'
-        ],
-        2
-      ],
-      [
-        [
-          'bar',
-          'foo'
-        ],
-        3
-      ]
-    ])), /CBOR encode error: complex map keys are not supported/);
-  });
-  it('should throw on bad decode failure modes', () => {
-    assert.throws(() => decode(toBytes('{"a":1 & "b":2}')), 'CBOR decode error: unexpected character at position 7, was expecting object delimiter but found \'&\'');
-    assert.throws(() => decode(toBytes('{"a":1,"b"!2}')), 'CBOR decode error: unexpected character at position 10, was expecting key/value delimiter \':\' but found \'!\'');
-    assert.throws(() => decode(toBytes('[1,2&3]')), 'CBOR decode error: unexpected character at position 4, was expecting array delimiter but found \'&\'');
-    assert.throws(() => decode(toBytes('{"a":!}')), 'CBOR decode error: unexpected character at position 5');
-    assert.throws(() => decode(toBytes('"abc')), 'CBOR decode error: unexpected end of string at position 4');
-    assert.throws(() => decode(toBytes('"ab\\xc"')), 'CBOR decode error: unexpected string escape character at position 5');
-    assert.throws(() => decode(toBytes('"ab\x1Ec"')), 'CBOR decode error: invalid control character at position 3');
-    assert.throws(() => decode(toBytes('"ab\\')), 'CBOR decode error: unexpected string termination at position 4');
-    assert.throws(() => decode(toBytes('"\u263A').subarray(0, 3)), 'CBOR decode error: unexpected unicode sequence at position 1');
-    assert.throws(() => decode(toBytes('"\\uxyza"')), 'CBOR decode error: unexpected unicode escape character at position 3');
-    assert.throws(() => decode(toBytes('"\\u11"')), 'CBOR decode error: unexpected end of unicode escape sequence at position 3');
-    assert.throws(() => decode(toBytes('-boop')), 'CBOR decode error: unexpected token at position 1');
-    assert.throws(() => decode(toBytes('{"v":nope}')), 'CBOR decode error: unexpected token at position 7, expected to find \'null\'');
-    assert.throws(() => decode(toBytes('[n]')), 'CBOR decode error: unexpected end of input at position 1');
-    assert.throws(() => decode(toBytes('{"v":truu}')), 'CBOR decode error: unexpected token at position 9, expected to find \'true\'');
-    assert.throws(() => decode(toBytes('[tr]')), 'CBOR decode error: unexpected end of input at position 1');
-    assert.throws(() => decode(toBytes('{"v":flase}')), 'CBOR decode error: unexpected token at position 7, expected to find \'false\'');
-    assert.throws(() => decode(toBytes('[fa]')), 'CBOR decode error: unexpected end of input at position 1');
-    assert.throws(() => decode(toBytes('-0..1')), 'CBOR decode error: unexpected token at position 3');
-  });
-  it('should throw when rejectDuplicateMapKeys enabled on duplicate keys', () => {
-    assert.deepStrictEqual(decode(toBytes('{"foo":1,"foo":2}')), { foo: 2 });
-    assert.throws(() => decode(toBytes('{"foo":1,"foo":2}'), { rejectDuplicateMapKeys: true }), /CBOR decode error: found repeat map key "foo"/);
-  });
-});

package/esm/browser-test/test-length.js

@@ -1,55 +0,0 @@
-import chai from 'chai';
-import { garbage } from 'ipld-garbage';
-import { uintBoundaries } from '../lib/0uint.js';
-import { encode } from '../cborg.js';
-import { encodedLength } from '../lib/length.js';
-import { dateEncoder } from './common.js';
-const {assert} = chai;
-function verifyLength(object, options) {
-  const len = encodedLength(object, options);
-  const encoded = encode(object, options);
-  const actual = encoded.length;
-  assert.strictEqual(actual, len, JSON.stringify(object));
-}
-describe('encodedLength', () => {
-  it('int boundaries', () => {
-    for (let ii = 0; ii < 4; ii++) {
-      verifyLength(uintBoundaries[ii]);
-      verifyLength(uintBoundaries[ii] - 1);
-      verifyLength(uintBoundaries[ii] + 1);
-      verifyLength(-1 * uintBoundaries[ii]);
-      verifyLength(-1 * uintBoundaries[ii] - 1);
-      verifyLength(-1 * uintBoundaries[ii] + 1);
-    }
-  });
-  it('tags', () => {
-    verifyLength({ date: new Date('2013-03-21T20:04:00Z') }, { typeEncoders: { Date: dateEncoder } });
-  });
-  it('floats', () => {
-    verifyLength(0.5);
-    verifyLength(0.5, { float64: true });
-    verifyLength(8.940696716308594e-8);
-    verifyLength(8.940696716308594e-8, { float64: true });
-  });
-  it('small garbage', function () {
-    this.timeout(10000);
-    for (let ii = 0; ii < 1000; ii++) {
-      const gbg = garbage(1 << 6, { weights: { CID: 0 } });
-      verifyLength(gbg);
-    }
-  });
-  it('medium garbage', function () {
-    this.timeout(10000);
-    for (let ii = 0; ii < 100; ii++) {
-      const gbg = garbage(1 << 16, { weights: { CID: 0 } });
-      verifyLength(gbg);
-    }
-  });
-  it('large garbage', function () {
-    this.timeout(10000);
-    for (let ii = 0; ii < 10; ii++) {
-      const gbg = garbage(1 << 20, { weights: { CID: 0 } });
-      verifyLength(gbg);
-    }
-  });
-});

package/esm/cborg.js

@@ -1,12 +0,0 @@
-import { encode } from './lib/encode.js';
-import { decode } from './lib/decode.js';
-import {
-  Token,
-  Type
-} from './lib/token.js';
-export {
-  decode,
-  encode,
-  Token,
-  Type
-};

package/esm/lib/0uint.js

@@ -1,152 +0,0 @@
-import {
-  Token,
-  Type
-} from './token.js';
-import {
-  decodeErrPrefix,
-  assertEnoughData
-} from './common.js';
-export const uintBoundaries = [
-  24,
-  256,
-  65536,
-  4294967296,
-  BigInt('18446744073709551616')
-];
-export function readUint8(data, offset, options) {
-  assertEnoughData(data, offset, 1);
-  const value = data[offset];
-  if (options.strict === true && value < uintBoundaries[0]) {
-    throw new Error(`${ decodeErrPrefix } integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-export function readUint16(data, offset, options) {
-  assertEnoughData(data, offset, 2);
-  const value = data[offset] << 8 | data[offset + 1];
-  if (options.strict === true && value < uintBoundaries[1]) {
-    throw new Error(`${ decodeErrPrefix } integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-export function readUint32(data, offset, options) {
-  assertEnoughData(data, offset, 4);
-  const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  if (options.strict === true && value < uintBoundaries[2]) {
-    throw new Error(`${ decodeErrPrefix } integer encoded in more bytes than necessary (strict decode)`);
-  }
-  return value;
-}
-export function readUint64(data, offset, options) {
-  assertEnoughData(data, offset, 8);
-  const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-  const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
-  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
-  if (options.strict === true && value < uintBoundaries[3]) {
-    throw new Error(`${ decodeErrPrefix } integer encoded in more bytes than necessary (strict decode)`);
-  }
-  if (value <= Number.MAX_SAFE_INTEGER) {
-    return Number(value);
-  }
-  if (options.allowBigInt === true) {
-    return value;
-  }
-  throw new Error(`${ decodeErrPrefix } integers outside of the safe integer range are not supported`);
-}
-export function decodeUint8(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
-}
-export function decodeUint16(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
-}
-export function decodeUint32(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
-}
-export function decodeUint64(data, pos, _minor, options) {
-  return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
-}
-export function encodeUint(buf, token) {
-  return encodeUintValue(buf, 0, token.value);
-}
-export function encodeUintValue(buf, major, uint) {
-  if (uint < uintBoundaries[0]) {
-    const nuint = Number(uint);
-    buf.push([major | nuint]);
-  } else if (uint < uintBoundaries[1]) {
-    const nuint = Number(uint);
-    buf.push([
-      major | 24,
-      nuint
-    ]);
-  } else if (uint < uintBoundaries[2]) {
-    const nuint = Number(uint);
-    buf.push([
-      major | 25,
-      nuint >>> 8,
-      nuint & 255
-    ]);
-  } else if (uint < uintBoundaries[3]) {
-    const nuint = Number(uint);
-    buf.push([
-      major | 26,
-      nuint >>> 24 & 255,
-      nuint >>> 16 & 255,
-      nuint >>> 8 & 255,
-      nuint & 255
-    ]);
-  } else {
-    const buint = BigInt(uint);
-    if (buint < uintBoundaries[4]) {
-      const set = [
-        major | 27,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0
-      ];
-      let lo = Number(buint & BigInt(4294967295));
-      let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-      set[8] = lo & 255;
-      lo = lo >> 8;
-      set[7] = lo & 255;
-      lo = lo >> 8;
-      set[6] = lo & 255;
-      lo = lo >> 8;
-      set[5] = lo & 255;
-      set[4] = hi & 255;
-      hi = hi >> 8;
-      set[3] = hi & 255;
-      hi = hi >> 8;
-      set[2] = hi & 255;
-      hi = hi >> 8;
-      set[1] = hi & 255;
-      buf.push(set);
-    } else {
-      throw new Error(`${ decodeErrPrefix } encountered BigInt larger than allowable range`);
-    }
-  }
-}
-encodeUint.encodedSize = function encodedSize(token) {
-  return encodeUintValue.encodedSize(token.value);
-};
-encodeUintValue.encodedSize = function encodedSize(uint) {
-  if (uint < uintBoundaries[0]) {
-    return 1;
-  }
-  if (uint < uintBoundaries[1]) {
-    return 2;
-  }
-  if (uint < uintBoundaries[2]) {
-    return 3;
-  }
-  if (uint < uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
-};

package/esm/lib/1negint.js

@@ -1,55 +0,0 @@
-import {
-  Token,
-  Type
-} from './token.js';
-import * as uint from './0uint.js';
-import { decodeErrPrefix } from './common.js';
-export function decodeNegint8(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint8(data, pos + 1, options), 2);
-}
-export function decodeNegint16(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint16(data, pos + 1, options), 3);
-}
-export function decodeNegint32(data, pos, _minor, options) {
-  return new Token(Type.negint, -1 - uint.readUint32(data, pos + 1, options), 5);
-}
-const neg1b = BigInt(-1);
-const pos1b = BigInt(1);
-export function decodeNegint64(data, pos, _minor, options) {
-  const int = uint.readUint64(data, pos + 1, options);
-  if (typeof int !== 'bigint') {
-    const value = -1 - int;
-    if (value >= Number.MIN_SAFE_INTEGER) {
-      return new Token(Type.negint, value, 9);
-    }
-  }
-  if (options.allowBigInt !== true) {
-    throw new Error(`${ decodeErrPrefix } integers outside of the safe integer range are not supported`);
-  }
-  return new Token(Type.negint, neg1b - BigInt(int), 9);
-}
-export function encodeNegint(buf, token) {
-  const negint = token.value;
-  const unsigned = typeof negint === 'bigint' ? negint * neg1b - pos1b : negint * -1 - 1;
-  uint.encodeUintValue(buf, token.type.majorEncoded, unsigned);
-}
-encodeNegint.encodedSize = function encodedSize(token) {
-  const negint = token.value;
-  const unsigned = typeof negint === 'bigint' ? negint * neg1b - pos1b : negint * -1 - 1;
-  if (unsigned < uint.uintBoundaries[0]) {
-    return 1;
-  }
-  if (unsigned < uint.uintBoundaries[1]) {
-    return 2;
-  }
-  if (unsigned < uint.uintBoundaries[2]) {
-    return 3;
-  }
-  if (unsigned < uint.uintBoundaries[3]) {
-    return 5;
-  }
-  return 9;
-};
-encodeNegint.compareTokens = function compareTokens(tok1, tok2) {
-  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
-};

package/esm/lib/2bytes.js

@@ -1,59 +0,0 @@
-import {
-  Token,
-  Type
-} from './token.js';
-import {
-  assertEnoughData,
-  decodeErrPrefix
-} from './common.js';
-import * as uint from './0uint.js';
-import {
-  compare,
-  fromString,
-  slice
-} from './byte-utils.js';
-function toToken(data, pos, prefix, length) {
-  assertEnoughData(data, pos, prefix + length);
-  const buf = slice(data, pos + prefix, pos + prefix + length);
-  return new Token(Type.bytes, buf, prefix + length);
-}
-export function decodeBytesCompact(data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor);
-}
-export function decodeBytes8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options));
-}
-export function decodeBytes16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options));
-}
-export function decodeBytes32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options));
-}
-export function decodeBytes64(data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options);
-  if (typeof l === 'bigint') {
-    throw new Error(`${ decodeErrPrefix } 64-bit integer bytes lengths not supported`);
-  }
-  return toToken(data, pos, 9, l);
-}
-function tokenBytes(token) {
-  if (token.encodedBytes === undefined) {
-    token.encodedBytes = token.type === Type.string ? fromString(token.value) : token.value;
-  }
-  return token.encodedBytes;
-}
-export function encodeBytes(buf, token) {
-  const bytes = tokenBytes(token);
-  uint.encodeUintValue(buf, token.type.majorEncoded, bytes.length);
-  buf.push(bytes);
-}
-encodeBytes.encodedSize = function encodedSize(token) {
-  const bytes = tokenBytes(token);
-  return uint.encodeUintValue.encodedSize(bytes.length) + bytes.length;
-};
-encodeBytes.compareTokens = function compareTokens(tok1, tok2) {
-  return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
-};
-export function compareBytes(b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
-}

package/esm/lib/3string.js

@@ -1,43 +0,0 @@
-import {
-  Token,
-  Type
-} from './token.js';
-import {
-  assertEnoughData,
-  decodeErrPrefix
-} from './common.js';
-import * as uint from './0uint.js';
-import { encodeBytes } from './2bytes.js';
-import {
-  toString,
-  slice
-} from './byte-utils.js';
-function toToken(data, pos, prefix, length, options) {
-  const totLength = prefix + length;
-  assertEnoughData(data, pos, totLength);
-  const tok = new Token(Type.string, toString(data, pos + prefix, pos + totLength), totLength);
-  if (options.retainStringBytes === true) {
-    tok.byteValue = slice(data, pos + prefix, pos + totLength);
-  }
-  return tok;
-}
-export function decodeStringCompact(data, pos, minor, options) {
-  return toToken(data, pos, 1, minor, options);
-}
-export function decodeString8(data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options), options);
-}
-export function decodeString16(data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options), options);
-}
-export function decodeString32(data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options), options);
-}
-export function decodeString64(data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options);
-  if (typeof l === 'bigint') {
-    throw new Error(`${ decodeErrPrefix } 64-bit integer string lengths not supported`);
-  }
-  return toToken(data, pos, 9, l, options);
-}
-export const encodeString = encodeBytes;