@pezkuwi/types-codec 16.5.20 → 16.5.21

package/src/extended/Linkage.spec.ts

@@ -1,43 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { Linkage } from '@pezkuwi/types-codec';
-
-const registry = new TypeRegistry();
-
-describe('Linkage', (): void => {
-  it('decodes with ValidatorPrefs', (): void => {
-    const LINKA = { next: '5GznmRvdi5htUJKnMSWJgJUzSJJXSvWuHRSEdyUbHJZDNcwU', previous: null };
-    const PREFS = { commission: '10.00%' };
-
-    // prefs sanity check
-    expect(
-      registry.createType(
-        'ValidatorPrefsWithCommission',
-        '0x0284d717'
-      ).toHuman()
-    ).toEqual(PREFS);
-
-    // linkage sanity checks
-    expect(
-      new Linkage(registry, 'AccountId', '0x0001da30b68f54f686f586ddb29de12b682dd8bd1404566fb8a8db5dec20aa5b6b36').toHuman()
-    ).toEqual(LINKA);
-    expect(
-      registry.createType(
-        'Linkage<AccountId>',
-        '0x0001da30b68f54f686f586ddb29de12b682dd8bd1404566fb8a8db5dec20aa5b6b36'
-      ).toHuman()
-    ).toEqual(LINKA);
-
-    // actual check
-    expect(
-      registry.createType(
-        '(ValidatorPrefsWithCommission, Linkage<AccountId>)',
-        '0x0284d7170001da30b68f54f686f586ddb29de12b682dd8bd1404566fb8a8db5dec20aa5b6b36'
-      ).toHuman()
-    ).toEqual([PREFS, LINKA]);
-  });
-});

package/src/extended/Linkage.ts

