@gibs/common 1.13.1 → 1.17.0

package/dist/url.js

@@ -0,0 +1,281 @@
+/**
+ * Request addresses, built and read with plain string work.
+ *
+ * WHY THIS EXISTS: React Native 0.77 installs its own `URL` and
+ * `URLSearchParams` (react-native/Libraries/Blob/URL.js), and both are partial.
+ * `new URL(x).protocol`, `.host`, `.pathname` and `.search` throw "not
+ * implemented". `searchParams` is always a new, empty list, so a reader of it
+ * silently sees no parameters. `URLSearchParams` can only append and
+ * serialize: `get`, `set`, `has` and `delete` throw, and a string passed to
+ * its constructor is ignored. A package that uses either class needs a
+ * polyfill in a wallet. These functions need nothing from the runtime but
+ * `encodeURIComponent` and `decodeURIComponent`.
+ *
+ * Their output matches what the WHATWG classes produce for the addresses the
+ * Gibs packages build: a lowercase `http:` or `https:` origin with a plain
+ * path. A query is encoded exactly as `URLSearchParams` encodes it, as
+ * `application/x-www-form-urlencoded`: a space becomes `+`, and only letters,
+ * digits and `*-._` stay as they are. They do not normalize the address
+ * itself: an uppercase host or a `..` path segment passes through as written.
+ */
+/** A surrogate pair, or a lone surrogate half. */
+const surrogates = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g;
+/** The characters `encodeURIComponent` keeps that a form encoder escapes. */
+const formEscapedCharacters = /[!'()~]/g;
+/** A run of percent-encoded bytes. */
+const percentEncodedRun = /(?:%[0-9A-Fa-f]{2})+/g;
+/** The port each special scheme leaves out of its host. */
+const defaultPorts = Object.freeze({
+    http: '80',
+    https: '443',
+    ws: '80',
+    wss: '443',
+    ftp: '21',
+});
+/**
+ * Replaces each lone surrogate half with U+FFFD, as the WHATWG classes do
+ * before they encode. `encodeURIComponent` would throw on one instead.
+ *
+ * @param text - any string
+ * @returns the string, well formed
+ */
+const toWellFormed = (text) => text.replace(surrogates, (match) => (match.length === 2 ? match : '�'));
+/**
+ * Percent-encodes one character as two uppercase hex digits.
+ *
+ * @param character - a single ASCII character
+ * @returns the character as `%XX`
+ */
+const percentEncodeCharacter = (character) => `%${character.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
+/**
+ * Encodes a query name or value exactly as `URLSearchParams.toString` does.
+ *
+ * @param text - the raw name or value
+ * @returns the encoded text
+ */
+export const encodeQueryComponent = (text) => encodeURIComponent(toWellFormed(text))
+    .replace(formEscapedCharacters, percentEncodeCharacter)
+    .replace(/%20/g, '+');
+/**
+ * Counts the continuation bytes a UTF-8 lead byte announces, and the bounds
+ * the first of them must fall in. The bounds reject overlong forms and
+ * surrogates, as the WHATWG decoder does.
+ *
+ * @param lead - the first byte of a sequence
+ * @returns the count, the lead byte's own bits, and the first continuation byte's bounds; null for a byte that cannot start one
+ */
+const utf8Lead = (lead) => {
+    if (lead >= 0xc2 && lead <= 0xdf)
+        return { count: 1, bits: lead & 0x1f, lower: 0x80, upper: 0xbf };
+    if (lead === 0xe0)
+        return { count: 2, bits: lead & 0x0f, lower: 0xa0, upper: 0xbf };
+    if (lead === 0xed)
+        return { count: 2, bits: lead & 0x0f, lower: 0x80, upper: 0x9f };
+    if (lead >= 0xe1 && lead <= 0xef)
+        return { count: 2, bits: lead & 0x0f, lower: 0x80, upper: 0xbf };
+    if (lead === 0xf0)
+        return { count: 3, bits: lead & 0x07, lower: 0x90, upper: 0xbf };
+    if (lead === 0xf4)
+        return { count: 3, bits: lead & 0x07, lower: 0x80, upper: 0x8f };
+    if (lead >= 0xf1 && lead <= 0xf3)
+        return { count: 3, bits: lead & 0x07, lower: 0x80, upper: 0xbf };
+    return null;
+};
+/**
+ * Decodes UTF-8 bytes as the WHATWG decoder does: each malformed part becomes
+ * one U+FFFD, and a byte that ends a malformed part is read again as the
+ * start of the next. Only reached when `decodeURIComponent` refuses a run.
+ *
+ * @param bytes - the bytes
+ * @returns the decoded text
+ */
+const decodeUtf8Leniently = (bytes) => {
+    const decode = (index, decoded) => {
+        if (index >= bytes.length)
+            return decoded;
+        const lead = bytes[index];
+        if (lead < 0x80)
+            return decode(index + 1, decoded + String.fromCharCode(lead));
+        const shape = utf8Lead(lead);
+        if (shape === null)
+            return decode(index + 1, `${decoded}�`);
+        const readContinuation = (offset, codePoint) => {
+            if (offset > shape.count)
+                return { codePoint, length: offset };
+            const byte = bytes[index + offset];
+            const lower = offset === 1 ? shape.lower : 0x80;
+            const upper = offset === 1 ? shape.upper : 0xbf;
+            if (byte === undefined || byte < lower || byte > upper)
+                return { codePoint: -1, length: offset };
+            return readContinuation(offset + 1, (codePoint << 6) | (byte & 0x3f));
+        };
+        const { codePoint, length } = readContinuation(1, shape.bits);
+        if (codePoint === -1)
+            return decode(index + length, `${decoded}�`);
+        return decode(index + length, decoded + String.fromCodePoint(codePoint));
+    };
+    return decode(0, '');
+};
+/**
+ * Decodes one run of `%XX` bytes.
+ *
+ * @param run - consecutive `%XX` sequences
+ * @returns the text they encode
+ */
+const decodePercentRun = (run) => {
+    try {
+        return decodeURIComponent(run);
+    }
+    catch {
+        return decodeUtf8Leniently(run.slice(1).split('%').map((pair) => Number.parseInt(pair, 16)));
+    }
+};
+/**
+ * Decodes a query name or value as the WHATWG URL standard says
+ * `URLSearchParams` must: `+` is a space, a valid `%XX` is a byte, a `%` that
+ * starts no valid sequence stays as it is, and each malformed UTF-8 part, or
+ * lone surrogate half, becomes U+FFFD.
+ *
+ * @param text - the encoded name or value
+ * @returns the decoded text
+ */
+export const decodeQueryComponent = (text) => toWellFormed(text).replace(/\+/g, ' ').replace(percentEncodedRun, decodePercentRun);
+/**
+ * Lists the parameters of a query, decoded and in order.
+ *
+ * @param query - a query, with or without its leading `?`
+ * @returns each parameter's name and value; a parameter with no `=` has an empty value
+ */
+export const parseQuery = (query) => query
+    .replace(/^\?/, '')
+    .split('&')
+    .filter((part) => part !== '')
+    .map((part) => {
+    const equalsAt = part.indexOf('=');
+    const name = equalsAt === -1 ? part : part.slice(0, equalsAt);
+    const value = equalsAt === -1 ? '' : part.slice(equalsAt + 1);
+    return [decodeQueryComponent(name), decodeQueryComponent(value)];
+});
+/**
+ * Turns query parameters into ordered pairs.
+ *
+ * @param parameters - a record or pairs; see {@link QueryParameters}
+ * @returns the pairs, with every `undefined` record value left out
+ */
+const toEntries = (parameters) => {
+    if (Array.isArray(parameters))
+        return parameters;
+    return Object.entries(parameters).filter((entry) => entry[1] !== undefined);
+};
+/**
+ * Writes a query, as `new URLSearchParams(parameters).toString()` does.
+ *
+ * @param parameters - a record or pairs; see {@link QueryParameters}
+ * @returns the encoded query, with no leading `?`; empty for no parameters
+ */
+export const buildQuery = (parameters) => toEntries(parameters)
+    .map(([name, value]) => `${encodeQueryComponent(name)}=${encodeQueryComponent(value)}`)
+    .join('&');
+/**
+ * Sets one parameter in a query, as `URLSearchParams.set` does: the first
+ * parameter of that name takes the value and any later ones are removed, or
+ * the parameter is appended when none has the name.
+ *
+ * @param query - an encoded query, with or without its leading `?`
+ * @param name - the parameter's name
+ * @param value - its value
+ * @returns the encoded query, with no leading `?`
+ */
+export const setQueryParameter = (query, name, value) => {
+    const entries = parseQuery(query);
+    const firstAt = entries.findIndex(([entryName]) => entryName === name);
+    if (firstAt === -1)
+        return buildQuery([...entries, [name, value]]);
+    return buildQuery(entries.flatMap((entry, index) => {
+        if (index === firstAt)
+            return [[name, value]];
+        return entry[0] === name ? [] : [entry];
+    }));
+};
+/**
+ * Splits an address at its first `#` and then at its first `?`.
+ *
+ * @param address - any address
+ * @returns everything before the query, the query and the fragment, each without its delimiter
+ */
+const splitAtQuery = (address) => {
+    const fragmentAt = address.indexOf('#');
+    const beforeFragment = fragmentAt === -1 ? address : address.slice(0, fragmentAt);
+    const fragment = fragmentAt === -1 ? '' : address.slice(fragmentAt + 1);
+    const queryAt = beforeFragment.indexOf('?');
+    if (queryAt === -1)
+        return { beforeQuery: beforeFragment, query: '', fragment };
+    return { beforeQuery: beforeFragment.slice(0, queryAt), query: beforeFragment.slice(queryAt + 1), fragment };
+};
+/**
+ * Adds query parameters to an address, as `url.searchParams.set` does for
+ * each one in turn. A query already on the address is kept, and a fragment
+ * stays at the end.
+ *
+ * @param address - the address, with or without a query
+ * @param parameters - a record or pairs; see {@link QueryParameters}
+ * @returns the address with the parameters set; the address unchanged when there are none
+ */
+export const buildUrl = (address, parameters) => {
+    const entries = toEntries(parameters);
+    if (entries.length === 0)
+        return address;
+    const { beforeQuery, query, fragment } = splitAtQuery(address);
+    const updated = entries.reduce((current, [name, value]) => setQueryParameter(current, name, value), query);
+    return `${beforeQuery}?${updated}${fragment === '' ? '' : `#${fragment}`}`;
+};
+/**
+ * Reads the host the WHATWG `URL` reports from an authority: lowercase, with
+ * any user name and password dropped, and the port dropped when it is the
+ * scheme's default.
+ *
+ * @param authority - the text between `//` and the path
+ * @param scheme - the lowercase scheme
+ * @returns the host
+ */
+const hostOfAuthority = (authority, scheme) => {
+    const hostAndPort = authority.slice(authority.lastIndexOf('@') + 1).toLowerCase();
+    const port = /:(\d*)$/.exec(hostAndPort);
+    if (port === null)
+        return hostAndPort;
+    const hostname = hostAndPort.slice(0, port.index);
+    if (port[1] === '')
+        return hostname;
+    const portNumber = String(Number(port[1]));
+    return portNumber === defaultPorts[scheme] ? hostname : `${hostname}:${portNumber}`;
+};
+/**
+ * Splits an address into its parts, without the WHATWG `URL` class.
+ *
+ * @param address - any address; leading and trailing spaces and control characters are ignored, as the WHATWG parser ignores them
+ * @returns the parts; see {@link UrlParts}
+ */
+export const splitUrl = (address) => {
+    const trimmed = address.replace(/^[\u0000- ]+|[\u0000- ]+$/g, '');
+    const { beforeQuery, query, fragment } = splitAtQuery(trimmed);
+    const schemeMatch = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(beforeQuery);
+    const scheme = schemeMatch === null ? '' : schemeMatch[1].toLowerCase();
+    const rest = schemeMatch === null ? beforeQuery : beforeQuery.slice(schemeMatch[0].length);
+    if (!rest.startsWith('//'))
+        return { scheme, host: '', path: rest, query, fragment };
+    const pathAt = rest.indexOf('/', 2);
+    const authority = pathAt === -1 ? rest.slice(2) : rest.slice(2, pathAt);
+    const path = pathAt === -1 ? '/' : rest.slice(pathAt);
+    return { scheme, host: hostOfAuthority(authority, scheme), path, query, fragment };
+};
+/**
+ * Says whether a value is an absolute `http:` or `https:` address with a host.
+ * It reads the scheme by its prefix, so it needs no `URL` class.
+ *
+ * @param value - any string
+ * @returns true for an absolute `http:` or `https:` address
+ */
+export const isHttpUrl = (value) => {
+    const { scheme, host } = splitUrl(value);
+    return (scheme === 'http' || scheme === 'https') && host !== '';
+};

package/erc20/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/erc20.js",
+  "module": "../dist/erc20.js",
+  "types": "../dist/erc20.d.ts",
+  "react-native": "../dist/cjs/erc20.js"
+}

