@gibs/common 1.13.0 → 1.17.0

package/dist/cjs/url.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+/**
+ * Query parameters, as a record or as ordered name and value pairs.
+ *
+ * In a record, a value of `undefined` leaves that parameter out, so an
+ * optional parameter can be written in place. Pairs keep their order and may
+ * repeat a name.
+ */
+export type QueryParameters = Readonly<Record<string, string | undefined>> | ReadonlyArray<readonly [string, string]>;
+/** One query parameter: its decoded name and value. */
+export type QueryEntry = readonly [name: string, value: string];
+/** The parts of an address, as the WHATWG `URL` getters name them. */
+export type UrlParts = {
+    /** The scheme in lowercase, with no colon, such as `https`. Empty when the address has none. */
+    readonly scheme: string;
+    /** The host in lowercase, with the port unless it is the scheme's default. Empty when the address has no authority. */
+    readonly host: string;
+    /** The path. `/` for an address with an authority and no path. */
+    readonly path: string;
+    /** The query, with no leading `?`. */
+    readonly query: string;
+    /** The fragment, with no leading `#`. */
+    readonly fragment: string;
+};
+/**
+ * Encodes a query name or value exactly as `URLSearchParams.toString` does.
+ *
+ * @param text - the raw name or value
+ * @returns the encoded text
+ */
+export declare const encodeQueryComponent: (text: string) => string;
+/**
+ * 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 declare const decodeQueryComponent: (text: string) => string;
+/**
+ * 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 declare const parseQuery: (query: string) => readonly QueryEntry[];
+/**
+ * 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 declare const buildQuery: (parameters: QueryParameters) => string;
+/**
+ * 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 declare const setQueryParameter: (query: string, name: string, value: string) => string;
+/**
+ * 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 declare const buildUrl: (address: string, parameters: QueryParameters) => string;
+/**
+ * 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 declare const splitUrl: (address: string) => UrlParts;
+/**
+ * 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 declare const isHttpUrl: (value: string) => boolean;

package/dist/cjs/url.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpUrl = exports.splitUrl = exports.buildUrl = exports.setQueryParameter = exports.buildQuery = exports.parseQuery = exports.decodeQueryComponent = exports.encodeQueryComponent = void 0;
+/**
+ * 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
+ */
+const encodeQueryComponent = (text) => encodeURIComponent(toWellFormed(text))
+    .replace(formEscapedCharacters, percentEncodeCharacter)
+    .replace(/%20/g, '+');
+exports.encodeQueryComponent = encodeQueryComponent;
+/**
+ * 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
+ */
+const decodeQueryComponent = (text) => toWellFormed(text).replace(/\+/g, ' ').replace(percentEncodedRun, decodePercentRun);
+exports.decodeQueryComponent = decodeQueryComponent;
+/**
+ * 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
+ */
+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 [(0, exports.decodeQueryComponent)(name), (0, exports.decodeQueryComponent)(value)];
+});
+exports.parseQuery = parseQuery;
+/**
+ * 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
+ */
+const buildQuery = (parameters) => toEntries(parameters)
+    .map(([name, value]) => `${(0, exports.encodeQueryComponent)(name)}=${(0, exports.encodeQueryComponent)(value)}`)
+    .join('&');
+exports.buildQuery = buildQuery;
+/**
+ * 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 `?`
+ */
+const setQueryParameter = (query, name, value) => {
+    const entries = (0, exports.parseQuery)(query);
+    const firstAt = entries.findIndex(([entryName]) => entryName === name);
+    if (firstAt === -1)
+        return (0, exports.buildQuery)([...entries, [name, value]]);
+    return (0, exports.buildQuery)(entries.flatMap((entry, index) => {
+        if (index === firstAt)
+            return [[name, value]];
+        return entry[0] === name ? [] : [entry];
+    }));
+};
+exports.setQueryParameter = setQueryParameter;
+/**
+ * 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
+ */
+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]) => (0, exports.setQueryParameter)(current, name, value), query);
+    return `${beforeQuery}?${updated}${fragment === '' ? '' : `#${fragment}`}`;
+};
+exports.buildUrl = buildUrl;
+/**
+ * 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}
+ */
+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 };
+};
+exports.splitUrl = splitUrl;
+/**
+ * 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
+ */
+const isHttpUrl = (value) => {
+    const { scheme, host } = (0, exports.splitUrl)(value);
+    return (scheme === 'http' || scheme === 'https') && host !== '';
+};
+exports.isHttpUrl = isHttpUrl;

package/dist/client.js

@@ -1,5 +1,6 @@
 import { createPublicClient, createTransport, http, webSocket, } from 'viem';
 import { countMethods, createRpcPacer, MAX_SAME_METHOD_CALLS_PER_SECOND, } from './rpcPacer.js';
