@ocap/util 1.27.16 → 1.28.1

package/esm/lodash.d.ts

@@ -0,0 +1,12 @@
+declare module 'lodash/camelCase';
+declare module 'lodash/flatten';
+declare module 'lodash/get';
+declare module 'lodash/isBoolean';
+declare module 'lodash/isNull';
+declare module 'lodash/isNumber';
+declare module 'lodash/isObject';
+declare module 'lodash/isString';
+declare module 'lodash/padEnd';
+declare module 'lodash/padStart';
+declare module 'lodash/uniq';
+declare module 'lodash/upperFirst';

package/esm/md5.d.ts

@@ -1 +1,4 @@
-export declare const md5: (x: $TSFixMe) => string;
+//#region src/md5.d.ts
+declare const md5: (x: $TSFixMe) => string;
+//#endregion
+export { md5 };

package/esm/md5.js

@@ -1,3 +1,7 @@
-import crypto from 'crypto';
-// eslint-disable-next-line import/prefer-default-export
-export const md5 = (x) => crypto.createHash('md5').update(x).digest('hex');
+import crypto from "crypto";
+
+//#region src/md5.ts
+const md5 = (x) => crypto.createHash("md5").update(x).digest("hex");
+
+//#endregion
+export { md5 };

package/esm/ready.d.ts

