ts-data-forge 6.3.0 → 6.3.1

package/src/collections/queue.mts

@@ -205,19 +205,19 @@ export type Queue<T> = Readonly<{
  */
 class QueueClass<T> implements Queue<T> {
   /** @internal Circular buffer to store queue elements. */
-  #buffer: (T | undefined)[];
+  #mut_buffer: (T | undefined)[];
 
   /** @internal Index of the first element (front of queue). */
-  #head: number;
+  #mut_head: number;
 
   /** @internal Index where the next element will be added (back of queue). */
-  #tail: number;
+  #mut_tail: number;
 
   /** @internal Current number of elements in the queue. */
   #mut_size: number;
 
   /** @internal Current capacity of the buffer. */
-  #capacity: number;
+  #mut_capacity: number;
 
   /** @internal Initial capacity for new queues. */
   static readonly #INITIAL_CAPACITY = 8;
@@ -232,18 +232,18 @@ class QueueClass<T> implements Queue<T> {
       Math.max(QueueClass.#INITIAL_CAPACITY, initialValues.length * 2),
     );
 
-    this.#buffer = Array.from<unknown, T | undefined>(
+    this.#mut_buffer = Array.from<unknown, T | undefined>(
       { length: initialCapacity },
       () => undefined,
     );
 
-    this.#head = 0;
+    this.#mut_head = 0;
 
-    this.#tail = 0;
+    this.#mut_tail = 0;
 
     this.#mut_size = 0;
 
-    this.#capacity = initialCapacity;
+    this.#mut_capacity = initialCapacity;
 
     // Add initial values
     for (const value of initialValues) {
@@ -281,11 +281,11 @@ class QueueClass<T> implements Queue<T> {
     }
 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const element = this.#buffer[this.#head]!;
+    const element = this.#mut_buffer[this.#mut_head]!;
 
-    this.#buffer[this.#head] = undefined; // Clear reference for garbage collection
+    this.#mut_buffer[this.#mut_head] = undefined; // Clear reference for garbage collection
 
-    this.#head = (this.#head + 1) % this.#capacity;
+    this.#mut_head = (this.#mut_head + 1) % this.#mut_capacity;
 
     this.#mut_size -= 1;
 
@@ -311,13 +311,13 @@ class QueueClass<T> implements Queue<T> {
    */
   enqueue(value: T): void {
     // Resize if buffer is full
-    if (this.#mut_size === this.#capacity) {
+    if (this.#mut_size === this.#mut_capacity) {
       this.#resize();
     }
 
-    this.#buffer[this.#tail] = value;
+    this.#mut_buffer[this.#mut_tail] = value;
 
-    this.#tail = (this.#tail + 1) % this.#capacity;
+    this.#mut_tail = (this.#mut_tail + 1) % this.#mut_capacity;
 
     this.#mut_size += 1;
   }
@@ -328,7 +328,7 @@ class QueueClass<T> implements Queue<T> {
    * Doubles the capacity and reorganizes elements to maintain queue order.
    */
   #resize(): void {
-    const newCapacity = asUint32(this.#capacity * 2);
+    const newCapacity = asUint32(this.#mut_capacity * 2);
 
     const newBuffer = Array.from<unknown, T | undefined>(
       { length: newCapacity },
@@ -337,18 +337,18 @@ class QueueClass<T> implements Queue<T> {
 
     // Copy elements in order from head to tail
     for (const i of range(asSafeUint(this.#mut_size))) {
-      const sourceIndex = (this.#head + i) % this.#capacity;
+      const sourceIndex = (this.#mut_head + i) % this.#mut_capacity;
 
-      newBuffer[i] = this.#buffer[sourceIndex];
+      newBuffer[i] = this.#mut_buffer[sourceIndex];
     }
 
-    this.#buffer = newBuffer;
+    this.#mut_buffer = newBuffer;
 
-    this.#head = 0;
+    this.#mut_head = 0;
 
-    this.#tail = this.#mut_size;
+    this.#mut_tail = this.#mut_size;
 
-    this.#capacity = newCapacity;
+    this.#mut_capacity = newCapacity;
   }
 }
 

package/src/collections/queue.test.mts

@@ -481,7 +481,7 @@ describe('Queue test', () => {
     });
 
     test('should properly clean up references for garbage collection', () => {
-      const q = createQueue<{ id: number }>();
+      const q = createQueue<Readonly<{ id: number }>>();
 
       const objects = Arr.seq(10).map((i) => ({ id: i }));
 

package/src/collections/stack.mts

@@ -200,13 +200,13 @@ export type Stack<T> = Readonly<{
  */
 class StackClass<T> implements Stack<T> {
   /** @internal Dynamic array to store stack elements. */
-  #buffer: (T | undefined)[];
+  #mut_buffer: (T | undefined)[];
 
   /** @internal Current number of elements in the stack. */
   #mut_size: Uint32;
 
   /** @internal Current capacity of the buffer. */
-  #capacity: Uint32;
+  #mut_capacity: Uint32;
 
   /** @internal Initial capacity for new stacks. */
   static readonly #INITIAL_CAPACITY = 8;
@@ -221,14 +221,14 @@ class StackClass<T> implements Stack<T> {
       Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2),
     );
 
-    this.#buffer = Array.from<unknown, T | undefined>(
+    this.#mut_buffer = Array.from<unknown, T | undefined>(
       { length: initialCapacity },
       () => undefined,
     );
 
     this.#mut_size = asUint32(0);
 
-    this.#capacity = initialCapacity;
+    this.#mut_capacity = initialCapacity;
 
     // Add initial values
     for (const value of initialValues) {
@@ -268,9 +268,9 @@ class StackClass<T> implements Stack<T> {
     this.#mut_size = Uint32.sub(this.#mut_size, 1);
 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const element = this.#buffer[this.#mut_size]!;
+    const element = this.#mut_buffer[this.#mut_size]!;
 
-    this.#buffer[this.#mut_size] = undefined; // Clear reference for garbage collection
+    this.#mut_buffer[this.#mut_size] = undefined; // Clear reference for garbage collection
 
     return Optional.some(element);
   }
@@ -294,11 +294,11 @@ class StackClass<T> implements Stack<T> {
    */
   push(value: T): void {
     // Resize if buffer is full
-    if (this.#mut_size === this.#capacity) {
+    if (this.#mut_size === this.#mut_capacity) {
       this.#resize();
     }
 
-    this.#buffer[this.#mut_size] = value;
+    this.#mut_buffer[this.#mut_size] = value;
 
     this.#mut_size = Uint32.add(this.#mut_size, 1);
   }
@@ -309,7 +309,7 @@ class StackClass<T> implements Stack<T> {
    * Doubles the capacity while preserving all elements.
    */
   #resize(): void {
-    const newCapacity = asUint32(this.#capacity * 2);
+    const newCapacity = asUint32(this.#mut_capacity * 2);
 
     const newBuffer = Array.from<unknown, T | undefined>(
       { length: newCapacity },
@@ -318,12 +318,12 @@ class StackClass<T> implements Stack<T> {
 
     // Copy existing elements
     for (const i of range(this.#mut_size)) {
-      newBuffer[i] = this.#buffer[i];
+      newBuffer[i] = this.#mut_buffer[i];
     }
 
-    this.#buffer = newBuffer;
+    this.#mut_buffer = newBuffer;
 
-    this.#capacity = newCapacity;
+    this.#mut_capacity = newCapacity;
   }
 }
 

package/src/functional/match.mts

@@ -27,7 +27,7 @@ import { keyIsIn } from '../guard/index.mjs';
  *
  * const message = match<
  *   Status,
- *   { draft: string; review: string; published: string }
+ *   Readonly<{ draft: string; review: string; published: string }>
  * >(status, {
  *   draft: 'Work in progress',
  *   review: 'Awaiting feedback',
@@ -104,11 +104,15 @@ type StrictPropertyCheck<T, ExpectedKeys extends PropertyKey> =
 type AllCasesCovered<Case extends PropertyKey, R> =
   TypeEq<Case, keyof R> extends true ? true : false;
 
-expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+expectType<AllCasesCovered<'a' | 'b', Readonly<{ a: 1; b: 2 }>>, true>('=');
 
-expectType<AllCasesCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>('=');
+expectType<AllCasesCovered<'a' | 'b' | 'c', Readonly<{ a: 1; b: 2 }>>, false>(
+  '=',
+);
 
-expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>('=');
+expectType<AllCasesCovered<'a' | 'b', Readonly<{ a: 1; b: 2; c: 3 }>>, false>(
+  '=',
+);
 
 expectType<AllCasesCovered<string, Record<string, string>>, true>('=');
 
@@ -126,15 +130,20 @@ type IsLiteralUnionFullyCovered<
     ? AllCasesCovered<Case, R>
     : false;
 
-expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+expectType<
+  IsLiteralUnionFullyCovered<'a' | 'b', Readonly<{ a: 1; b: 2 }>>,
+  true
+>('=');
 
-expectType<IsLiteralUnionFullyCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>(
-  '=',
-);
+expectType<
+  IsLiteralUnionFullyCovered<'a' | 'b' | 'c', Readonly<{ a: 1; b: 2 }>>,
+  false
+>('=');
 
-expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>(
-  '=',
-);
+expectType<
+  IsLiteralUnionFullyCovered<'a' | 'b', Readonly<{ a: 1; b: 2; c: 3 }>>,
+  false
+>('=');
 
 expectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(
   '=',
@@ -142,7 +151,7 @@ expectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(
 
 expectType<
   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
-  IsLiteralUnionFullyCovered<'a' | 'b' | string, { a: 1; b: 2 }>,
+  IsLiteralUnionFullyCovered<'a' | 'b' | string, Readonly<{ a: 1; b: 2 }>>,
   false
 >('=');
 

package/src/globals.d.mts

@@ -13,7 +13,7 @@ type ArgArrayIndex<Ar extends readonly unknown[]> =
 
 type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
   IsFixedLengthList<Ar> extends true
-    ? IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
+    ? IndexOfTuple<readonly [...Ar, 0]> | NegativeIndexOfTuple<Ar>
     : SizeType.ArgArrWithNegative;
 
 // https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Array/length

package/src/guard/has-key.mts

@@ -17,7 +17,7 @@
  * @example
  *
  * ```ts
- * const maybeUser: { id?: number; name?: string } = { id: 42 };
+ * const maybeUser: Readonly<{ id?: number; name?: string }> = { id: 42 };
  *
  * if (hasKey(maybeUser, 'id')) {
  *   // `maybeUser` is now known to have an `id` property.

package/src/guard/has-key.test.mts

@@ -4,52 +4,42 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 test('hasKey type inferences', () => {
   {
     expectType<
-      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'a'>,
+      HasKeyReturnType<Readonly<{ a: 0 } | { b: 1 }>, 'a'>,
       Readonly<{ a: 0 }>
     >('=');
 
     expectType<
-      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'b'>,
+      HasKeyReturnType<Readonly<{ a: 0 } | { b: 1 }>, 'b'>,
       Readonly<{ b: 1 }>
     >('=');
 
-    expectType<
-      HasKeyReturnType<Readonly<{ a: 0 }> | Readonly<{ b: 1 }>, 'd'>,
-      never
-    >('=');
+    expectType<HasKeyReturnType<Readonly<{ a: 0 } | { b: 1 }>, 'd'>, never>(
+      '=',
+    );
 
     expectType<
       HasKeyReturnType<
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>
-        | Readonly<{ c: 3 }>,
+        Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 } | { c: 3 }>,
         'a'
       >,
-      Readonly<{ a: 0 }> | Readonly<{ a: 1; b: 1 }>
+      Readonly<{ a: 0 } | { a: 1; b: 1 }>
     >('=');
 
     expectType<
       HasKeyReturnType<
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>
-        | Readonly<{ c: 3 }>,
+        Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 } | { c: 3 }>,
         'b'
       >,
-      Readonly<{ a: 1; b: 1 }> | Readonly<{ b: 2 }>
+      Readonly<{ a: 1; b: 1 } | { b: 2 }>
     >('=');
 
     expectType<
       HasKeyReturnType<
         | ReadonlyRecord<string, number>
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
-        | Readonly<{ b: 2 }>,
+        | Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 }>,
         'a'
       >,
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
+      | Readonly<{ a: 0 } | { a: 1; b: 1 }>
       | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
     >('=');
 
@@ -60,7 +50,7 @@ test('hasKey type inferences', () => {
   }
 
   {
-    type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
+    type R = Readonly<{ a: 0 } | { b: 1 }>;
 
     const obj: R = { a: 0 } as R;
 
@@ -76,11 +66,7 @@ test('hasKey type inferences', () => {
   }
 
   {
-    type R =
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
-      | Readonly<{ c: 3 }>;
+    type R = Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 } | { c: 3 }>;
 
     const obj: R = { a: 0 } as R;
 
@@ -96,18 +82,14 @@ test('hasKey type inferences', () => {
   {
     type R =
       | ReadonlyRecord<string, number>
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>;
+      | Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 }>;
 
     const obj: R = { a: 0 } as R;
 
     expectType<
       R,
       | ReadonlyRecord<string, number>
-      | Readonly<{ a: 0 }>
-      | Readonly<{ a: 1; b: 1 }>
-      | Readonly<{ b: 2 }>
+      | Readonly<{ a: 0 } | { a: 1; b: 1 } | { b: 2 }>
     >('=');
 
     if (hasKey(obj, 'a')) {
@@ -115,8 +97,7 @@ test('hasKey type inferences', () => {
 
       expectType<
         typeof obj,
-        | Readonly<{ a: 0 }>
-        | Readonly<{ a: 1; b: 1 }>
+        | Readonly<{ a: 0 } | { a: 1; b: 1 }>
         | (ReadonlyRecord<'a', number> & ReadonlyRecord<string, number>)
       >('=');
     }

package/src/guard/is-error.test.mts

@@ -43,7 +43,7 @@ describe('isError from @sindresorhus/is', () => {
 
   test('should return true for Error subclass with additional properties', () => {
     class ExtendedError extends Error {
-      code: number;
+      readonly code: number;
 
       constructor(message: string, code: number) {
         super(message);

package/src/guard/is-non-empty-string.test.mts

@@ -75,7 +75,7 @@ describe(isNonEmptyString, () => {
   });
 
   test('should work in filter operations', () => {
-    const mixed: unknown[] = [
+    const mixed: readonly unknown[] = [
       'valid',
       '',
       null,

package/src/guard/is-non-null-object.mts

@@ -19,7 +19,7 @@
  * @example
  *
  * ```ts
- * const mixed: unknown[] = [{ id: 1 }, null, 'Ada'] as const;
+ * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
  *
  * const objects = mixed.filter(isNonNullObject);
  *

package/src/guard/is-non-null-object.test.mts

@@ -89,7 +89,7 @@ describe(isNonNullObject, () => {
   });
 
   test('should work in filter operations', () => {
-    const mixed: unknown[] = [
+    const mixed: readonly unknown[] = [
       'string',
       42,
       { a: 1 },

package/src/guard/is-primitive.test.mts

@@ -93,7 +93,7 @@ describe(isPrimitive, () => {
   });
 
   test('should narrow types correctly in conditional', () => {
-    const values: unknown[] = [
+    const values: readonly unknown[] = [
       'string',
       42,
       true,

package/src/guard/is-record.mts

@@ -25,7 +25,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
  * @example
  *
  * ```ts
- * const entries: unknown[] = [{ id: 1 }, 'str', 0, null];
+ * const entries: readonly unknown[] = [{ id: 1 }, 'str', 0, null];
  *
  * const records = entries.filter(isRecord);
  *

package/src/guard/is-type.mts

@@ -9,7 +9,7 @@
  * @example
  *
  * ```ts
- * const values: (number | undefined)[] = [1, undefined, 2];
+ * const values: readonly (number | undefined)[] = [1, undefined, 2];
  *
  * const undefinedValues = values.filter(isUndefined);
  *
@@ -34,7 +34,7 @@ export const isUndefined = (u: unknown): u is undefined => u === undefined;
  * @example
  *
  * ```ts
- * const values: (number | undefined)[] = [1, undefined, 2];
+ * const values: readonly (number | undefined)[] = [1, undefined, 2];
  *
  * const definedValues = values.filter(isNotUndefined);
  *
@@ -60,7 +60,7 @@ export const isNotUndefined = <T,>(u: T): u is RelaxedExclude<T, undefined> =>
  * @example
  *
  * ```ts
- * const flags: unknown[] = [true, 'no', false];
+ * const flags: readonly unknown[] = [true, 'no', false];
  *
  * const booleans = flags.filter(isBoolean);
  *
@@ -84,7 +84,7 @@ export const isBoolean = (u: unknown): u is boolean => typeof u === 'boolean';
  * @example
  *
  * ```ts
- * const flags: unknown[] = [true, 'no', false];
+ * const flags: readonly unknown[] = [true, 'no', false];
  *
  * const nonBooleans = flags.filter(isNotBoolean);
  *
@@ -111,7 +111,7 @@ export const isNotBoolean = <T,>(u: T): u is RelaxedExclude<T, boolean> =>
  * @example
  *
  * ```ts
- * const mixed: unknown[] = [1, '2', 3];
+ * const mixed: readonly unknown[] = [1, '2', 3];
  *
  * const numbers = mixed.filter(isNumber);
  *
@@ -135,7 +135,7 @@ export const isNumber = (u: unknown): u is number => typeof u === 'number';
  * @example
  *
  * ```ts
- * const mixed: unknown[] = [1, '2', 3];
+ * const mixed: readonly unknown[] = [1, '2', 3];
  *
  * const nonNumbers = mixed.filter(isNotNumber);
  *
@@ -161,7 +161,7 @@ export const isNotNumber = <T,>(u: T): u is RelaxedExclude<T, number> =>
  * @example
  *
  * ```ts
- * const values: unknown[] = [1n, 2, 3n];
+ * const values: readonly unknown[] = [1n, 2, 3n];
  *
  * const bigints = values.filter(isBigint);
  *
@@ -185,7 +185,7 @@ export const isBigint = (u: unknown): u is bigint => typeof u === 'bigint';
  * @example
  *
  * ```ts
- * const values: unknown[] = [1n, 2, 3n];
+ * const values: readonly unknown[] = [1n, 2, 3n];
  *
  * const nonBigints = values.filter(isNotBigint);
  *
@@ -212,7 +212,7 @@ export const isNotBigint = <T,>(u: T): u is RelaxedExclude<T, bigint> =>
  * @example
  *
  * ```ts
- * const values: unknown[] = ['Ada', 42, 'Lovelace'];
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'];
  *
  * const strings = values.filter(isString);
  *
@@ -236,7 +236,7 @@ export const isString = (u: unknown): u is string => typeof u === 'string';
  * @example
  *
  * ```ts
- * const values: unknown[] = ['Ada', 42, 'Lovelace'];
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'];
  *
  * const nonStrings = values.filter(isNotString);
  *
@@ -266,7 +266,7 @@ export const isNotString = <T,>(u: T): u is RelaxedExclude<T, string> =>
  *
  * const shared = Symbol.for('shared');
  *
- * const tokens: unknown[] = [id, 'shared', shared];
+ * const tokens: readonly unknown[] = [id, 'shared', shared];
  *
  * const symbols = tokens.filter(isSymbol);
  *
@@ -292,7 +292,7 @@ export const isSymbol = (u: unknown): u is symbol => typeof u === 'symbol';
  * ```ts
  * const id = Symbol('id');
  *
- * const tokens: unknown[] = [id, 'shared'];
+ * const tokens: readonly unknown[] = [id, 'shared'];
  *
  * const nonSymbols = tokens.filter(isNotSymbol);
  *
@@ -343,7 +343,7 @@ export const isNull = (u: unknown): u is null => u === null;
  * @example
  *
  * ```ts
- * const values: (number | null)[] = [null, 5];
+ * const values: readonly (number | null)[] = [null, 5];
  *
  * const nonNullValues = values.filter(isNotNull);
  *
@@ -372,7 +372,11 @@ export const isNotNull = <T,>(u: T | null): u is T => u !== null;
  * @example
  *
  * ```ts
- * const values: (string | null | undefined)[] = ['Ada', null, undefined];
+ * const values: readonly (string | null | undefined)[] = [
+ *   'Ada',
+ *   null,
+ *   undefined,
+ * ];
  *
  * const nullishValues = values.filter(isNullish);
  *
@@ -401,7 +405,11 @@ export const isNullish = (u: unknown): u is null | undefined => u == null;
  * @example
  *
  * ```ts
- * const values: (string | null | undefined)[] = ['Ada', null, undefined];
+ * const values: readonly (string | null | undefined)[] = [
+ *   'Ada',
+ *   null,
+ *   undefined,
+ * ];
  *
  * const definedValues = values.filter(isNonNullish);
  *

package/src/guard/is-type.test.mts

@@ -566,7 +566,7 @@ describe(isNonNullish, () => {
   });
 
   test('should work with array filtering', () => {
-    const items: (string | null | undefined)[] = [
+    const items: readonly (string | null | undefined)[] = [
       'hello',
       null,
       'world',
@@ -576,7 +576,7 @@ describe(isNonNullish, () => {
 
     const definedItems = items.filter(isNonNullish);
 
-    expectType<typeof definedItems, string[]>('<=');
+    expectType<typeof definedItems, readonly string[]>('<=');
 
     expect(definedItems).toHaveLength(3);
 
@@ -609,7 +609,7 @@ describe('type guard behavior in complex scenarios', () => {
   });
 
   test('should work with array operations', () => {
-    const mixed: (string | number | boolean | null | undefined)[] = [
+    const mixed: readonly (string | number | boolean | null | undefined)[] = [
       'hello',
       42,
       true,
@@ -622,15 +622,15 @@ describe('type guard behavior in complex scenarios', () => {
 
     const nonNullish = mixed.filter(isNonNullish);
 
-    expectType<typeof nonNullish, (string | number | boolean)[]>('<=');
+    expectType<typeof nonNullish, readonly (string | number | boolean)[]>('<=');
 
     const nonBooleans = nonNullish.filter(isNotBoolean);
 
-    expectType<typeof nonBooleans, (string | number)[]>('<=');
+    expectType<typeof nonBooleans, readonly (string | number)[]>('<=');
 
     const strings = nonBooleans.filter(isNotNumber);
 
-    expectType<typeof strings, string[]>('<=');
+    expectType<typeof strings, readonly string[]>('<=');
 
     assert.deepStrictEqual(strings, ['hello', 'world']);
   });

package/src/json/json.test.mts

@@ -507,6 +507,7 @@ describe('stringifySelected', () => {
   });
 
   test('should handle circular references with error', () => {
+    // transformer-ignore-next-line
     type CircularType = { name: string; self?: CircularType };
 
     const mut_circular: CircularType = { name: 'test' };
@@ -669,6 +670,7 @@ describe('stringifySortedKey', () => {
 
   test('should handle problematic objects', () => {
     try {
+      // transformer-ignore-next-line
       type CircularObj = {
         normal: string;
         circular: { self?: CircularObj };