@cloudpss/ubjson 0.5.55 → 0.6.0-alpha.10

package/src/helper/string-encoder.ts

@@ -114,12 +114,32 @@ export function nativeEncodeInto(v: string, buf: Uint8Array, offset: number): nu
     const encoded = TEXT_ENCODER!.encodeInto(v, buf.subarray(offset));
     return encoded.written;
 }
+
+/** Undocumented */
+type BufferUndocumented = Buffer & {
+    utf8Write: (this: Uint8Array, v: string, offset: number, byteLength: number) => number;
+};
+let utf8Write: ((this: Uint8Array, v: string, offset: number, byteLength: number) => number) | null;
+/**
+ * Encode string into utf-8.
+ * Provided `buf` MUST have enough space.
+ */
+export function nodeEncodeInto(v: string, buf: Uint8Array, offset: number): number {
+    const encoded = utf8Write!.call(buf, v, offset, buf.byteLength - offset);
+    return encoded;
+}
+
+/**
+ * 默认编码器阈值
+ * @see /benchmark/string-encoder.js
+ */
+const DEFAULT_TEXT_ENCODER_THRESHOLD = 45;
 /**
  * Encode string into utf-8.
  * Provided `buf` MUST have enough space.
  */
 export function myEncodeInto(v: string, buf: Uint8Array, offset: number): number {
-    if (v.length < 55) {
+    if (v.length < DEFAULT_TEXT_ENCODER_THRESHOLD) {
         return jsEncodeInto(v, buf, offset);
     }
     return nativeEncodeInto(v, buf, offset);
@@ -137,14 +157,21 @@ export let encode: (v: string) => Uint8Array<ArrayBuffer>;
 /** 重设环境 */
 export function resetEnv(): void {
     TEXT_ENCODER = typeof TextEncoder == 'function' ? new TextEncoder() : null;
-    stringByteLength =
-        typeof Buffer == 'function' && typeof Buffer.byteLength == 'function'
-            ? nodeStringByteLength
-            : jsStringByteLength;
-    encodeInto = typeof TEXT_ENCODER?.encodeInto == 'function' ? myEncodeInto : jsEncodeInto;
+    const hasBuffer = typeof Buffer == 'function';
+    stringByteLength = hasBuffer && typeof Buffer.byteLength == 'function' ? nodeStringByteLength : jsStringByteLength;
+
+    utf8Write = hasBuffer ? (Buffer.prototype as BufferUndocumented).utf8Write : null;
+    encodeInto =
+        typeof utf8Write == 'function'
+            ? nodeEncodeInto
+            : typeof TEXT_ENCODER?.encodeInto == 'function'
+              ? myEncodeInto
+              : jsEncodeInto;
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const from = hasBuffer ? Buffer.from : null;
     encode =
-        typeof Buffer == 'function' && Buffer.from
-            ? (v) => Buffer.from(v, 'utf8')
+        typeof from == 'function'
+            ? (v) => from(v, 'utf8')
             : TEXT_ENCODER
               ? (v) => TEXT_ENCODER!.encode(v)
               : (v) => {

package/tests/{.utils.js → .utils.ts}

@@ -7,7 +7,7 @@ import '../dist/options.js';
 /**
  * 重设所有环境
  */
-export function resetEnv() {
+export function resetEnv(): void {
     resetDecoderEnv();
     resetEncoderEnv();
     resetEncoder();
@@ -15,25 +15,26 @@ export function resetEnv() {
 
 /**
  * 输入转为数字数组以便比较
- * @param {[ArrayBuffer] | [Uint8Array] | (number | string)[]} args 输入
- * @returns {number[]} 数字数组
+ * @param args 输入
+ * @returns 数字数组
  */
-export function toArray(...args) {
+export function toArray(...args: [ArrayBuffer] | [Uint8Array] | Array<number | string>): number[] {
     if (args[0] instanceof ArrayBuffer) {
         return Array.from(new Uint8Array(args[0]));
     }
     if (args[0] instanceof Uint8Array) {
         return Array.from(args[0]);
     }
-    return args.map((x) => (typeof x == 'number' ? x : /** @type {string} */ (x).charCodeAt(0)));
+    // eslint-disable-next-line unicorn/prefer-code-point
+    return args.map((x) => (typeof x == 'number' ? x : (x as string).charCodeAt(0)));
 }
 
 /**
  * 将数字或字符串转换为 Uint8Array
- * @param  {...string | number} args 数字或 char 的数组
- * @returns {Uint8Array} Uint8Array
+ * @param args 数字或 char 的数组
+ * @returns Uint8Array
  */
-export function toBuffer(...args) {
+export function toBuffer(...args: Array<string | number>): Uint8Array<ArrayBuffer> {
     const data = [];
     for (const x of args) {
         if (typeof x == 'number') {

package/tests/{decode.js → decode.ts}

@@ -3,7 +3,7 @@
  */
 
 import { decode, UnexpectedEof } from '../dist/index.js';
-import { toBuffer } from './.utils.js';
+import { toBuffer } from './.utils.ts';
 
 test('decode unsupported type', () => {
     expect(() => decode(toBuffer('!'))).toThrow();
@@ -141,6 +141,7 @@ test('decode huge string (unexpected eof) [error]', () => {
 
 test('decode ascii string', () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(decode(payload)).toBe('a'.repeat(0x3fff));
@@ -148,6 +149,7 @@ test('decode ascii string', () => {
 
 test('decode ascii string [huge]', () => {
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x7fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(decode(payload)).toBe('a'.repeat(0x7fff));
@@ -507,18 +509,16 @@ test('decode (eof at key)', () => {
 
 describe('proto poisoning attack', () => {
     it('should remove __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
-        );
+        const obj = decode(
+            toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
+        ) as Record<string, unknown>;
         expect(Object.hasOwn(obj, '__proto__')).toBe(false);
         expect(obj['__proto__']).toBe(Object.prototype);
     });
     it('should allow __proto__ key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
-                protoAction: 'allow',
-            })
-        );
+        const obj = decode(toBuffer('{', 'i', 9, '__proto__', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+            protoAction: 'allow',
+        }) as Record<string, unknown>;
         expect(Object.hasOwn(obj, '__proto__')).toBe(true);
         expect(obj['__proto__']).toEqual({ a: 'abc' });
     });
@@ -533,18 +533,16 @@ describe('proto poisoning attack', () => {
 
 describe('constructor poisoning attack', () => {
     it('should remove constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
-                constructorAction: 'remove',
-            })
-        );
+        const obj = decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'), {
+            constructorAction: 'remove',
+        }) as Record<string, unknown>;
         expect(Object.hasOwn(obj, 'constructor')).toBe(false);
         expect(obj.constructor).toBe(Object);
     });
     it('should allow constructor key', () => {
-        const obj = /** @type {Record<string, unknown>} */ (
-            decode(toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'))
-        );
+        const obj = decode(
+            toBuffer('{', 'i', 11, 'constructor', '{', 'i', 1, 'a', 'S', 'i', 3, 'abc', '}', '}'),
+        ) as Record<string, unknown>;
         expect(Object.hasOwn(obj, 'constructor')).toBe(true);
         expect(obj.constructor).toEqual({ a: 'abc' });
     });

package/tests/e2e/{.data.js → .data.ts}

@@ -1,7 +1,5 @@
-/** @type {Record<string, unknown>} */
-export const INPUTS = {};
-/** @type {Record<string, unknown>} */
-export const EXPECTED = {};
+export const INPUTS: Record<string, unknown> = {};
+export const EXPECTED: Record<string, unknown> = {};
 
 INPUTS['number 0'] = 0;
 INPUTS['number 1'] = 1;

package/tests/e2e/{no-buffer-text.js → no-buffer-text.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no Buffer and no textencoder/decoder', () => {

package/tests/e2e/{no-buffer.js → no-buffer.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no Buffer', () => {

package/tests/e2e/{no-encode-into.js → no-encode-into.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no encodeInto', () => {

package/tests/e2e/{no-textencoder-decoder.js → no-textencoder-decoder.ts}

@@ -1,5 +1,5 @@
-import { resetEnv } from '../.utils.js';
-import { INPUTS, EXPECTED } from './.data.js';
+import { resetEnv } from '../.utils.ts';
+import { INPUTS, EXPECTED } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 describe('no textencoder/decoder', () => {

package/tests/e2e/{normal.js → normal.ts}

@@ -1,4 +1,4 @@
-import { EXPECTED, INPUTS } from './.data.js';
+import { EXPECTED, INPUTS } from './.data.ts';
 import { encode, decode } from '../../dist/index.js';
 
 it.each(Object.keys(INPUTS))('%s', (name) => {

package/tests/e2e/{stream.js → stream.ts}

@@ -1,6 +1,6 @@
 import { Readable } from 'node:stream';
 import { encode as encodeStream, decode as decodeStream } from '../../dist/stream/index.js';
-import { EXPECTED, INPUTS } from './.data.js';
+import { EXPECTED, INPUTS } from './.data.ts';
 
 describe('stream', () => {
     it.each(Object.keys(INPUTS))('%s', async (name) => {
@@ -8,15 +8,15 @@ describe('stream', () => {
         const expected = EXPECTED[name] ?? input;
         if (expected instanceof Error) {
             await expect(async () => {
-                const encoded = await Readable.fromWeb(/** @type {any} */ (encodeStream(input))).toArray();
+                const encoded = await Readable.fromWeb(encodeStream(input) as never).toArray();
                 const decoded = await decodeStream(
-                    /** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from(encoded))),
+                    Readable.toWeb(Readable.from(encoded)) as ReadableStream<Uint8Array<ArrayBuffer>>,
                 );
                 expect(decoded).toEqual(expected);
             }).rejects.toThrow(expected);
         } else {
-            const encoded = await Readable.fromWeb(/** @type {any} */ (encodeStream(input))).toArray();
-            const data = encoded.flatMap((/** @type {Buffer} */ chunk) => {
+            const encoded = await Readable.fromWeb(encodeStream(input) as never).toArray();
+            const data = encoded.flatMap((chunk: Buffer<ArrayBuffer>) => {
                 if (chunk.length < 2) return [chunk];
                 // split to random chunks
                 const chunks = [];
@@ -29,7 +29,7 @@ describe('stream', () => {
                 return chunks;
             });
             const decoded = await decodeStream(
-                /** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(Readable.from(data))),
+                Readable.toWeb(Readable.from(data)) as ReadableStream<Uint8Array<ArrayBuffer>>,
             );
             expect(decoded).toEqual(expected);
         }

package/tests/{encode.js → encode.ts}

@@ -4,10 +4,10 @@
 
 import { encode, decode } from '../dist/index.js';
 import { getEncoder } from '../dist/encoder.js';
-import { toArray } from './.utils.js';
+import { toArray } from './.utils.ts';
 
 // @ts-expect-error Access private property
-const poolInit = getEncoder().pool;
+const poolInit = getEncoder().pool as Uint8Array<ArrayBuffer>;
 
 test('encode function', () => {
     expect(() =>
@@ -444,10 +444,10 @@ test('encode object (only null values)', () => {
 });
 
 test('encode object (skip prototype)', () => {
-    const obj = Object.create({ a: 2, x: 'xx' });
-    obj.a = 1;
-    obj.b = 'a';
-    obj.c = true;
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
+    obj['a'] = 1;
+    obj['b'] = 'a';
+    obj['c'] = true;
     expect(toArray(encode(obj))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
     );

package/tests/{huge-string.js → huge-string.ts}

@@ -1,16 +1,13 @@
 import { Buffer } from 'node:buffer';
 import { encode } from '../dist/index.js';
-import { toArray, resetEnv } from './.utils.js';
+import { toArray, resetEnv } from './.utils.ts';
 
 const STR_BYTE_LENGTH = 128 * 1024 * 1024 - 20;
 
 /**
  * 构造测试字符串
- * @param {string} char 使用的字符
- * @param {number} byteLength 需要的长度
- * @returns {[Uint8Array, string]}
  */
-function makeString(char, byteLength) {
+function makeString(char: string, byteLength: number): [Uint8Array<ArrayBuffer>, string] {
     const encoded = new TextEncoder().encode(char);
     return [encoded, char.repeat(byteLength / encoded.byteLength)];
 }

package/tests/rxjs/{decode.js → decode.ts}

@@ -2,36 +2,30 @@
  * Tests from https://bitbucket.org/shelacek/ubjson
  */
 import { jest } from '@jest/globals';
-import { firstValueFrom, of, Subject } from 'rxjs';
+import { firstValueFrom, type Observable, of, Subject } from 'rxjs';
 import { decode as decodePipe } from '../../dist/rxjs/index.js';
-import { toBuffer } from '../.utils.js';
+import { toBuffer } from '../.utils.ts';
 import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
  * 包装为 promise
- * @param {Uint8Array} data ubjson 数据
- * @returns {Promise<unknown>}
  */
-async function decode(data) {
+async function decode(data: BufferSource): Promise<unknown> {
     const readable = of(data);
     return firstValueFrom(readable.pipe(decodePipe()), { defaultValue: undefined });
 }
 
 /**
  * 包装为 promise
- * @param {import("rxjs").Observable<Uint8Array>} observable ubjson 数据流
- * @param {(data: unknown) => void} onData 数据回调
  */
-async function decodeStream(observable, onData) {
-    return /** @type {Promise<void>} */ (
-        new Promise((resolve, reject) => {
-            observable.pipe(decodePipe()).subscribe({
-                next: onData,
-                error: reject,
-                complete: resolve,
-            });
-        })
-    );
+async function decodeStream(observable: Observable<BufferSource>, onData: (data: unknown) => void) {
+    return new Promise<void>((resolve, reject) => {
+        observable.pipe(decodePipe()).subscribe({
+            next: onData,
+            error: reject,
+            complete: resolve,
+        });
+    });
 }
 
 test('decode unsupported type', async () => {
@@ -117,6 +111,7 @@ test('decode string (unexpected eof) [error]', async () => {
 
 test('decode ascii string', async () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x3fff));
@@ -125,6 +120,7 @@ test('decode ascii string', async () => {
 test('decode ascii string 32kiB [huge]', async () => {
     const size = 0x7fff;
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(size));
@@ -133,6 +129,7 @@ test('decode ascii string 32kiB [huge]', async () => {
 test('decode ascii string 64MB [huge]', async () => {
     const size = 0x03d0_9000;
     const header = toBuffer('S', 'l', 0x03, 0xd0, 0x90, 0x00);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(size + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(size));
@@ -469,7 +466,7 @@ test('decode object (empty key, optimized)', async () => {
 });
 
 test('decode stream', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -487,7 +484,7 @@ test('decode stream', async () => {
 });
 
 test('decode bad stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -506,7 +503,7 @@ test('decode bad stream [error]', async () => {
 });
 
 test('decode partial stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);
@@ -522,7 +519,7 @@ test('decode partial stream [error]', async () => {
 });
 
 test('decode error stream [error]', async () => {
-    const stream = new Subject();
+    const stream = new Subject<BufferSource>();
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     const result = decodeStream(stream, onData);

package/tests/rxjs/{encode.js → encode.ts}

@@ -4,14 +4,12 @@
 import { firstValueFrom, of, map, reduce, Subject, toArray as rxjsToArray } from 'rxjs';
 import { encode } from '../../dist/rxjs/index.js';
 import { decode, encode as encodeRef } from '../../dist/index.js';
-import { toArray } from '../.utils.js';
+import { toArray } from '../.utils.ts';
 
 /**
  * 包装为 promise
- * @param {unknown} value 要编码的值
- * @returns {Promise<Buffer>}
  */
-async function encodeAsync(value) {
+async function encodeAsync(value: unknown): Promise<Buffer<ArrayBuffer>> {
     return firstValueFrom(
         of(value).pipe(
             encode(),
@@ -304,7 +302,7 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = /** @type {Record<string, unknown>} */ (Object.create({ a: 2, x: 'xx' }));
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
     obj['a'] = 1;
     obj['b'] = 'a';
     obj['c'] = true;

package/tests/stream/{decode.js → decode.ts}

@@ -4,25 +4,21 @@
 import { jest } from '@jest/globals';
 import { Readable, Transform } from 'node:stream';
 import { decoder as decodeStream, decode as decodeAsync } from '../../dist/stream/index.js';
-import { toBuffer } from '../.utils.js';
+import { toBuffer } from '../.utils.ts';
 import { UnexpectedEofError as UnexpectedEof } from '../../dist/helper/errors.js';
 
 /**
  * 包装为 promise
- * @param {Uint8Array} data ubjson 数据
- * @returns {Promise<unknown>}
  */
-async function decode(data) {
+async function decode(data: Uint8Array<ArrayBuffer>): Promise<unknown> {
     const readable = Readable.from([data], { objectMode: false });
-    return decodeAsync(/** @type {ReadableStream<Uint8Array>} */ (Readable.toWeb(readable)));
+    return decodeAsync(Readable.toWeb(readable) as ReadableStream<Uint8Array<ArrayBuffer>>);
 }
 
 /**
  * 包装为 promise
- * @param {import("stream").Readable} stream ubjson 流
- * @returns {Promise<void>}
  */
-async function eos(stream) {
+async function eos(stream: Readable): Promise<void> {
     return new Promise((resolve, reject) => {
         stream.on('error', reject);
         stream.on('end', resolve);
@@ -113,6 +109,7 @@ test('decode string (unexpected eof) [error]', async () => {
 
 test('decode ascii string', async () => {
     const header = toBuffer('S', 'I', 0x3f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x3fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x3fff));
@@ -120,6 +117,7 @@ test('decode ascii string', async () => {
 
 test('decode ascii string [huge]', async () => {
     const header = toBuffer('S', 'I', 0x7f, 0xff);
+    // eslint-disable-next-line unicorn/prefer-code-point
     const payload = new Uint8Array(0x7fff + header.byteLength).fill('a'.charCodeAt(0));
     payload.set(header);
     expect(await decode(payload)).toBe('a'.repeat(0x7fff));
@@ -456,7 +454,7 @@ test('decode object (empty key, optimized)', async () => {
 });
 
 test('decode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (decodeStream()), { objectMode: true });
+    const stream = Transform.fromWeb(decodeStream() as never, { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);
@@ -499,7 +497,7 @@ test('decode bad stream [error]', async () => {
 });
 
 test('decode partial stream [error]', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (decodeStream()), { objectMode: true });
+    const stream = Transform.fromWeb(decodeStream() as never, { objectMode: true });
     // while decoding streaming, N will be regarded as a no-op, rather than an undefined value
     const onData = jest.fn();
     stream.on('data', onData);

package/tests/stream/{encode.js → encode.ts}

@@ -4,16 +4,14 @@
 import { buffer } from 'node:stream/consumers';
 import { encode, encoder } from '../../dist/stream/index.js';
 import { decode, encode as encodeRef } from '../../dist/index.js';
-import { toArray } from '../.utils.js';
+import { toArray } from '../.utils.ts';
 import { Transform } from 'node:stream';
 
 /**
  * 包装为 promise
- * @param {unknown} value 值
- * @returns {Promise<Buffer>} 返回值
  */
-async function encodeAsync(value) {
-    return buffer(encode(value));
+async function encodeAsync(value: unknown): Promise<Buffer<ArrayBuffer>> {
+    return (await buffer(encode(value))) as Buffer<ArrayBuffer>;
 }
 
 test('encode function', async () => {
@@ -299,10 +297,10 @@ test('encode object (only null values)', async () => {
 });
 
 test('encode object (skip prototype)', async () => {
-    const obj = Object.create({ a: 2, x: 'xx' });
-    obj.a = 1;
-    obj.b = 'a';
-    obj.c = true;
+    const obj = Object.create({ a: 2, x: 'xx' }) as Record<string, unknown>;
+    obj['a'] = 1;
+    obj['b'] = 'a';
+    obj['c'] = true;
     expect(toArray(await encodeAsync(obj))).toEqual(
         toArray('{', 'i', 1, 'a', 'U', 1, 'i', 1, 'b', 'C', 'a', 'i', 1, 'c', 'T', '}'),
     );
@@ -364,7 +362,7 @@ test('encode huge data (~128M)', async () => {
 });
 
 test('encode stream', async () => {
-    const stream = Transform.fromWeb(/** @type {any} */ (encoder()), { objectMode: true });
+    const stream = Transform.fromWeb(encoder() as never, { objectMode: true });
     stream.write(undefined);
     stream.write(true);
     stream.write(false);