ts-data-forge 5.1.0 → 6.0.0

package/src/functional/ternary-result/impl/ternary-result-is-ternary-result.mts

@@ -13,11 +13,11 @@ import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
  *
  * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
  *
- * assert.ok(TernaryResult.isTernaryResult(okValue));
+ * assert.isTrue(TernaryResult.isTernaryResult(okValue));
  *
- * assert.ok(TernaryResult.isTernaryResult(warnValue));
+ * assert.isTrue(TernaryResult.isTernaryResult(warnValue));
  *
- * assert.ok(!TernaryResult.isTernaryResult(notResult));
+ * assert.isFalse(TernaryResult.isTernaryResult(notResult));
  * ```
  */
 export const isTernaryResult = (

package/src/functional/ternary-result.test.mts

@@ -10,15 +10,15 @@ describe('TernaryResult test', () => {
 
     const err = TernaryResult.err(new Error('boom'));
 
-    expect(TernaryResult.isOk(ok)).toBe(true);
+    assert.isTrue(TernaryResult.isOk(ok));
 
-    expect(TernaryResult.isWarn(warn)).toBe(true);
+    assert.isTrue(TernaryResult.isWarn(warn));
 
-    expect(TernaryResult.isErr(err)).toBe(true);
+    assert.isTrue(TernaryResult.isErr(err));
 
-    expect(TernaryResult.isTernaryResult(ok)).toBe(true);
+    assert.isTrue(TernaryResult.isTernaryResult(ok));
 
-    expect(TernaryResult.isTernaryResult({})).toBe(false);
+    assert.isFalse(TernaryResult.isTernaryResult({}));
 
     expectType<typeof ok, TernaryResult<number, never, never>>('<=');
 
@@ -85,7 +85,7 @@ describe('TernaryResult test', () => {
 
     expect(TernaryResult.unwrapOk(okResult)).toBe(3);
 
-    expect(TernaryResult.isWarn(warnResult)).toBe(true);
+    assert.isTrue(TernaryResult.isWarn(warnResult));
 
     if (TernaryResult.isWarn(warnResult)) {
       expect(warnResult.value).toBe(3);
@@ -242,7 +242,7 @@ describe('TernaryResult test', () => {
       Promise.reject(new Error('bad')),
     );
 
-    expect(TernaryResult.isErr(rejected)).toBe(true);
+    assert.isTrue(TernaryResult.isErr(rejected));
   });
 
   test('fromThrowable converts thrown values', () => {
@@ -255,7 +255,7 @@ describe('TernaryResult test', () => {
       throw new Error('boom');
     });
 
-    expect(TernaryResult.isErr(errorResult)).toBe(true);
+    assert.isTrue(TernaryResult.isErr(errorResult));
   });
 
   test('unwrapOkOr curried version', () => {

package/src/globals.d.mts

@@ -13,7 +13,8 @@ type ArgArrayIndex<Ar extends readonly unknown[]> =
 
 type ArgArrayIndexWithNegative<Ar extends readonly unknown[]> =
   IsFixedLengthList<Ar> extends true
-    ? IndexOfTuple<[...Ar, 0]> | NegativeIndexOfTuple<Ar>
+    ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+        IndexOfTuple<[...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

@@ -21,9 +21,9 @@
  *
  * if (hasKey(maybeUser, 'id')) {
  *   // `maybeUser` is now known to have an `id` property.
- *   assert(maybeUser.id === 42);
+ *   assert.isTrue(maybeUser.id === 42);
  * } else {
- *   assert.fail('Expected the object to contain the id key.');
+ *   assert.fail();
  * }
  * ```
  *
@@ -58,11 +58,14 @@ export type HasKeyReturnType<
 > = R extends R // union distribution
   ? K extends keyof R
     ? string extends keyof R
-      ? ReadonlyRecord<K, R[keyof R]> & R
+      ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+        ReadonlyRecord<K, R[keyof R]> & R
       : number extends keyof R
-        ? ReadonlyRecord<K, R[keyof R]> & R
+        ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+          ReadonlyRecord<K, R[keyof R]> & R
         : symbol extends keyof R
-          ? ReadonlyRecord<K, R[keyof R]> & R
+          ? // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+            ReadonlyRecord<K, R[keyof R]> & R
           : R
     : never // omit union member that does not have key K
   : never; // dummy case for union distribution

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