+import { splitUrl } from './url.js';
 export { MAX_SAME_METHOD_CALLS_PER_SECOND } from './rpcPacer.js';
 /**
  * JSON-RPC request batching config. When enabled, viem coalesces requests made
@@ -65,7 +66,7 @@ const pacer = createRpcPacer({ ceiling: MAX_SAME_METHOD_CALLS_PER_SECOND });
 const paceRequest = async (request) => {
     // The HOST, not the full url: one proxy serves every chain from one budget,
     // so `/evm/1` and `/evm/369` must count against the same tally.
-    const host = new URL(request.url).host;
+    const { host } = splitUrl(request.url);
     await pacer.reserve(host, countMethods(await request.clone().text().catch(() => null)));
 };
 /**

package/dist/erc20.d.ts

@@ -7,11 +7,9 @@ export declare const erc20MetadataCalls: {
 /**
  * The multicall for the erc20 metadata.
  *
- * The explicit annotation is required rather than stylistic: `@types/lodash-es`
- * re-exports its `MemoizedFunction` type from a nested `@types/lodash` that a
- * generated declaration file cannot name (TS2742). Spelling out the plain call
- * signature also keeps the memoization an implementation detail — no caller
- * touches the `.cache` property it would otherwise publish.
+ * The annotation spells out the plain call signature, which keeps the
+ * memoization an implementation detail: no caller touches the `.cache`
+ * property it would otherwise publish.
  */
 export declare const multicallErc20: (inputs: {
     client: PublicClient;

package/dist/erc20.js

@@ -1,5 +1,5 @@
-import * as _ from 'lodash-es';
 import { erc20Abi, erc20Abi_bytes32, getAddress, } from 'viem';
+import { memoizeByKey } from './cache.js';
 import { multicallRead } from './multicall.js';
 /** The erc20 metadata calls */
 export const erc20MetadataCalls = [
@@ -10,13 +10,11 @@ export const erc20MetadataCalls = [
 /**
  * The multicall for the erc20 metadata.
  *
- * The explicit annotation is required rather than stylistic: `@types/lodash-es`
- * re-exports its `MemoizedFunction` type from a nested `@types/lodash` that a
- * generated declaration file cannot name (TS2742). Spelling out the plain call
- * signature also keeps the memoization an implementation detail — no caller
- * touches the `.cache` property it would otherwise publish.
+ * The annotation spells out the plain call signature, which keeps the
+ * memoization an implementation detail: no caller touches the `.cache`
+ * property it would otherwise publish.
  */
-export const multicallErc20 = _.memoize(async ({ client, target, chain }) => {
+export const multicallErc20 = memoizeByKey(async ({ client, target, chain }) => {
     const options = {
         chain: chain,
         client: client,

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export * from './erc20.js';
 export * from './multicall.js';
 export * from './serialize.js';
 export * from './types.js';
+export * from './url.js';

package/dist/index.js

@@ -5,3 +5,4 @@ export * from './erc20.js';
 export * from './multicall.js';
 export * from './serialize.js';
 export * from './types.js';
+export * from './url.js';

package/dist/multicall.js

@@ -1,4 +1,3 @@
-import * as _ from 'lodash-es';
 import { decodeFunctionResult, encodeFunctionData, getContract, multicall3Abi, } from 'viem';
 import { ensureResult } from './assert.js';
 /**
@@ -206,7 +205,7 @@ export const multicallRead = async ({ chain, client, abi, calls, target, }) => {
             chainId: client.chain?.id,
             target,
             callCount: calls.length,
-            functionNames: _.uniq(calls.map((call) => call.functionName)),
+            functionNames: [...new Set(calls.map((call) => call.functionName))],
         });
         throw err;
     }

package/dist/url.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+/**
+ * Query parameters, as a record or as ordered name and value pairs.
+ *
+ * In a record, a value of `undefined` leaves that parameter out, so an
+ * optional parameter can be written in place. Pairs keep their order and may
+ * repeat a name.
+ */
+export type QueryParameters = Readonly<Record<string, string | undefined>> | ReadonlyArray<readonly [string, string]>;
+/** One query parameter: its decoded name and value. */
+export type QueryEntry = readonly [name: string, value: string];
+/** The parts of an address, as the WHATWG `URL` getters name them. */
+export type UrlParts = {
+    /** The scheme in lowercase, with no colon, such as `https`. Empty when the address has none. */
+    readonly scheme: string;
+    /** The host in lowercase, with the port unless it is the scheme's default. Empty when the address has no authority. */
+    readonly host: string;
+    /** The path. `/` for an address with an authority and no path. */
+    readonly path: string;
+    /** The query, with no leading `?`. */
+    readonly query: string;
+    /** The fragment, with no leading `#`. */
+    readonly fragment: string;
+};
+/**
+ * Encodes a query name or value exactly as `URLSearchParams.toString` does.
+ *
+ * @param text - the raw name or value
+ * @returns the encoded text
+ */
+export declare const encodeQueryComponent: (text: string) => string;
+/**
+ * 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 declare const decodeQueryComponent: (text: string) => string;
+/**
+ * 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 declare const parseQuery: (query: string) => readonly QueryEntry[];
+/**
+ * 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 declare const buildQuery: (parameters: QueryParameters) => string;
+/**
+ * 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 declare const setQueryParameter: (query: string, name: string, value: string) => string;
+/**
+ * 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 declare const buildUrl: (address: string, parameters: QueryParameters) => string;
+/**
+ * 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 declare const splitUrl: (address: string) => UrlParts;
+/**
+ * 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 declare const isHttpUrl: (value: string) => boolean;