package/llms.txt

@@ -8,9 +8,13 @@
 ## Install
 
 - Run `npm install @gibs/common viem`.
-- The package is ESM only. Use `import`, not `require`.
-- It needs Node 20 or later.
-- viem is a peer dependency. The range is `>=2.37.0 <3`.
+- It runs on Node 20 or later, in browsers, and in React Native under Hermes.
+- `import` loads the ECMAScript module build (`dist/`). `require` loads the CommonJS build (`dist/cjs/`).
+- React Native 0.77 or later: Metro's default configuration and the React Native jest preset load it with no extra setup. Add no `resolveRequest` hook and no `transformIgnorePatterns`. The `react-native` condition gives an `import` statement the ECMAScript module build and a `require` call the CommonJS build.
+- It needs no polyfill, not even for `URL`: React Native 0.77's own `URL` and `URLSearchParams` are partial, and no entry point reads them.
+- Import from the narrowest subpath, for example `@gibs/common/cache`. Metro does not drop unused exports.
+- It has no runtime dependency except viem.
+- viem is a peer dependency. The range is `>=2.35.0 <3`.
 - Version note: 1.12.0 and older on npm are broken. 1.13.0 is the first usable version.
 
 ## Entry points
@@ -19,9 +23,10 @@
 - `@gibs/common/client`: `clientFromChain({ chain, urls })`, `chainKey`, `clientCache`.
 - `@gibs/common/erc20`: `multicallErc20`, `erc20MetadataCalls`.
 - `@gibs/common/multicall`: `multicallRead`.