@@ -61,7 +61,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
 {
   type R = Readonly<{ a: 0 }> | Readonly<{ b: 1 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   if (hasKey(obj, 'a')) {
@@ -82,7 +81,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
     | Readonly<{ b: 2 }>
     | Readonly<{ c: 3 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   if (hasKey(obj, 'a') && hasKey(obj, 'b')) {
@@ -101,7 +99,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
     | Readonly<{ a: 1; b: 1 }>
     | Readonly<{ b: 2 }>;
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const obj: R = { a: 0 } as R;
 
   expectType<
@@ -193,7 +190,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
         | Readonly<{ b: 2 }>
         | Record<string, number>;
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const o2 = { b: 2 } as O;
 
       if (hasOwnNaive(o2, 'a')) {
@@ -212,7 +208,6 @@ import { hasKey, type HasKeyReturnType } from './has-key.mjs';
         | Readonly<{ a: 1; b: 1 }>
         | Readonly<{ b: 2 }>;
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const o2 = { b: 2 } as O;
 
       if (hasOwnNaive(o2, 'a')) {

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

@@ -0,0 +1,143 @@
+/* eslint-disable functional/immutable-data */
+/* eslint-disable functional/no-class-inheritance */
+/* eslint-disable unicorn/error-message */
+import { isError as isErrorBySindreSorhus } from '@sindresorhus/is';
+import { expectType } from '../expect-type.mjs';
+
+describe('isError from @sindresorhus/is', () => {
+  test('should return true for native Error instances', () => {
+    assert.isTrue(isErrorBySindreSorhus(new Error()));
+
+    assert.isTrue(isErrorBySindreSorhus(new Error('test message')));
+  });
+
+  test('should return true for native Error subclasses', () => {
+    assert.isTrue(isErrorBySindreSorhus(new TypeError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new RangeError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new ReferenceError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new SyntaxError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new EvalError()));
+
+    assert.isTrue(isErrorBySindreSorhus(new URIError()));
+  });
+
+  test('should return true for custom Error subclasses', () => {
+    class CustomError extends Error {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'CustomError';
+      }
+    }
+
+    assert.isTrue(isErrorBySindreSorhus(new CustomError()));
+
+    assert.isTrue(
+      isErrorBySindreSorhus(new CustomError('custom error message')),
+    );
+  });
+
+  test('should return true for Error subclass with additional properties', () => {
+    class ExtendedError extends Error {
+      code: number;
+
+      constructor(message: string, code: number) {
+        super(message);
+
+        this.name = 'ExtendedError';
+
+        this.code = code;
+      }
+    }
+
+    assert.isTrue(
+      isErrorBySindreSorhus(new ExtendedError('error with code', 404)),
+    );
+  });
+
+  test('should return true for deeply nested Error subclass', () => {
+    class BaseCustomError extends Error {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'BaseCustomError';
+      }
+    }
+
+    class DerivedCustomError extends BaseCustomError {
+      constructor(message?: string) {
+        super(message);
+
+        this.name = 'DerivedCustomError';
+      }
+    }
+
+    assert.isTrue(isErrorBySindreSorhus(new DerivedCustomError()));
+  });
+
+  test('should return false for Error-like objects', () => {
+    const errorLikeObject = {
+      name: 'Error',
+      message: 'This is not a real error',
+      stack: 'fake stack trace',
+    };
+
+    assert.isFalse(isErrorBySindreSorhus(errorLikeObject));
+  });
+
+  test('should return false for non-Error values', () => {
+    assert.isFalse(isErrorBySindreSorhus(null));
+
+    assert.isFalse(isErrorBySindreSorhus(undefined));
+
+    assert.isFalse(isErrorBySindreSorhus(0));
+
+    assert.isFalse(isErrorBySindreSorhus(''));
+
+    assert.isFalse(isErrorBySindreSorhus('Error'));
+
+    assert.isFalse(isErrorBySindreSorhus(true));
+
+    assert.isFalse(isErrorBySindreSorhus({}));
+
+    assert.isFalse(isErrorBySindreSorhus([]));
+
+    assert.isFalse(isErrorBySindreSorhus(() => {}));
+  });
+
+  test('should act as a type guard', () => {
+    const value: Error | string = new Error('test');
+
+    if (isErrorBySindreSorhus(value)) {
+      expectType<typeof value, Error>('=');
+
+      expect(value.message).toBe('test');
+    }
+  });
+
+  test('should work with AggregateError', () => {
+    const aggregateError = new AggregateError(
+      [new Error('error 1'), new Error('error 2')],
+      'Multiple errors occurred',
+    );
+
+    assert.isTrue(isErrorBySindreSorhus(aggregateError));
+  });
+
+  test('should return false for errors created with Object.create', () => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const protoError = Object.create(Error.prototype);
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    protoError.message = 'proto error';
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    protoError.name = 'ProtoError';
+
+    assert.isFalse(isErrorBySindreSorhus(protoError));
+  });
+});

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

@@ -3,51 +3,51 @@ import { isNonEmptyString } from './is-non-empty-string.mjs';
 
 describe(isNonEmptyString, () => {
   test('should return true for non-empty strings', () => {
-    expect(isNonEmptyString('hello')).toBe(true);
+    assert.isTrue(isNonEmptyString('hello'));
 
-    expect(isNonEmptyString('a')).toBe(true);
+    assert.isTrue(isNonEmptyString('a'));
 
-    expect(isNonEmptyString(' ')).toBe(true); // Space is not empty
+    assert.isTrue(isNonEmptyString(' ')); // Space is not empty
 
-    expect(isNonEmptyString('  multiple spaces  ')).toBe(true);
+    assert.isTrue(isNonEmptyString('  multiple spaces  '));
 
-    expect(isNonEmptyString('123')).toBe(true);
+    assert.isTrue(isNonEmptyString('123'));
 
-    expect(isNonEmptyString('special!@#$%')).toBe(true);
+    assert.isTrue(isNonEmptyString('special!@#$%'));
   });
 
   test('should return false for empty string', () => {
-    expect(isNonEmptyString('')).toBe(false);
+    assert.isFalse(isNonEmptyString(''));
   });
 
   test('should return false for non-string values', () => {
-    expect(isNonEmptyString(null)).toBe(false);
+    assert.isFalse(isNonEmptyString(null));
 
-    expect(isNonEmptyString(undefined)).toBe(false);
+    assert.isFalse(isNonEmptyString(undefined));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(42)).toBe(false);
+    assert.isFalse(isNonEmptyString(42));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(0)).toBe(false);
+    assert.isFalse(isNonEmptyString(0));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(true)).toBe(false);
+    assert.isFalse(isNonEmptyString(true));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(false)).toBe(false);
+    assert.isFalse(isNonEmptyString(false));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString({})).toBe(false);
+    assert.isFalse(isNonEmptyString({}));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString([])).toBe(false);
+    assert.isFalse(isNonEmptyString([]));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(['string'])).toBe(false);
+    assert.isFalse(isNonEmptyString(['string']));
 
     // @ts-expect-error Testing non-string types
-    expect(isNonEmptyString(() => 'string')).toBe(false);
+    assert.isFalse(isNonEmptyString(() => 'string'));
   });
 
   test('should act as a type guard', () => {
@@ -93,22 +93,22 @@ describe(isNonEmptyString, () => {
   });
 
   test('should handle string edge cases', () => {
-    expect(isNonEmptyString('\n')).toBe(true); // Newline
+    assert.isTrue(isNonEmptyString('\n')); // Newline
 
-    expect(isNonEmptyString('\t')).toBe(true); // Tab
+    assert.isTrue(isNonEmptyString('\t')); // Tab
 
-    expect(isNonEmptyString('\r')).toBe(true); // Carriage return
+    assert.isTrue(isNonEmptyString('\r')); // Carriage return
 
-    expect(isNonEmptyString('\0')).toBe(true); // Null character
+    assert.isTrue(isNonEmptyString('\0')); // Null character
 
-    expect(isNonEmptyString('🎉')).toBe(true); // Emoji
+    assert.isTrue(isNonEmptyString('🎉')); // Emoji
 
-    expect(isNonEmptyString('你好')).toBe(true); // Unicode characters
+    assert.isTrue(isNonEmptyString('你好')); // Unicode characters
   });
 
   test('should not accept String objects', () => {
     // @ts-expect-error Testing non-string types
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNonEmptyString(new String('hello') as unknown)).toBe(false);
+    assert.isFalse(isNonEmptyString(new String('hello') as unknown));
   });
 });

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