@@ -1,10 +1,14 @@
-import EventEmitter from 'events';
-export declare class Ready extends EventEmitter {
-    emit: $TSFixMe;
-    ready: $TSFixMe;
-    readyCallbacks: $TSFixMe;
-    readyMarks: $TSFixMe;
-    constructor();
-    markReady(mark?: $TSFixMe): void;
-    onReady(cb: $TSFixMe): void;
+import EventEmitter from "events";
+
+//#region src/ready.d.ts
+declare class Ready extends EventEmitter {
+  emit: $TSFixMe;
+  ready: $TSFixMe;
+  readyCallbacks: $TSFixMe;
+  readyMarks: $TSFixMe;
+  constructor();
+  markReady(mark?: $TSFixMe): void;
+  onReady(cb: $TSFixMe): void;
 }
+//#endregion
+export { Ready };

package/esm/ready.js

@@ -1,36 +1,33 @@
-import EventEmitter from 'events';
-export class Ready extends EventEmitter {
-    constructor() {
-        super();
-        this.ready = false;
-        this.readyCallbacks = [];
-        this.readyMarks = {};
-    }
-    markReady(mark) {
-        if (this.ready) {
-            return;
-        }
-        if (mark === undefined) {
-            this.ready = true;
-            this.readyCallbacks.forEach((x) => x());
-            this.emit('ready');
-        }
-        else {
-            // console.log('Ready.markReady', this.name, mark);
-            this.readyMarks[mark] = true;
-            this.ready = Object.values(this.readyMarks).every((x) => !!x);
-            if (this.ready) {
-                this.readyCallbacks.forEach((cb) => cb());
-                this.emit('ready');
-            }
-        }
-    }
-    onReady(cb) {
-        if (this.ready) {
-            cb();
-        }
-        else {
-            this.readyCallbacks.push(cb);
-        }
-    }
-}
+import EventEmitter from "events";
+
+//#region src/ready.ts
+var Ready = class extends EventEmitter {
+	constructor() {
+		super();
+		this.ready = false;
+		this.readyCallbacks = [];
+		this.readyMarks = {};
+	}
+	markReady(mark) {
+		if (this.ready) return;
+		if (mark === void 0) {
+			this.ready = true;
+			this.readyCallbacks.forEach((x) => x());
+			this.emit("ready");
+		} else {
+			this.readyMarks[mark] = true;
+			this.ready = Object.values(this.readyMarks).every((x) => !!x);
+			if (this.ready) {
+				this.readyCallbacks.forEach((cb) => cb());
+				this.emit("ready");
+			}
+		}
+	}
+	onReady(cb) {
+		if (this.ready) cb();
+		else this.readyCallbacks.push(cb);
+	}
+};
+
+//#endregion
+export { Ready };

package/esm/retry.d.ts

@@ -1,11 +1,18 @@
+//#region src/retry.d.ts
 interface RetryOptions {
-    retryLimit?: number;
-    backoff?: {
-        baseDelay: number;
-        maxDelay: number;
-    };
-    shouldRetry?: (error: unknown) => boolean;
-    onError?: (error: unknown, attempt: number) => Promise<void> | void;
+  retryLimit?: number;
+  backoff?: {
+    baseDelay: number;
+    maxDelay: number;
+  };
+  shouldRetry?: (error: unknown) => boolean;
+  onError?: (error: unknown, attempt: number) => Promise<void> | void;
 }
-export declare function withRetry<T>(handle: () => Promise<T>, { retryLimit, backoff, shouldRetry, onError, }?: RetryOptions): Promise<T>;
-export {};
+declare function withRetry<T>(handle: () => Promise<T>, {
+  retryLimit,
+  backoff,
+  shouldRetry,
+  onError
+}?: RetryOptions): Promise<T>;
+//#endregion
+export { withRetry };

package/esm/retry.js

@@ -1,30 +1,29 @@
-/* eslint-disable no-await-in-loop */
+//#region src/retry.ts
 function wait(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
 }
-// eslint-disable-next-line consistent-return
-export async function withRetry(handle, { retryLimit = 30, backoff = { baseDelay: 20, maxDelay: 1000 }, shouldRetry = () => true, onError = () => { }, } = {}) {
-    let attempt = 0;
-    let lastError;
-    while (attempt <= retryLimit) {
-        attempt++;
-        try {
-            const result = await handle();
-            return result;
-        }
-        catch (error) {
-            if (!shouldRetry(error) || attempt > retryLimit) {
-                throw error;
-            }
-            lastError = error;
-            if (onError) {
-                await onError(lastError, attempt);
-            }
-            const { baseDelay, maxDelay } = backoff;
-            const delay = Math.min(maxDelay, baseDelay * 2 ** attempt);
-            await wait(Math.random() * delay);
-        }
-    }
+async function withRetry(handle, { retryLimit = 30, backoff = {
+	baseDelay: 20,
+	maxDelay: 1e3
+}, shouldRetry = () => true, onError = () => {} } = {}) {
+	let attempt = 0;
+	let lastError;
+	while (attempt <= retryLimit) {
+		attempt++;
+		try {
+			return await handle();
+		} catch (error) {
+			if (!shouldRetry(error) || attempt > retryLimit) throw error;
+			lastError = error;
+			if (onError) await onError(lastError, attempt);
+			const { baseDelay, maxDelay } = backoff;
+			const delay = Math.min(maxDelay, baseDelay * 2 ** attempt);
+			await wait(Math.random() * delay);
+		}
+	}
 }
+
+//#endregion
+export { withRetry };

package/esm/tsfixme.d.ts

@@ -0,0 +1,3 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type $TSFixMe = any;
+type $TSFixMeFunction = (...args: any[]) => any;

package/esm/url.d.ts

@@ -1,13 +1,17 @@
-import * as ipaddr from 'ipaddr.js';
-export declare function parseIp(host: string): ipaddr.IPv4 | ipaddr.IPv6 | null;
-export declare function isUnicastAddress(host: string): boolean;
-export declare function resolveHostAddresses(host: string): Promise<string[]>;
-export interface VerifyUrlOptions {
-    allowIp?: boolean;
-    maxLength?: number;
-    protocols?: string[];
-    blockedHosts?: string[];
-    blockedSuffixes?: string[];
-    checkDns?: boolean;
+import * as ipaddr from "ipaddr.js";
+
+//#region src/url.d.ts
+declare function parseIp(host: string): ipaddr.IPv4 | ipaddr.IPv6 | null;
+declare function isUnicastAddress(host: string): boolean;
+declare function resolveHostAddresses(host: string): Promise<string[]>;
+interface VerifyUrlOptions {
+  allowIp?: boolean;
+  maxLength?: number;
+  protocols?: string[];
+  blockedHosts?: string[];
+  blockedSuffixes?: string[];
+  checkDns?: boolean;
 }
-export declare function verifyUrl(url: string, options?: VerifyUrlOptions): Promise<boolean>;
+declare function verifyUrl(url: string, options?: VerifyUrlOptions): Promise<boolean>;
+//#endregion
+export { VerifyUrlOptions, isUnicastAddress, parseIp, resolveHostAddresses, verifyUrl };

package/esm/url.js

@@ -1,101 +1,76 @@
-import { URL } from 'url';
-import * as ipaddr from 'ipaddr.js';
-import { Resolver } from 'dns/promises';
+import { URL } from "url";
+import * as ipaddr from "ipaddr.js";
+import { Resolver } from "dns/promises.js";
+
+//#region src/url.ts
 const MAX_URL_LENGTH = 256;
-export function parseIp(host) {
-    if (!ipaddr.isValid(host))
-        return null;
-    try {
-        return ipaddr.parse(host);
-    }
-    catch {
-        return null;
-    }
+function parseIp(host) {
+	if (!ipaddr.isValid(host)) return null;
+	try {
+		return ipaddr.parse(host);
+	} catch {
+		return null;
+	}
 }
 function stripTrailingDots(host) {
-    return host.replace(/\.+$/, '');
+	return host.replace(/\.+$/, "");
 }
 function isBlockedHostname(host, blockedHosts, blockedSuffixes) {
-    const normalized = host.toLowerCase();
-    if (blockedHosts.includes(normalized))
-        return true;
-    if (blockedSuffixes.some((suffix) => normalized.endsWith(suffix)))
-        return true;
-    return false;
+	const normalized = host.toLowerCase();
+	if (blockedHosts.includes(normalized)) return true;
+	if (blockedSuffixes.some((suffix) => normalized.endsWith(suffix))) return true;
+	return false;
 }
-export function isUnicastAddress(host) {
-    const parsed = parseIp(host);
-    if (!parsed)
-        return false;
-    const range = parsed.range();
-    if (range === 'ipv4Mapped' && parsed.kind() === 'ipv6') {
-        const mapped = parsed.toIPv4Address();
-        return mapped.range() === 'unicast';
-    }
-    return range === 'unicast';
+function isUnicastAddress(host) {
+	const parsed = parseIp(host);
+	if (!parsed) return false;
+	const range = parsed.range();
+	if (range === "ipv4Mapped" && parsed.kind() === "ipv6") return parsed.toIPv4Address().range() === "unicast";
+	return range === "unicast";
 }
-export async function resolveHostAddresses(host) {
-    try {
-        const resolver = new Resolver();
-        resolver.setServers(['8.8.8.8', '1.1.1.1']);
-        const addresses = [];
-        // resolve ipv4
-        try {
-            const ipv4Addresses = await resolver.resolve4(host);
-            addresses.push(...ipv4Addresses);
-        }
-        catch (error) {
-            console.warn(`IPv4 resolution failed for ${host}:`, error?.message);
-        }
-        // resolve ipv6
-        if (!addresses.length) {
-            try {
-                const ipv6Addresses = await resolver.resolve6(host);
-                addresses.push(...ipv6Addresses);
-            }
-            catch (error) {
-                console.warn(`IPv6 resolution failed for ${host}:`, error?.message);
-            }
-        }
-        return addresses.filter(Boolean);
-    }
-    catch (error) {
-        console.warn(`DNS resolution failed for host: ${host}, error: ${error?.message}`);
-        return [];
-    }
+async function resolveHostAddresses(host) {
+	try {
+		const resolver = new Resolver();
+		resolver.setServers(["8.8.8.8", "1.1.1.1"]);
+		const addresses = [];
+		try {
+			const ipv4Addresses = await resolver.resolve4(host);
+			addresses.push(...ipv4Addresses);
+		} catch (error) {
+			console.warn(`IPv4 resolution failed for ${host}:`, error?.message);
+		}
+		if (!addresses.length) try {
+			const ipv6Addresses = await resolver.resolve6(host);
+			addresses.push(...ipv6Addresses);
+		} catch (error) {
+			console.warn(`IPv6 resolution failed for ${host}:`, error?.message);
+		}
+		return addresses.filter(Boolean);
+	} catch (error) {
+		console.warn(`DNS resolution failed for host: ${host}, error: ${error?.message}`);
+		return [];
+	}
 }
-export async function verifyUrl(url, options = {}) {
-    if (!url)
-        throw new Error('URL is required');
-    const { maxLength = MAX_URL_LENGTH, protocols = ['https:'], blockedHosts = ['localhost'], blockedSuffixes = [], allowIp = false, checkDns = false, } = options;
-    if (url.length > maxLength) {
-        throw new Error(`URL exceeds maximum length of ${maxLength} characters: ${url.length}`);
-    }
-    const { hostname, protocol } = new URL(url);
-    if (!protocols.includes(protocol)) {
-        throw new Error(`Protocol '${protocol}' is not allowed. Allowed protocols: ${protocols.join(', ')}`);
-    }
-    const normalizedHost = stripTrailingDots(hostname);
-    if (isBlockedHostname(normalizedHost, blockedHosts, blockedSuffixes)) {
-        throw new Error(`Hostname '${normalizedHost}' is blocked`);
-    }
-    const isIP = Boolean(parseIp(normalizedHost));
-    if (isIP) {
-        if (!allowIp) {
-            throw new Error(`IP addresses are not allowed: ${normalizedHost}`);
-        }
-        if (!isUnicastAddress(normalizedHost)) {
-            throw new Error(`IP address is not unicast: ${normalizedHost}`);
-        }
-    }
-    if (checkDns && !isIP) {
-        const resolved = await resolveHostAddresses(normalizedHost);
-        if (resolved.length === 0) {
-            throw new Error(`DNS resolution failed: no addresses found for ${normalizedHost}`);
-        }
-        if (!resolved.every((address) => isUnicastAddress(address))) {
-            throw new Error(`DNS resolved to non-unicast addresses for ${normalizedHost}`);
-        }
-    }
-    return true;
+async function verifyUrl(url, options = {}) {
+	if (!url) throw new Error("URL is required");
+	const { maxLength = MAX_URL_LENGTH, protocols = ["https:"], blockedHosts = ["localhost"], blockedSuffixes = [], allowIp = false, checkDns = false } = options;
+	if (url.length > maxLength) throw new Error(`URL exceeds maximum length of ${maxLength} characters: ${url.length}`);
+	const { hostname, protocol } = new URL(url);
+	if (!protocols.includes(protocol)) throw new Error(`Protocol '${protocol}' is not allowed. Allowed protocols: ${protocols.join(", ")}`);
+	const normalizedHost = stripTrailingDots(hostname);
+	if (isBlockedHostname(normalizedHost, blockedHosts, blockedSuffixes)) throw new Error(`Hostname '${normalizedHost}' is blocked`);
+	const isIP = Boolean(parseIp(normalizedHost));
+	if (isIP) {
+		if (!allowIp) throw new Error(`IP addresses are not allowed: ${normalizedHost}`);
+		if (!isUnicastAddress(normalizedHost)) throw new Error(`IP address is not unicast: ${normalizedHost}`);
+	}
+	if (checkDns && !isIP) {
+		const resolved = await resolveHostAddresses(normalizedHost);
+		if (resolved.length === 0) throw new Error(`DNS resolution failed: no addresses found for ${normalizedHost}`);
+		if (!resolved.every((address) => isUnicastAddress(address))) throw new Error(`DNS resolved to non-unicast addresses for ${normalizedHost}`);
+	}
+	return true;
 }
+
+//#endregion
+export { isUnicastAddress, parseIp, resolveHostAddresses, verifyUrl };

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/bn.d.ts

@@ -1,7 +1,9 @@
-import BaseBN from 'bn.js';
-export interface BN extends BaseBN {
+import BaseBN from "bn.js";
+
+//#region src/bn.d.ts
+interface BN extends BaseBN {}
+declare class BN extends BaseBN {
+  constructor(value: number | string | number[] | Uint8Array | Buffer | BaseBN | null | undefined, base?: number | 'hex', endian?: BaseBN.Endianness);
 }
-export declare class BN extends BaseBN {
-    constructor(value: number | string | number[] | Uint8Array | Buffer | BaseBN | null | undefined, base?: number | 'hex', endian?: BaseBN.Endianness);
-}
-export { BaseBN };
+//#endregion
+export { BN, BaseBN };

package/lib/bn.js

@@ -1,14 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let bn_js = require("bn.js");
+bn_js = require_rolldown_runtime.__toESM(bn_js);
+
+//#region src/bn.ts
+var BN = class extends bn_js.default {
+	constructor(value, base, endian) {
+		super(value === null ? "0" : value, base, endian);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseBN = exports.BN = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
-exports.BaseBN = bn_js_1.default;
-class BN extends bn_js_1.default {
-    constructor(value, base, endian) {
-        super(value === null ? '0' : value, base, endian);
-    }
-}
+
+//#endregion
 exports.BN = BN;
+exports.BaseBN = bn_js.default;

package/lib/constant.d.ts

@@ -1 +1,4 @@
-export declare const DEFAULT_TOKEN_DECIMAL = 18;
+//#region src/constant.d.ts
+declare const DEFAULT_TOKEN_DECIMAL = 18;
+//#endregion
+export { DEFAULT_TOKEN_DECIMAL };

package/lib/constant.js

@@ -1,4 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TOKEN_DECIMAL = void 0;
-exports.DEFAULT_TOKEN_DECIMAL = 18;
+
+//#region src/constant.ts
+const DEFAULT_TOKEN_DECIMAL = 18;
+
+//#endregion
+exports.DEFAULT_TOKEN_DECIMAL = DEFAULT_TOKEN_DECIMAL;

package/lib/create-sorted-list.d.ts

@@ -1 +1,4 @@
-export declare const createSortedList: (list: $TSFixMe) => any;
+//#region src/create-sorted-list.d.ts
+declare const createSortedList: (list: $TSFixMe) => unknown[];
+//#endregion
+export { createSortedList };

package/lib/create-sorted-list.js

@@ -1,10 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSortedList = void 0;
-const uniq_1 = __importDefault(require("lodash/uniq"));
-const flatten_1 = __importDefault(require("lodash/flatten"));
-const createSortedList = (list) => (0, uniq_1.default)((0, flatten_1.default)(list)).filter(Boolean).sort();
-exports.createSortedList = createSortedList;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let lodash_uniq = require("lodash/uniq");
+lodash_uniq = require_rolldown_runtime.__toESM(lodash_uniq);
+let lodash_flatten = require("lodash/flatten");
+lodash_flatten = require_rolldown_runtime.__toESM(lodash_flatten);
+
+//#region src/create-sorted-list.ts
+const createSortedList = (list) => (0, lodash_uniq.default)((0, lodash_flatten.default)(list)).filter(Boolean).sort();
+
+//#endregion
+exports.createSortedList = createSortedList;