-- `@gibs/common/cache`: `maxMemoize`, `ttlMemoizeSingle`.
+- `@gibs/common/cache`: `maxMemoize`, `ttlMemoizeSingle`, `memoizeByKey`.
 - `@gibs/common/serialize`: `jsonAnyStringify`, `jsonAnyParse`, `isSerializedBigInt`.
 - `@gibs/common/types`: `Call`, `Erc20Metadata`.
+- `@gibs/common/url`: `buildUrl`, `buildQuery`, `parseQuery`, `setQueryParameter`, `splitUrl`, `isHttpUrl`, `encodeQueryComponent`, `decodeQueryComponent`. They build and read request addresses with string work, never with `URL`, and encode a query exactly as `URLSearchParams` does.
 
 ## Read a token's name, symbol and decimals
 
@@ -56,6 +61,20 @@ const square = maxMemoize((x: number) => x * x, 100)
 const price = ttlMemoizeSingle(async (symbol: string) => symbol, 30_000)
 ```
 
+`memoizeByKey` keys each answer by a resolver you supply, and exposes the
+cache so you can evict one answer or clear them all.
+
+```ts
+import { memoizeByKey } from '@gibs/common/cache'
+
+const decimals = memoizeByKey(
+  async ({ chainId, address }: { chainId: number; address: string }) => (chainId === 1 ? 6 : 18),
+  ({ chainId, address }) => `${chainId}-${address.toLowerCase()}`,
+)
+decimals.cache.delete('1-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
+decimals.cache.clear()
+```
+
 ## Rules
 
 - `multicallRead` and `multicallErc20` need a chain object that carries a Multicall3 deployment. A chain without one fails.
@@ -66,5 +85,5 @@ const price = ttlMemoizeSingle(async (symbol: string) => symbol, 30_000)
 
 ## Links
 
-- [README](https://github.com/gibsfinance/bridge/blob/staging/packages/common/README.md)
+- [README](https://www.npmjs.com/package/@gibs/common)
 - [Gibs Finance llms.txt](https://next.gibs.finance/llms.txt): the whole platform.

package/multicall/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/multicall.js",
+  "module": "../dist/multicall.js",
+  "types": "../dist/multicall.d.ts",
+  "react-native": "../dist/cjs/multicall.js"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gibs/common",
-  "version": "1.13.1",
+  "version": "1.17.0",
   "description": "Low-level blockchain helpers shared across the Gibs Finance packages: caching, multicall, and serialization.",
   "keywords": [
     "ethereum",
@@ -25,48 +25,236 @@
   },
   "type": "module",
   "sideEffects": false,
-  "main": "./dist/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/index.js",
+  "react-native": "./dist/cjs/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "gibs-source": "./src/index.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/index.d.ts",
+          "default": "./dist/index.js"
+        },
+        "require": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        },
+        "default": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        }
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./erc20": {
       "gibs-source": "./src/erc20.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/erc20.d.ts",
+          "default": "./dist/erc20.js"
+        },
+        "require": {
+          "types": "./dist/cjs/erc20.d.ts",
+          "default": "./dist/cjs/erc20.js"
+        },
+        "default": {
+          "types": "./dist/cjs/erc20.d.ts",
+          "default": "./dist/cjs/erc20.js"
+        }
+      },
+      "import": {
+        "types": "./dist/erc20.d.ts",
+        "default": "./dist/erc20.js"
+      },
+      "require": {
+        "types": "./dist/cjs/erc20.d.ts",
+        "default": "./dist/cjs/erc20.js"
+      },
       "types": "./dist/erc20.d.ts",
       "default": "./dist/erc20.js"
     },
     "./cache": {
       "gibs-source": "./src/cache.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/cache.d.ts",
+          "default": "./dist/cache.js"
+        },
+        "require": {
+          "types": "./dist/cjs/cache.d.ts",
+          "default": "./dist/cjs/cache.js"
+        },
+        "default": {
+          "types": "./dist/cjs/cache.d.ts",
+          "default": "./dist/cjs/cache.js"
+        }
+      },
+      "import": {
+        "types": "./dist/cache.d.ts",
+        "default": "./dist/cache.js"
+      },
+      "require": {
+        "types": "./dist/cjs/cache.d.ts",
+        "default": "./dist/cjs/cache.js"
+      },
       "types": "./dist/cache.d.ts",
       "default": "./dist/cache.js"
     },
     "./serialize": {
       "gibs-source": "./src/serialize.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/serialize.d.ts",
+          "default": "./dist/serialize.js"
+        },
+        "require": {
+          "types": "./dist/cjs/serialize.d.ts",
+          "default": "./dist/cjs/serialize.js"
+        },
+        "default": {
+          "types": "./dist/cjs/serialize.d.ts",
+          "default": "./dist/cjs/serialize.js"
+        }
+      },
+      "import": {
+        "types": "./dist/serialize.d.ts",
+        "default": "./dist/serialize.js"
+      },
+      "require": {
+        "types": "./dist/cjs/serialize.d.ts",
+        "default": "./dist/cjs/serialize.js"
+      },
       "types": "./dist/serialize.d.ts",
       "default": "./dist/serialize.js"
     },
     "./types": {
       "gibs-source": "./src/types.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/types.d.ts",
+          "default": "./dist/types.js"
+        },
+        "require": {
+          "types": "./dist/cjs/types.d.ts",
+          "default": "./dist/cjs/types.js"
+        },
+        "default": {
+          "types": "./dist/cjs/types.d.ts",
+          "default": "./dist/cjs/types.js"
+        }
+      },
+      "import": {
+        "types": "./dist/types.d.ts",
+        "default": "./dist/types.js"
+      },
+      "require": {
+        "types": "./dist/cjs/types.d.ts",
+        "default": "./dist/cjs/types.js"
+      },
       "types": "./dist/types.d.ts",
       "default": "./dist/types.js"
     },
     "./multicall": {
       "gibs-source": "./src/multicall.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/multicall.d.ts",
+          "default": "./dist/multicall.js"
+        },
+        "require": {
+          "types": "./dist/cjs/multicall.d.ts",
+          "default": "./dist/cjs/multicall.js"
+        },
+        "default": {
+          "types": "./dist/cjs/multicall.d.ts",
+          "default": "./dist/cjs/multicall.js"
+        }
+      },
+      "import": {
+        "types": "./dist/multicall.d.ts",
+        "default": "./dist/multicall.js"
+      },
+      "require": {
+        "types": "./dist/cjs/multicall.d.ts",
+        "default": "./dist/cjs/multicall.js"
+      },
       "types": "./dist/multicall.d.ts",
       "default": "./dist/multicall.js"
     },
     "./client": {
       "gibs-source": "./src/client.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/client.d.ts",
+          "default": "./dist/client.js"
+        },
+        "require": {
+          "types": "./dist/cjs/client.d.ts",
+          "default": "./dist/cjs/client.js"
+        },
+        "default": {
+          "types": "./dist/cjs/client.d.ts",
+          "default": "./dist/cjs/client.js"
+        }
+      },
+      "import": {
+        "types": "./dist/client.d.ts",
+        "default": "./dist/client.js"
+      },
+      "require": {
+        "types": "./dist/cjs/client.d.ts",
+        "default": "./dist/cjs/client.js"
+      },
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
     },
+    "./url": {
+      "gibs-source": "./src/url.ts",
+      "react-native": {
+        "import": {
+          "types": "./dist/url.d.ts",
+          "default": "./dist/url.js"
+        },
+        "require": {
+          "types": "./dist/cjs/url.d.ts",
+          "default": "./dist/cjs/url.js"
+        },
+        "default": {
+          "types": "./dist/cjs/url.d.ts",
+          "default": "./dist/cjs/url.js"
+        }
+      },
+      "import": {
+        "types": "./dist/url.d.ts",
+        "default": "./dist/url.js"
+      },
+      "require": {
+        "types": "./dist/cjs/url.d.ts",
+        "default": "./dist/cjs/url.js"
+      },
+      "types": "./dist/url.d.ts",
+      "default": "./dist/url.js"
+    },
     "./test-utils/fuzz": {
       "gibs-source": "./src/test-utils/fuzz.ts",
       "default": "./src/test-utils/fuzz.ts"
-    }
+    },
+    "./test-utils/react-native-url": {
+      "gibs-source": "./src/test-utils/react-native-url.ts",
+      "default": "./src/test-utils/react-native-url.ts"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -74,20 +262,28 @@
     "!dist/**/*.test-d.*",
     "!dist/test-utils",
     "LICENSE",
-    "llms.txt"
+    "llms.txt",
+    "erc20",
+    "cache",
+    "serialize",
+    "types",
+    "multicall",
+    "client",
+    "url"
   ],
   "scripts": {
     "prepublishOnly": "npx tsc",
+    "prepack": "npm run build:cjs && npm run build:stubs",
+    "postpack": "node ../../scripts/subpath-stubs.mjs remove",
     "build": "npx tsc",
+    "build:cjs": "node ../../scripts/build-cjs.mjs",
+    "build:stubs": "node ../../scripts/subpath-stubs.mjs write",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"
   },
-  "dependencies": {
-    "lodash-es": "^4.17.21"
-  },
   "peerDependencies": {
-    "viem": ">=2.37.0 <3"
+    "viem": ">=2.35.0 <3"
   },
   "devDependencies": {
     "@types/node": "^24",

package/serialize/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/serialize.js",
+  "module": "../dist/serialize.js",
+  "types": "../dist/serialize.d.ts",
+  "react-native": "../dist/cjs/serialize.js"
+}

package/types/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/types.js",
+  "module": "../dist/types.js",
+  "types": "../dist/types.d.ts",
+  "react-native": "../dist/cjs/types.js"
+}

package/url/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/url.js",
+  "module": "../dist/url.js",
+  "types": "../dist/url.d.ts",
+  "react-native": "../dist/cjs/url.js"
+}