@brillout/json-serializer 0.5.19 → 0.5.21

package/dist/{esm/stringify.d.ts → stringify.d.ts}

@@ -1,6 +1,6 @@
 export { stringify };
 export { isJsonSerializerError };
-import { type Iterable, type Path } from './utils/replacerWithPath.js';
+import { type Iterable, type Path } from './utils/addPathToReplacer.js';
 declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, }?: {
     forbidReactElements?: boolean;
     space?: number;

package/dist/{esm/stringify.js → stringify.js}

@@ -4,7 +4,7 @@ import { types } from './types.js';
 import { isReactElement } from './utils/isReactElement.js';
 import { isCallable } from './utils/isCallable.js';
 import { isObject } from './utils/isObject.js';
-import { replacerWithPath } from './utils/replacerWithPath.js';
+import { addPathToReplacer } from './utils/addPathToReplacer.js';
 function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, } = {}) {
     // The only error `JSON.stringify()` can throw is `TypeError "cyclic object value"`.
     // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#exceptions
@@ -12,13 +12,13 @@ function stringify(value, { forbidReactElements, space, valueName, sortObjectKey
     //    - Cyclic references
     //    - Functions
     //    - React elements
-    const serializer = (val) => JSON.stringify(val, replacerWithPath(replacer), space);
+    const serializer = (val) => JSON.stringify(val, addPathToReplacer(replacer), space);
     return serializer(value);
-    function replacer(key, valueAfterJSON, path) {
+    function replacer(key, _valueAfterNativeJsonStringify, path) {
         const valueOriginal = this[key];
         let value = valueOriginal;
         {
-            const ret = replacerUserProvided?.call(this, key, valueAfterJSON, serializer);
+            const ret = replacerUserProvided?.call(this, key, valueOriginal, serializer);
             if (ret) {
                 value = ret.replacement;
                 if (ret.resolved !== false)

package/dist/utils/addPathToReplacer.d.ts

@@ -0,0 +1,12 @@
+export { addPathToReplacer };
+export type { Iterable };
+export type { Path };
+type Path = (string | number)[];
+type Iterable = Record<string, unknown>;
+type Replacer = (this: Iterable, key: string, valueAfterNativeJsonStringify: unknown, path: Path) => unknown;
+/**
+ * The `replacer()` callback of `JSON.stringify()` doesn't provide the path of the object property that is being stringified.
+ *
+ * `addPathToReplacer(replacer)` adds the property path to the `replacer()` callback as last parameter.
+ */
+declare function addPathToReplacer(replacer: Replacer): (this: Iterable, key: string, valueAfterNativeJsonStringify: unknown) => unknown;

package/dist/utils/addPathToReplacer.js

@@ -0,0 +1,24 @@
+export { addPathToReplacer };
+/**
+ * The `replacer()` callback of `JSON.stringify()` doesn't provide the path of the object property that is being stringified.
+ *
+ * `addPathToReplacer(replacer)` adds the property path to the `replacer()` callback as last parameter.
+ */
+function addPathToReplacer(replacer) {
+    const pathMap = new WeakMap();
+    return replacerForJsonStringify;
+    function replacerForJsonStringify(key, valueAfterNativeJsonStringify) {
+        const pathPrevious = pathMap.get(this) ?? [];
+        const path = [...pathPrevious];
+        if (key !== '') {
+            const pathEntry = !Array.isArray(this) ? key : parseInt(key, 10);
+            path.push(pathEntry);
+        }
+        if (isIterable(valueAfterNativeJsonStringify))
+            pathMap.set(valueAfterNativeJsonStringify, path);
+        return replacer.call(this, key, valueAfterNativeJsonStringify, path);
+    }
+}
+function isIterable(value) {
+    return value === Object(value);
+}

package/examples.js

@@ -0,0 +1,44 @@
+/**
+ * Run all examples in the examples/ directory
+ */
+
+import { readdir } from 'fs/promises'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+runAllExamples()
+
+async function runAllExamples() {
+  console.log('🎯 Running all json-serializer examples...\n')
+
+  // Read all .js files from examples directory
+  const files = await readdir(join(__dirname, 'examples'))
+  const examples = files.filter((file) => file.endsWith('.js')).sort()
+
+  let successCount = 0
+  let failureCount = 0
+
+  for (const example of examples) {
+    try {
+      console.log(`🚀 Running ${example}...`)
+      await import(`./examples/${example}`)
+      console.log(`✅ ${example} completed successfully\n`)
+      successCount++
+    } catch (error) {
+      console.log(`❌ ${example} failed: ${error.message}\n`)
+      failureCount++
+    }
+  }
+
+  console.log('='.repeat(50))
+  console.log(`✅ Successful: ${successCount}`)
+  if (failureCount > 0) {
+    console.log(`❌ Failed: ${failureCount}`)
+    console.log(`📁 Total: ${examples.length}`)
+    process.exit(1)
+  } else {
+    console.log('🎉 All examples completed successfully!')
+  }
+}

package/package.json

@@ -1,22 +1,20 @@
 {
   "name": "@brillout/json-serializer",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "Same as JSON but with added support for `Date`, `undefined`, `Map`, `Set`, and more.",
   "main": "./index.mjs",
   "type": "module",
   "exports": {
     ".": "./index.mjs",
     "./parse": {
-      "import": "./dist/esm/parse.js",
-      "require": "./dist/cjs/parse.js",
-      "types": "./dist/esm/parse.d.ts",
-      "default": "./dist/esm/parse.js"
+      "import": "./dist/parse.js",
+      "types": "./dist/parse.d.ts",
+      "default": "./dist/parse.js"
     },
     "./stringify": {
-      "import": "./dist/esm/stringify.js",
-      "require": "./dist/cjs/stringify.js",
-      "types": "./dist/esm/stringify.d.ts",
-      "default": "./dist/esm/stringify.js"
+      "import": "./dist/stringify.js",
+      "types": "./dist/stringify.d.ts",
+      "default": "./dist/stringify.js"
     }
   },
   "devDependencies": {
@@ -45,15 +43,11 @@
   },
   "scripts": {
     "========= Dev": "",
-    "dev": "pnpm run tsc:watch:cjs",
+    "dev": "tsc --watch",
     "========= Build": "",
-    "build": "rm -rf dist/ && pnpm run tsc:esm && pnpm run tsc:cjs",
-    "tsc:esm": "tsc",
-    "tsc:cjs": "tsc --project ./tsconfig.cjs.json",
-    "tsc:watch:esm": "tsc --incremental --watch",
-    "tsc:watch:cjs": "tsc --incremental --watch --project ./tsconfig.cjs.json",
+    "build": "rm -rf dist/ && tsc",
     "========= Test": "",
-    "test": "vitest",
+    "test": "node ./examples && vitest run",
     "========= Build readme.md": "",
     "docs": "mdocs",
     "========= Formatting": "",

package/parse.d.ts

@@ -1,2 +1,2 @@
 // Help TS's resolver until it supports `package.json#exports`
-export * from './dist/esm/parse'
+export * from './dist/parse'

package/parse.js

@@ -1,11 +1,3 @@
-// Some tools don't support `package.json#exports`, such as:
-//  - Nuxt v2
-//  - Expo/Metro
-//  - ESLint
-// prettier-ignore
-// biome-ignore format:
-'use strict';
-// prettier-ignore
-// biome-ignore format:
-exports.parse = require('./dist/cjs/parse.js').parse;
-exports.parseTransform = require('./dist/cjs/parse.js').parseTransform
+// Some tools still need this as of January 2025
+export * from './dist/parse.js'
+export { default } from './dist/parse.js'

package/readme.md

@@ -91,10 +91,10 @@ JSON is a good serializer for JavaScript values but
 is lacking some JavaScript types such as `Date`:
 
 ~~~js
-const assert = require('assert')
+import assert from 'assert'
 
 let obj = {
-  time: new Date('2042-01-01')
+  time: new Date('2042-01-01'),
 }
 
 // JSON converts dates to strings
@@ -107,12 +107,12 @@ assert(obj.time === '2042-01-01T00:00:00.000Z')
 Whereas with `@brillout/json-serializer`:
 
 ~~~js
-const assert = require('assert')
-const { parse } = require('@brillout/json-serializer/parse')
-const { stringify } = require('@brillout/json-serializer/stringify')
+import { parse } from '@brillout/json-serializer/parse'
+import { stringify } from '@brillout/json-serializer/stringify'
+import assert from 'assert'
 
 let obj = {
-  time: new Date('2042-01-01')
+  time: new Date('2042-01-01'),
 }
 
 // `@brillout/json-serializer` preserves Date
@@ -137,12 +137,12 @@ assert(obj.time.getTime() === new Date('2042-01-01').getTime())
 
 ~~~js
 // npm install @brillout/json-serializer
-const { parse } = require('@brillout/json-serializer/parse')
-const { stringify } = require('@brillout/json-serializer/stringify')
+import { parse } from '@brillout/json-serializer/parse'
+import { stringify } from '@brillout/json-serializer/stringify'
 
 const obj = {
   hello: 'from the future',
-  time: new Date('2042-01-01')
+  time: new Date('2042-01-01'),
 }
 
 // Serialize with @brillout/json-serializer
@@ -161,17 +161,16 @@ Example exposing all differences between JSON and `@brillout/json-serializer`.
 ~~~js
 // /examples/json-serializer.js
 
-const assert = require('assert')
-
-const { parse } = require('@brillout/json-serializer/parse')
-const { stringify } = require('@brillout/json-serializer/stringify')
+import { parse } from '@brillout/json-serializer/parse'
+import { stringify } from '@brillout/json-serializer/stringify'
+import assert from 'assert'
 
 const obj = {
   date: new Date(),
   undefined: undefined,
   NaN: NaN,
   Infinity: Infinity,
-  regexp: /^\d+$/g
+  regexp: /^\d+$/g,
 }
 
 // All of `obj` can be serialized with @brillout/json-serializer
@@ -217,7 +216,7 @@ Let's see how `@brillout/json-serializer` serializes an object:
 ~~~js
 // /examples/inspect.js
 
-const { stringify } = require('@brillout/json-serializer/stringify')
+import { stringify } from '@brillout/json-serializer/stringify'
 
 const obj = {
   date: new Date(),
@@ -225,7 +224,7 @@ const obj = {
   collision: '!undefined',
   NaN: NaN,
   Infinity: Infinity,
-  regexp: /^\d+$/g
+  regexp: /^\d+$/g,
 }
 
 console.log(stringify(obj, undefined, 2))

package/stringify.d.ts

@@ -1,2 +1,2 @@
 // Help TS's resolver until it supports `package.json#exports`
-export * from './dist/esm/stringify'
+export * from './dist/stringify'

package/stringify.js

@@ -1,10 +1,3 @@
-// Some tools don't support `package.json#exports`, such as:
-//  - Nuxt v2
-//  - Expo/Metro
-//  - ESLint
-// prettier-ignore
-// biome-ignore format:
-'use strict';
-// prettier-ignore
-// biome-ignore format:
-exports.stringify = require('./dist/cjs/stringify.js').stringify;
+// Some tools still need this as of January 2025
+export * from './dist/stringify.js'
+export { default } from './dist/stringify.js'

package/dist/cjs/parse.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = parse;
-exports.parseTransform = parseTransform;
-const types_js_1 = require("./types.js");
-function parse(str, options = {}) {
-    // We don't use the reviver option in `JSON.parse(str, reviver)` because it doesn't support `undefined` values
-    const value = JSON.parse(str);
-    return parseTransform(value, options);
-}
-function parseTransform(value, options = {}) {
-    if (typeof value === 'string') {
-        return reviver(value, options);
-    }
-    if (
-    // Also matches arrays
-    typeof value === 'object' &&
-        value !== null) {
-        Object.entries(value).forEach(([key, val]) => {
-            ;
-            value[key] = parseTransform(val, options);
-        });
-    }
-    return value;
-}
-function reviver(value, options) {
-    var _a;
-    const parser = (str) => parse(str, options);
-    {
-        const res = (_a = options.reviver) === null || _a === void 0 ? void 0 : _a.call(options, 
-        // TO-DO/eventually: provide key if some user needs it
-        undefined, value, parser);
-        if (res) {
-            if (typeof res.replacement !== 'string') {
-                return res.replacement;
-            }
-            else {
-                value = res.replacement;
-                if (res.resolved)
-                    return value;
-            }
-        }
-    }
-    for (const { match, deserialize } of types_js_1.types) {
-        if (match(value)) {
-            return deserialize(value, parser);
-        }
-    }
-    return value;
-}

package/dist/cjs/stringify.d.ts

@@ -1,21 +0,0 @@
-export { stringify };
-export { isJsonSerializerError };
-import { type Iterable, type Path } from './utils/replacerWithPath.js';
-declare function stringify(value: unknown, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, }?: {
-    forbidReactElements?: boolean;
-    space?: number;
-    valueName?: string;
-    sortObjectKeys?: boolean;
-    replacer?: (this: Iterable, key: string, value: unknown, serializer: (value: unknown) => string) => {
-        replacement: unknown;
-        resolved?: boolean;
-    } | undefined;
-}): string;
-type ErrAddendum = {
-    messageCore: `cannot serialize ${string} because it's a function` | `cannot serialize ${string} because it's a React element`;
-    value: unknown;
-    path: Path;
-    pathString: string;
-    subjectName: string;
-};
-declare function isJsonSerializerError(thing: unknown): thing is Error & ErrAddendum;

package/dist/cjs/stringify.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringify = stringify;
-exports.isJsonSerializerError = isJsonSerializerError;
-const types_js_1 = require("./types.js");
-const isReactElement_js_1 = require("./utils/isReactElement.js");
-const isCallable_js_1 = require("./utils/isCallable.js");
-const isObject_js_1 = require("./utils/isObject.js");
-const replacerWithPath_js_1 = require("./utils/replacerWithPath.js");
-function stringify(value, { forbidReactElements, space, valueName, sortObjectKeys, replacer: replacerUserProvided, } = {}) {
-    // The only error `JSON.stringify()` can throw is `TypeError "cyclic object value"`.
-    // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#exceptions
-    // - This means we have total of 3 possible errors while serializing:
-    //    - Cyclic references
-    //    - Functions
-    //    - React elements
-    const serializer = (val) => JSON.stringify(val, (0, replacerWithPath_js_1.replacerWithPath)(replacer), space);
-    return serializer(value);
-    function replacer(key, valueAfterJSON, path) {
-        const valueOriginal = this[key];
-        let value = valueOriginal;
-        {
-            const ret = replacerUserProvided === null || replacerUserProvided === void 0 ? void 0 : replacerUserProvided.call(this, key, valueAfterJSON, serializer);
-            if (ret) {
-                value = ret.replacement;
-                if (ret.resolved !== false)
-                    return value;
-            }
-        }
-        if (forbidReactElements && (0, isReactElement_js_1.isReactElement)(value)) {
-            throw genErr({
-                value,
-                valueType: 'React element',
-                path,
-                rootValueName: valueName,
-            });
-        }
-        if ((0, isCallable_js_1.isCallable)(value)) {
-            const functionName = value.name;
-            throw genErr({
-                value,
-                valueType: 'function',
-                path,
-                rootValueName: valueName,
-                problematicValueName: path.length === 0 ? functionName : undefined,
-            });
-        }
-        for (const { is, serialize } of types_js_1.types.slice().reverse()) {
-            if (is(value)) {
-                //@ts-ignore
-                return serialize(value, serializer);
-            }
-        }
-        if (sortObjectKeys && (0, isObject_js_1.isObject)(value)) {
-            const copy = {};
-            Object.keys(value)
-                .sort()
-                .forEach((key) => {
-                copy[key] = value[key];
-            });
-            value = copy;
-        }
-        return value;
-    }
-}
-function genErr({ value, valueType, path, rootValueName, problematicValueName, }) {
-    const subjectName = getSubjectName({ path, rootValueName, problematicValueName });
-    const messageCore = `cannot serialize ${subjectName} because it's a ${valueType}`;
-    const err = new Error(`[@brillout/json-serializer](https://github.com/brillout/json-serializer) ${messageCore}.`);
-    const pathString = getPathString(path, true);
-    const errAddendum = {
-        [stamp]: true,
-        messageCore,
-        value,
-        path,
-        pathString,
-        subjectName,
-    };
-    Object.assign(err, errAddendum);
-    return err;
-}
-const stamp = '_isJsonSerializerError';
-function isJsonSerializerError(thing) {
-    return (0, isObject_js_1.isObject)(thing) && thing[stamp] === true;
-}
-function getSubjectName({ path, rootValueName, problematicValueName, }) {
-    const pathString = getPathString(path, !rootValueName);
-    let subjectName;
-    if (!pathString) {
-        subjectName = rootValueName || problematicValueName || 'value';
-    }
-    else {
-        if (problematicValueName) {
-            subjectName = problematicValueName + ' at ';
-        }
-        else {
-            subjectName = '';
-        }
-        subjectName = subjectName + (rootValueName || '') + pathString;
-    }
-    return subjectName;
-}
-function getPathString(path, canBeFirstKey) {
-    const pathString = path
-        .map((key, i) => {
-        if (typeof key === 'number') {
-            return `[${key}]`;
-        }
-        if (i === 0 && canBeFirstKey && isKeyDotNotationCompatible(key)) {
-            return key;
-        }
-        return getPropAccessNotation(key);
-    })
-        .join('');
-    return pathString;
-}
-function getPropAccessNotation(key) {
-    return typeof key === 'string' && isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
-}
-function isKeyDotNotationCompatible(key) {
-    return /^[a-z0-9\$_]+$/i.test(key);
-}

package/dist/cjs/types.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.types = void 0;
-const types = [
-    ts({
-        is: (val) => val === undefined,
-        match: (str) => str === '!undefined',
-        serialize: () => '!undefined',
-        deserialize: () => undefined,
-    }),
-    ts({
-        is: (val) => val === Infinity,
-        match: (str) => str === '!Infinity',
-        serialize: () => '!Infinity',
-        deserialize: () => Infinity,
-    }),
-    ts({
-        is: (val) => val === -Infinity,
-        match: (str) => str === '!-Infinity',
-        serialize: () => '!-Infinity',
-        deserialize: () => -Infinity,
-    }),
-    ts({
-        is: (val) => typeof val === 'number' && isNaN(val),
-        match: (str) => str === '!NaN',
-        serialize: () => '!NaN',
-        deserialize: () => NaN,
-    }),
-    ts({
-        is: (val) => val instanceof Date,
-        match: (str) => str.startsWith('!Date:'),
-        serialize: (val) => '!Date:' + val.toISOString(),
-        deserialize: (str) => new Date(str.slice('!Date:'.length)),
-    }),
-    ts({
-        is: (val) => typeof val === 'bigint',
-        match: (str) => str.startsWith('!BigInt:'),
-        serialize: (val) => '!BigInt:' + val.toString(),
-        deserialize: (str) => {
-            if (typeof BigInt === 'undefined') {
-                throw new Error('Your JavaScript environement does not support BigInt. Consider adding a polyfill.');
-            }
-            return BigInt(str.slice('!BigInt:'.length));
-        },
-    }),
-    ts({
-        is: (val) => val instanceof RegExp,
-        match: (str) => str.startsWith('!RegExp:'),
-        serialize: (val) => '!RegExp:' + val.toString(),
-        deserialize: (str) => {
-            str = str.slice('!RegExp:'.length);
-            // const args: string[] = str.match(/\/(.*?)\/([gimy])?$/)!
-            const args = str.match(/\/(.*)\/(.*)?/);
-            const pattern = args[1];
-            const flags = args[2];
-            return new RegExp(pattern, flags);
-        },
-    }),
-    ts({
-        is: (val) => val instanceof Map,
-        match: (str) => str.startsWith('!Map:'),
-        serialize: (val, serializer) => '!Map:' + serializer(Array.from(val.entries())),
-        deserialize: (str, parser) => new Map(parser(str.slice('!Map:'.length))),
-    }),
-    ts({
-        is: (val) => val instanceof Set,
-        match: (str) => str.startsWith('!Set:'),
-        serialize: (val, serializer) => '!Set:' + serializer(Array.from(val.values())),
-        deserialize: (str, parser) => new Set(parser(str.slice('!Set:'.length))),
-    }),
-    // Avoid collisions with the special strings defined above
-    ts({
-        is: (val) => typeof val === 'string' && val.startsWith('!'),
-        match: (str) => str.startsWith('!'),
-        serialize: (val) => '!' + val,
-        deserialize: (str) => str.slice(1),
-    }),
-];
-exports.types = types;
-// Type check
-function ts(t) {
-    return t;
-}

package/dist/cjs/utils/isCallable.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCallable = isCallable;
-function isCallable(thing) {
-    return thing instanceof Function || typeof thing === 'function';
-}

package/dist/cjs/utils/isObject.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObject = isObject;
-function isObject(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    if (Array.isArray(value)) {
-        return false;
-    }
-    return true;
-}

package/dist/cjs/utils/isReactElement.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isReactElement = isReactElement;
-function isReactElement(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        String(value['$$typeof']) === 'Symbol(react.element)');
-}

package/dist/cjs/utils/replacerWithPath.d.ts

@@ -1,7 +0,0 @@
-export { replacerWithPath };
-export type { Iterable };
-export type { Path };
-type Path = (string | number)[];
-type Iterable = Record<string, unknown>;
-type Replacer = (this: Iterable, key: string, value: unknown, path: Path) => unknown;
-declare function replacerWithPath(replacer: Replacer): (this: Iterable, key: string, value: unknown) => unknown;

package/dist/cjs/utils/replacerWithPath.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replacerWithPath = replacerWithPath;
-function replacerWithPath(replacer) {
-    const pathMap = new WeakMap();
-    return function (key, value) {
-        var _a;
-        const pathPrevious = (_a = pathMap.get(this)) !== null && _a !== void 0 ? _a : [];
-        const path = [...pathPrevious];
-        if (key !== '') {
-            const pathEntry = !Array.isArray(this) ? key : parseInt(key, 10);
-            path.push(pathEntry);
-        }
-        if (isIterable(value))
-            pathMap.set(value, path);
-        return replacer.call(this, key, value, path);
-    };
-}
-function isIterable(value) {
-    return value === Object(value);
-}

package/dist/esm/parse.d.ts

@@ -1,10 +0,0 @@
-export { parse };
-export { parseTransform };
-type Options = {
-    reviver?: (key: undefined | string, value: string, parser: (str: string) => unknown) => {
-        replacement: unknown;
-        resolved?: boolean;
-    } | undefined;
-};
-declare function parse(str: string, options?: Options): unknown;
-declare function parseTransform(value: unknown, options?: Options): unknown;

package/dist/esm/types.d.ts

@@ -1,8 +0,0 @@
-export { types };
-declare const types: readonly Type<any, any>[];
-type Type<ValueType, IntermediateType> = {
-    is: (val: unknown) => asserts val is ValueType;
-    match: (str: string) => boolean;
-    serialize: (val: ValueType, serializer: (val: IntermediateType) => string) => string;
-    deserialize: (str: string, parser: (str: string) => IntermediateType) => ValueType;
-};

package/dist/esm/utils/isCallable.d.ts

@@ -1 +0,0 @@
-export declare function isCallable<T extends (...args: unknown[]) => unknown>(thing: T | unknown): thing is T;

package/dist/esm/utils/isKeyDotNotationCompatible.js

@@ -1 +0,0 @@
-"use strict";

package/dist/esm/utils/isObject.d.ts

@@ -1,3 +0,0 @@
-export { isObject };
-type Object = Record<string, unknown>;
-declare function isObject(value: unknown): value is Object;

package/dist/esm/utils/isReactElement.d.ts

@@ -1 +0,0 @@
-export declare function isReactElement(value: unknown): boolean;

package/dist/esm/utils/replacerWithPath.d.ts

@@ -1,7 +0,0 @@
-export { replacerWithPath };
-export type { Iterable };
-export type { Path };
-type Path = (string | number)[];
-type Iterable = Record<string, unknown>;
-type Replacer = (this: Iterable, key: string, value: unknown, path: Path) => unknown;
-declare function replacerWithPath(replacer: Replacer): (this: Iterable, key: string, value: unknown) => unknown;

package/dist/esm/utils/replacerWithPath.js

@@ -1,18 +0,0 @@
-export { replacerWithPath };
-function replacerWithPath(replacer) {
-    const pathMap = new WeakMap();
-    return function (key, value) {
-        const pathPrevious = pathMap.get(this) ?? [];
-        const path = [...pathPrevious];
-        if (key !== '') {
-            const pathEntry = !Array.isArray(this) ? key : parseInt(key, 10);
-            path.push(pathEntry);
-        }
-        if (isIterable(value))
-            pathMap.set(value, path);
-        return replacer.call(this, key, value, path);
-    };
-}
-function isIterable(value) {
-    return value === Object(value);
-}