@@ -1,81 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-import type { Codec, CodecClass, Registry } from '../types/index.js';
-
-import { Option } from '../base/Option.js';
-import { Tuple } from '../base/Tuple.js';
-import { Vec } from '../base/Vec.js';
-import { Struct } from '../native/Struct.js';
-
-type TypeWithValues = [CodecClass, any[]];
-
-const EMPTY = new Uint8Array();
-
-/**
- * @name Linkage
- * @description The wrapper for the result from a LinkedMap
- */
-export class Linkage<T extends Codec> extends Struct {
-  constructor (registry: Registry, Type: CodecClass | string, value?: unknown) {
-    super(registry, {
-      previous: Option.with(Type),
-      // eslint-disable-next-line sort-keys
-      next: Option.with(Type)
-    }, value as HexString);
-  }
-
-  public static withKey<O extends Codec> (Type: CodecClass | string): CodecClass<Linkage<O>> {
-    return class extends Linkage<O> {
-      constructor (registry: Registry, value?: unknown) {
-        super(registry, Type, value);
-      }
-    };
-  }
-
-  /**
-   * @description Returns the next item the Linkage is pointing to
-   */
-  public get previous (): Option<T> {
-    return this.get('previous') as Option<T>;
-  }
-
-  /**
-   * @description Returns the previous item the Linkage is pointing to
-   */
-  public get next (): Option<T> {
-    return this.get('next') as Option<T>;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public override toRawType (): string {
-    return `Linkage<${this.next.toRawType(true)}>`;
-  }
-
-  /**
-   * @description Custom toU8a which with bare mode does not return the linkage if empty
-   */
-  public override toU8a (isBare?: boolean): Uint8Array {
-    // As part of a storage query (where these appear), in the case of empty, the values
-    // are NOT populated by the node - follow the same logic, leaving it empty
-    return this.isEmpty
-      ? EMPTY
-      : super.toU8a(isBare);
-  }
-}
-
-/**
- * @name LinkageResult
- * @description A Linkage keys/Values tuple
- */
-export class LinkageResult extends Tuple {
-  constructor (registry: Registry, [TypeKey, keys]: TypeWithValues, [TypeValue, values]: TypeWithValues) {
-    super(registry, {
-      Keys: Vec.with(TypeKey),
-      Values: Vec.with(TypeValue)
-    }, [keys, values]);
-  }
-}

package/src/extended/Map.spec.ts

@@ -1,123 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { CodecTo } from '@pezkuwi/types-codec/types';
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { CodecMap, Text, U32 } from '@pezkuwi/types-codec';
-import { stringToU8a } from '@pezkuwi/util';
-
-const registry = new TypeRegistry();
-const mockU32TextMap = new Map<Text, U32>();
-
-mockU32TextMap.set(new Text(registry, 'bazzing'), new U32(registry, 69));
-
-const mockU32TextMapString = '{"bazzing":69}';
-const mockU32TextMapObject = { bazzing: 69 };
-const mockU32TextMapHexString = '0x041c62617a7a696e6745000000';
-const mockU32TextMapUint8Array = Uint8Array.from([4, 28, 98, 97, 122, 122, 105, 110, 103, 69, 0, 0, 0]);
-
-const mockU32U32Map = new Map<U32, U32>();
-
-mockU32U32Map.set(new U32(registry, 1), new U32(registry, 2));
-mockU32U32Map.set(new U32(registry, 23), new U32(registry, 24));
-mockU32U32Map.set(new U32(registry, 28), new U32(registry, 30));
-mockU32U32Map.set(new U32(registry, 45), new U32(registry, 80));
-
-const mockU32U32MapString = '{"1":2,"23":24,"28":30,"45":80}';
-const mockU32U32MapObject = { 1: 2, 23: 24, 28: 30, 45: 80 };
-const mockU32U32MapHexString = '0x10043102000000083233180000000832381e00000008343550000000';
-const mockU32U32MapUint8Array = Uint8Array.from([16, 4, 49, 2, 0, 0, 0, 8, 50, 51, 24, 0, 0, 0, 8, 50, 56, 30, 0, 0, 0, 8, 52, 53, 80, 0, 0, 0]);
-
-describe('CodecMap', (): void => {
-  describe('decoding', (): void => {
-    const testDecode = (type: string, input: unknown, output: string): void =>
-      it(`can decode from ${type}`, (): void => {
-        const s = new CodecMap(registry, Text, U32, input as string);
-
-        expect(s.toString()).toBe(output);
-      });
-
-    testDecode('map', mockU32TextMap, mockU32TextMapString);
-    testDecode('hex', mockU32TextMapHexString, mockU32TextMapString);
-    testDecode('Uint8Array', mockU32TextMapUint8Array, mockU32TextMapString);
-
-    testDecode('map', mockU32U32Map, mockU32U32MapString);
-    testDecode('hex', mockU32U32MapHexString, mockU32U32MapString);
-    testDecode('Uint8Array', mockU32U32MapUint8Array, mockU32U32MapString);
-  });
-
-  describe('encoding', (): void => {
-    const testEncode = (to: CodecTo, expected: any): void =>
-      it(`can encode ${to}`, (): void => {
-        const s = new CodecMap(registry, Text, U32, mockU32TextMap, 'BTreeMap');
-
-        expect(s[to]()).toEqual(expected);
-      });
-
-    testEncode('toHex', mockU32TextMapHexString);
-    testEncode('toJSON', mockU32TextMapObject);
-    testEncode('toU8a', mockU32TextMapUint8Array);
-    testEncode('toString', mockU32TextMapString);
-  });
-
-  describe('encoding multiple values', (): void => {
-    const testEncode = (to: CodecTo, expected: any): void =>
-      it(`can encode ${to}`, (): void => {
-        const s = new CodecMap(registry, Text, U32, mockU32U32Map, 'BTreeMap');
-
-        expect(s[to]()).toEqual(expected);
-      });
-
-    testEncode('toHex', mockU32U32MapHexString);
-    testEncode('toJSON', mockU32U32MapObject);
-    testEncode('toU8a', mockU32U32MapUint8Array);
-    testEncode('toString', mockU32U32MapString);
-  });
-
-  describe('enocodedLength & initialU8aLength', (): void => {
-    it('correctly encodes/decodes empty', (): void => {
-      const none = new CodecMap(registry, Text, Text, new Map([]));
-
-      // only the length byte
-      expect(none.toHex()).toEqual('0x00');
-      expect(none.encodedLength).toEqual(1);
-      expect(
-        new CodecMap(registry, Text, Text, none.toHex()).initialU8aLength
-      ).toEqual(none.encodedLength);
-    });
-
-    it('correctly encodes/decodes filled', (): void => {
-      const some = new CodecMap(registry, Text, Text, new Map([
-        [new Text(registry, '1'), new Text(registry, 'foo')],
-        [new Text(registry, '2'), new Text(registry, 'bar')]
-      ]));
-
-      // length byte + 2 values, 2 << 2 with Text values
-      expect(some.toHex()).toEqual('0x0804310c666f6f04320c626172');
-      expect(some.encodedLength).toEqual(1 + ((1 + 1) * 2) + ((1 + 3) * 2));
-      expect(
-        new CodecMap(registry, Text, Text, some.toHex()).initialU8aLength
-      ).toEqual(some.encodedLength);
-    });
-  });
-
-  it('has a sane inspect', (): void => {
-    expect(
-      new CodecMap(registry, Text, Text, new Map([
-        [new Text(registry, '1'), new Text(registry, 'foo')],
-        [new Text(registry, '2'), new Text(registry, 'bar')]
-      ])).inspect()
-    ).toEqual({
-      inner: [
-        { outer: [new Uint8Array([1 << 2]), stringToU8a('1')] },
-        { outer: [new Uint8Array([3 << 2]), stringToU8a('foo')] },
-        { outer: [new Uint8Array([1 << 2]), stringToU8a('2')] },
-        { outer: [new Uint8Array([3 << 2]), stringToU8a('bar')] }
-      ],
-      outer: [new Uint8Array([2 << 2])]
-    });
-  });
-});

package/src/extended/Map.ts

@@ -1,255 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyJson, Codec, CodecClass, IMap, Inspect, IU8a, Registry } from '../types/index.js';
-
-import { compactFromU8aLim, compactToU8a, isHex, isObject, isU8a, logger, stringify, u8aConcatStrict, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-
-import { AbstractArray } from '../abstract/Array.js';
-import { Enum } from '../base/Enum.js';
-import { Raw } from '../native/Raw.js';
-import { Struct } from '../native/Struct.js';
-import { compareMap, decodeU8a, sortMap, typeToConstructor } from '../utils/index.js';
-
-const l = logger('Map');
-
-/** @internal */
-function decodeMapFromU8a<K extends Codec, V extends Codec> (registry: Registry, KeyClass: CodecClass<K>, ValClass: CodecClass<V>, u8a: Uint8Array): [CodecClass<K>, CodecClass<V>, Map<K, V>, number] {
-  const output = new Map<K, V>();
-  const [offset, count] = compactFromU8aLim(u8a);
-  const types = [];
-
-  for (let i = 0; i < count; i++) {
-    types.push(KeyClass, ValClass);
-  }
-
-  const [values, decodedLength] = decodeU8a(registry, new Array(types.length), u8a.subarray(offset), [types, []]);
-
-  for (let i = 0, count = values.length; i < count; i += 2) {
-    output.set(values[i] as K, values[i + 1] as V);
-  }
-
-  return [KeyClass, ValClass, output, offset + decodedLength];
-}
-
-/** @internal */
-function decodeMapFromMap<K extends Codec, V extends Codec> (registry: Registry, KeyClass: CodecClass<K>, ValClass: CodecClass<V>, value: Map<any, any>): [CodecClass<K>, CodecClass<V>, Map<K, V>, number] {
-  const output = new Map<K, V>();
-
-  for (const [key, val] of value.entries()) {
-    const isComplex = KeyClass.prototype instanceof AbstractArray ||
-      KeyClass.prototype instanceof Struct ||
-      KeyClass.prototype instanceof Enum;
-
-    try {
-      output.set(
-        key instanceof KeyClass
-          ? key
-          : new KeyClass(registry, isComplex && typeof key === 'string' ? JSON.parse(key) : key),
-        val instanceof ValClass
-          ? val
-          : new ValClass(registry, val)
-      );
-    } catch (error) {
-      l.error('Failed to decode key or value:', (error as Error).message);
-
-      throw error;
-    }
-  }
-
-  return [KeyClass, ValClass, output, 0];
-}
-
-/**
- * Decode input to pass into constructor.
- *
- * @param KeyClass - Type of the map key
- * @param ValClass - Type of the map value
- * @param value - Value to decode, one of:
- * - null
- * - undefined
- * - hex
- * - Uint8Array
- * - Map<any, any>, where both key and value types are either
- *   constructors or decodeable values for their types.
- * @param jsonMap
- * @internal
- */
-function decodeMap<K extends Codec, V extends Codec> (registry: Registry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, value?: Uint8Array | string | Map<any, any>): [CodecClass<K>, CodecClass<V>, Map<K, V>, number] {
-  const KeyClass = typeToConstructor(registry, keyType);
-  const ValClass = typeToConstructor(registry, valType);
-
-  if (!value) {
-    return [KeyClass, ValClass, new Map<K, V>(), 0];
-  } else if (isU8a(value) || isHex(value)) {
-    return decodeMapFromU8a<K, V>(registry, KeyClass, ValClass, u8aToU8a(value));
-  } else if (value instanceof Map) {
-    return decodeMapFromMap<K, V>(registry, KeyClass, ValClass, value);
-  } else if (isObject(value)) {
-    return decodeMapFromMap<K, V>(registry, KeyClass, ValClass, new Map(Object.entries(value)));
-  }
-
-  throw new Error('Map: cannot decode type');
-}
-
-export class CodecMap<K extends Codec = Codec, V extends Codec = Codec> extends Map<K, V> implements IMap<K, V> {
-  readonly registry: Registry;
-
-  public createdAtHash?: IU8a;
-  public initialU8aLength?: number;
-  public isStorageFallback?: boolean;
-
-  readonly #KeyClass: CodecClass<K>;
-  readonly #ValClass: CodecClass<V>;
-  readonly #type: string;
-
-  constructor (registry: Registry, keyType: CodecClass<K> | string, valType: CodecClass<V> | string, rawValue: Uint8Array | string | Map<any, any> | undefined, type: 'BTreeMap' | 'HashMap' = 'HashMap') {
-    const [KeyClass, ValClass, decoded, decodedLength] = decodeMap(registry, keyType, valType, rawValue);
-
-    super(type === 'BTreeMap' ? sortMap(decoded) : decoded);
-
-    this.registry = registry;
-    this.initialU8aLength = decodedLength;
-    this.#KeyClass = KeyClass;
-    this.#ValClass = ValClass;
-    this.#type = type;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  public get encodedLength (): number {
-    let len = compactToU8a(this.size).length;
-
-    for (const [k, v] of this.entries()) {
-      len += k.encodedLength + v.encodedLength;
-    }
-
-    return len;
-  }
-
-  /**
-   * @description Returns a hash of the value
-   */
-  public get hash (): IU8a {
-    return this.registry.hash(this.toU8a());
-  }
-
-  /**
-   * @description Checks if the value is an empty value
-   */
-  public get isEmpty (): boolean {
-    return this.size === 0;
-  }
-
-  /**
-   * @description Compares the value of the input to see if there is a match
-   */
-  public eq (other?: unknown): boolean {
-    return compareMap(this, other);
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  public inspect (): Inspect {
-    const inner: Inspect[] = [];
-
-    for (const [k, v] of this.entries()) {
-      inner.push(k.inspect());
-      inner.push(v.inspect());
-    }
-
-    return {
-      inner,
-      outer: [compactToU8a(this.size)]
-    };
-  }
-
-  /**
-   * @description Returns a hex string representation of the value. isLe returns a LE (number-only) representation
-   */
-  public toHex (): HexString {
-    return u8aToHex(this.toU8a());
-  }
-
-  /**
-   * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-   */
-  public toHuman (isExtended?: boolean, disableAscii?: boolean): Record<string, AnyJson> {
-    const json: Record<string, AnyJson> = {};
-
-    for (const [k, v] of this.entries()) {
-      json[
-        k instanceof Raw && !disableAscii && k.isAscii
-          ? k.toUtf8()
-          : k.toString()
-      ] = v.toHuman(isExtended, disableAscii);
-    }
-
-    return json;
-  }
-
-  /**
-   * @description Converts the Object to JSON, typically used for RPC transfers
-   */
-  public toJSON (): Record<string, AnyJson> {
-    const json: Record<string, AnyJson> = {};
-
-    for (const [k, v] of this.entries()) {
-      json[k.toString()] = v.toJSON();
-    }
-
-    return json;
-  }
-
-  /**
-   * @description Converts the value in a best-fit primitive form
-   */
-  public toPrimitive (disableAscii?: boolean): AnyJson {
-    const json: Record<string, AnyJson> = {};
-
-    for (const [k, v] of this.entries()) {
-      json[
-        k instanceof Raw && !disableAscii && k.isAscii
-          ? k.toUtf8()
-          : k.toString()
-      ] = v.toPrimitive(disableAscii);
-    }
-
-    return json;
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public toRawType (): string {
-    return `${this.#type}<${this.registry.getClassName(this.#KeyClass) || new this.#KeyClass(this.registry).toRawType()},${this.registry.getClassName(this.#ValClass) || new this.#ValClass(this.registry).toRawType()}>`;
-  }
-
-  /**
-   * @description Returns the string representation of the value
-   */
-  public override toString (): string {
-    return stringify(this.toJSON());
-  }
-
-  /**
-   * @description Encodes the value as a Uint8Array as per the SCALE specifications
-   * @param isBare true when the value has none of the type-specific prefixes (internal)
-   */
-  public toU8a (isBare?: boolean): Uint8Array {
-    const encoded: Uint8Array[] = [];
-
-    if (!isBare) {
-      encoded.push(compactToU8a(this.size));
-    }
-
-    for (const [k, v] of this.entries()) {
-      encoded.push(k.toU8a(isBare), v.toU8a(isBare));
-    }
-
-    return u8aConcatStrict(encoded);
-  }
-}

package/src/extended/OptionBool.spec.ts

@@ -1,49 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { OptionBool } from '@pezkuwi/types-codec';
-
-describe('OptionBool', (): void => {
-  const registry = new TypeRegistry();
-
-  describe('decodes', (): void => {
-    it('decodes none', (): void => {
-      expect(new OptionBool(registry).toJSON()).toEqual(null);
-    });
-
-    it('decodes true', (): void => {
-      expect(new OptionBool(registry, true).toJSON()).toEqual(true);
-    });
-
-    it('decodes false', (): void => {
-      expect(new OptionBool(registry, false).toJSON()).toEqual(false);
-    });
-  });
-
-  describe('encodes', (): void => {
-    it('encodes none', (): void => {
-      expect(new OptionBool(registry).toU8a()).toEqual(new Uint8Array([0]));
-    });
-
-    it('encodes true', (): void => {
-      expect(new OptionBool(registry, true).toU8a()).toEqual(new Uint8Array([1]));
-    });
-
-    it('encodes false', (): void => {
-      expect(new OptionBool(registry, false).toU8a()).toEqual(new Uint8Array([2]));
-    });
-  });
-
-  it('has a sane toRawType representation', (): void => {
-    expect(new OptionBool(registry).toRawType()).toEqual('Option<bool>');
-  });
-
-  it('has a sane inspect', (): void => {
-    expect(new OptionBool(registry, true).inspect()).toEqual({
-      outer: [new Uint8Array([1])]
-    });
-  });
-});

package/src/extended/OptionBool.ts

@@ -1,93 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyBool, Inspect, Registry } from '../types/index.js';
-
-import { isHex, isU8a, u8aToU8a } from '@pezkuwi/util';
-
-import { Option } from '../base/Option.js';
-import { bool as Bool } from '../native/Bool.js';
-
-function decodeU8a (registry: Registry, value: Uint8Array): null | Bool {
-  // Encoded as -
-  //  - 0 = None
-  //  - 1 = True
-  //  - 2 = False
-  return value[0] === 0
-    ? null
-    : new Bool(registry, value[0] === 1);
-}
-
-/**
- * @name OptionBool
- * @description A specific implementation of Option<bool> than allows for single-byte encoding
- */
-export class OptionBool extends Option<Bool> {
-  constructor (registry: Registry, value?: Option<Bool> | AnyBool | Uint8Array | HexString | null) {
-    super(
-      registry,
-      Bool,
-      isU8a(value) || isHex(value)
-        ? decodeU8a(registry, u8aToU8a(value))
-        : value
-    );
-
-    this.initialU8aLength = 1;
-  }
-
-  /**
-   * @description The length of the value when encoded as a Uint8Array
-   */
-  public override get encodedLength (): number {
-    return 1 | 0;
-  }
-
-  /**
-   * @description Checks if the value is an empty value (always false)
-   */
-  public get isFalse (): boolean {
-    return this.isSome
-      ? !this.value.valueOf()
-      : false;
-  }
-
-  /**
-   * @description Checks if the value is an empty value (always false)
-   */
-  public get isTrue (): boolean {
-    return this.isSome
-      ? this.value.valueOf()
-      : false;
-  }
-
-  /**
-   * @description Returns a breakdown of the hex encoding for this Codec
-   */
-  public override inspect (): Inspect {
-    return { outer: [this.toU8a()] };
-  }
-
-  /**
-   * @description Returns the base runtime type name for this instance
-   */
-  public override toRawType (isBare?: boolean): string {
-    return isBare
-      ? 'bool'
-      : 'Option<bool>';
-  }
-
-  /**
-   * @description Encodes the value as a Uint8Array as per the SCALE specifications
-   * @param isBare true when the value has none of the type-specific prefixes (internal)
-   */
-  public override toU8a (isBare?: boolean): Uint8Array {
-    if (isBare) {
-      return super.toU8a(true);
-    }
-
-    return this.isSome
-      ? new Uint8Array([this.isTrue ? 1 : 2])
-      : new Uint8Array([0]);
-  }
-}

package/src/extended/Range.spec.ts

@@ -1,37 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TypeRegistry } from '@pezkuwi/types';
-import { Range, U32 } from '@pezkuwi/types-codec';
-
-describe('Range', (): void => {
-  const registry = new TypeRegistry();
-  let range: Range<U32>;
-
-  beforeEach((): void => {
-    range = new (Range.with(U32))(registry, [1, 2]);
-  });
-
-  it('decodes', (): void => {
-    expect(range.toJSON()).toEqual([1, 2]);
-  });
-
-  it('encodes', (): void => {
-    expect(range.toU8a()).toEqual(new Uint8Array([1, 0, 0, 0, 2, 0, 0, 0]));
-  });
-
-  it('has a sane toRawType representation', (): void => {
-    expect(range.toRawType()).toEqual('Range<u32>');
-  });
-
-  it('has a sane inspect', (): void => {
-    expect(range.inspect()).toEqual({
-      inner: [
-        { outer: [new Uint8Array([1, 0, 0, 0])] },
-        { outer: [new Uint8Array([2, 0, 0, 0])] }
-      ]
-    });
-  });
-});