@@ -3,73 +3,73 @@ import { isNonNullObject } from './is-non-null-object.mjs';
 
 describe(isNonNullObject, () => {
   test('should return true for plain objects', () => {
-    expect(isNonNullObject({})).toBe(true);
+    assert.isTrue(isNonNullObject({}));
 
-    expect(isNonNullObject({ a: 1, b: 'test' })).toBe(true);
+    assert.isTrue(isNonNullObject({ a: 1, b: 'test' }));
 
-    expect(isNonNullObject({ nested: { value: true } })).toBe(true);
+    assert.isTrue(isNonNullObject({ nested: { value: true } }));
   });
 
   test('should return true for arrays', () => {
-    expect(isNonNullObject([])).toBe(true);
+    assert.isTrue(isNonNullObject([]));
 
-    expect(isNonNullObject([1, 2, 3])).toBe(true);
+    assert.isTrue(isNonNullObject([1, 2, 3]));
 
-    expect(isNonNullObject(['a', 'b', 'c'])).toBe(true);
+    assert.isTrue(isNonNullObject(['a', 'b', 'c']));
   });
 
   test('should return true for functions', () => {
-    expect(isNonNullObject(() => {})).toBe(false);
+    assert.isFalse(isNonNullObject(() => {}));
 
-    expect(isNonNullObject(async () => {})).toBe(false);
+    assert.isFalse(isNonNullObject(async () => {}));
 
     // eslint-disable-next-line @typescript-eslint/no-extraneous-class
-    expect(isNonNullObject(class MyClass {})).toBe(false);
+    assert.isFalse(isNonNullObject(class MyClass {}));
   });
 
   test('should return true for built-in objects', () => {
-    expect(isNonNullObject(new Date())).toBe(true);
+    assert.isTrue(isNonNullObject(new Date()));
 
-    expect(isNonNullObject(/test/u)).toBe(true);
+    assert.isTrue(isNonNullObject(/test/u));
 
-    expect(isNonNullObject(/regex/u)).toBe(true);
+    assert.isTrue(isNonNullObject(/regex/u));
 
-    expect(isNonNullObject(new Map())).toBe(true);
+    assert.isTrue(isNonNullObject(new Map()));
 
-    expect(isNonNullObject(new Set())).toBe(true);
+    assert.isTrue(isNonNullObject(new Set()));
 
-    expect(isNonNullObject(new Error('test'))).toBe(true);
+    assert.isTrue(isNonNullObject(new Error('test')));
   });
 
   test('should return true for boxed primitives', () => {
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNonNullObject(new String('hello'))).toBe(true);
+    assert.isTrue(isNonNullObject(new String('hello')));
 
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNonNullObject(new Number(42))).toBe(true);
+    assert.isTrue(isNonNullObject(new Number(42)));
 
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNonNullObject(new Boolean(true))).toBe(true);
+    assert.isTrue(isNonNullObject(new Boolean(true)));
   });
 
   test('should return false for null', () => {
-    expect(isNonNullObject(null)).toBe(false);
+    assert.isFalse(isNonNullObject(null));
   });
 
   test('should return false for primitive values', () => {
-    expect(isNonNullObject(undefined)).toBe(false);
+    assert.isFalse(isNonNullObject(undefined));
 
-    expect(isNonNullObject('string')).toBe(false);
+    assert.isFalse(isNonNullObject('string'));
 
-    expect(isNonNullObject(42)).toBe(false);
+    assert.isFalse(isNonNullObject(42));
 
-    expect(isNonNullObject(true)).toBe(false);
+    assert.isFalse(isNonNullObject(true));
 
-    expect(isNonNullObject(false)).toBe(false);
+    assert.isFalse(isNonNullObject(false));
 
-    expect(isNonNullObject(Symbol('test'))).toBe(false);
+    assert.isFalse(isNonNullObject(Symbol('test')));
 
-    expect(isNonNullObject(123n)).toBe(false);
+    assert.isFalse(isNonNullObject(123n));
   });
 
   test('should act as a type guard', () => {

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

@@ -4,9 +4,9 @@ import { isSymbol } from './is-type.mjs';
 
 describe(isPrimitive, () => {
   test('should return true for string primitives', () => {
-    expect(isPrimitive('hello')).toBe(true);
+    assert.isTrue(isPrimitive('hello'));
 
-    expect(isPrimitive('')).toBe(true);
+    assert.isTrue(isPrimitive(''));
 
     const value: unknown = 'test';
 
@@ -19,77 +19,77 @@ describe(isPrimitive, () => {
   });
 
   test('should return true for number primitives', () => {
-    expect(isPrimitive(42)).toBe(true);
+    assert.isTrue(isPrimitive(42));
 
-    expect(isPrimitive(0)).toBe(true);
+    assert.isTrue(isPrimitive(0));
 
-    expect(isPrimitive(-3.14)).toBe(true);
+    assert.isTrue(isPrimitive(-3.14));
 
-    expect(isPrimitive(Number.NaN)).toBe(true);
+    assert.isTrue(isPrimitive(Number.NaN));
 
-    expect(isPrimitive(Number.POSITIVE_INFINITY)).toBe(true);
+    assert.isTrue(isPrimitive(Number.POSITIVE_INFINITY));
   });
 
   test('should return true for boolean primitives', () => {
-    expect(isPrimitive(true)).toBe(true);
+    assert.isTrue(isPrimitive(true));
 
-    expect(isPrimitive(false)).toBe(true);
+    assert.isTrue(isPrimitive(false));
   });
 
   test('should return true for symbol primitives', () => {
-    expect(isPrimitive(Symbol('test'))).toBe(true);
+    assert.isTrue(isPrimitive(Symbol('test')));
 
-    expect(isPrimitive(Symbol.iterator)).toBe(true);
+    assert.isTrue(isPrimitive(Symbol.iterator));
   });
 
   test('should return true for bigint primitives', () => {
-    expect(isPrimitive(123n)).toBe(true);
+    assert.isTrue(isPrimitive(123n));
 
-    expect(isPrimitive(0n)).toBe(true);
+    assert.isTrue(isPrimitive(0n));
 
-    expect(isPrimitive(-123n)).toBe(true);
+    assert.isTrue(isPrimitive(-123n));
   });
 
   test('should return true for null', () => {
     // Note: null is considered an object by typeof, so isPrimitive returns false
-    expect(isPrimitive(null)).toBe(true);
+    assert.isTrue(isPrimitive(null));
   });
 
   test('should return true for undefined', () => {
-    expect(isPrimitive(undefined)).toBe(true);
+    assert.isTrue(isPrimitive(undefined));
   });
 
   test('should return false for objects', () => {
-    expect(isPrimitive({})).toBe(false);
+    assert.isFalse(isPrimitive({}));
 
-    expect(isPrimitive({ a: 1 })).toBe(false);
+    assert.isFalse(isPrimitive({ a: 1 }));
 
-    expect(isPrimitive(new Date())).toBe(false);
+    assert.isFalse(isPrimitive(new Date()));
   });
 
   test('should return false for arrays', () => {
-    expect(isPrimitive([])).toBe(false);
+    assert.isFalse(isPrimitive([]));
 
-    expect(isPrimitive([1, 2, 3])).toBe(false);
+    assert.isFalse(isPrimitive([1, 2, 3]));
   });
 
   test('should return false for functions', () => {
-    expect(isPrimitive(() => {})).toBe(false);
+    assert.isFalse(isPrimitive(() => {}));
 
-    expect(isPrimitive(() => {})).toBe(false);
+    assert.isFalse(isPrimitive(() => {}));
 
-    expect(isPrimitive(async () => {})).toBe(false);
+    assert.isFalse(isPrimitive(async () => {}));
   });
 
   test('should return false for boxed primitives', () => {
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isPrimitive(new String('hello'))).toBe(false);
+    assert.isFalse(isPrimitive(new String('hello')));
 
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isPrimitive(new Number(42))).toBe(false);
+    assert.isFalse(isPrimitive(new Number(42)));
 
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isPrimitive(new Boolean(true))).toBe(false);
+    assert.isFalse(isPrimitive(new Boolean(true)));
   });
 
   test('should narrow types correctly in conditional', () => {
@@ -120,7 +120,7 @@ describe(isPrimitive, () => {
 
     expect(primitives[4]).toBeUndefined();
 
-    expect(isSymbol(primitives[5])).toBe(true);
+    assert.isTrue(isSymbol(primitives[5]));
 
     assert.deepStrictEqual(nonPrimitives, [{}, []]);
   });

package/src/guard/is-record.mts

@@ -38,8 +38,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
  * @see {@link isNonNullObject} - For checking any object type (includes arrays)
  * @see {@link hasKey} - For checking if a record has specific keys
  */
-export const isRecord = (u: unknown): u is UnknownRecord =>
-  isNonNullObject(u) && !Array.isArray(u);
+export const isRecord = (u: unknown): u is UnknownRecord => isNonNullObject(u);
 
 /**
  * Type guard that checks if a value is a mutable record (an object with mutable string keys).