@pezkuwi/util 14.0.1 → 14.0.3

package/is/utf8.js

@@ -0,0 +1,197 @@
+import { u8aToU8a } from '../u8a/toU8a.js';
+import { isString } from './string.js';
+/**
+ * @name isUtf8
+ * @summary Tests if the input is valid Utf8
+ * @description
+ * Checks to see if the input string or Uint8Array is valid Utf8
+ */
+export function isUtf8(value) {
+    if (!value) {
+        return isString(value);
+    }
+    const u8a = u8aToU8a(value);
+    const len = u8a.length;
+    let i = 0;
+    while (i < len) {
+        if (u8a[i] <= 0x7F) /* 00..7F */ {
+            i += 1;
+        }
+        else if (u8a[i] >= 0xC2 && u8a[i] <= 0xDF) /* C2..DF 80..BF */ {
+            if (i + 1 < len) /* Expect a 2nd byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte between C2 and DF, expecting a 2nd byte between 80 and BF";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte between C2 and DF, expecting a 2nd byte.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 2;
+        }
+        else if (u8a[i] === 0xE0) /* E0 A0..BF 80..BF */ {
+            if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+                if (u8a[i + 1] < 0xA0 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte of E0, expecting a 2nd byte between A0 and BF.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte of E0, expecting a 3nd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte of E0, expecting two following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 3;
+        }
+        else if (u8a[i] >= 0xE1 && u8a[i] <= 0xEC) /* E1..EC 80..BF 80..BF */ {
+            if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte between E1 and EC, expecting the 2nd byte between 80 and BF.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte between E1 and EC, expecting the 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte between E1 and EC, expecting two following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 3;
+        }
+        else if (u8a[i] === 0xED) /* ED 80..9F 80..BF */ {
+            if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x9F) {
+                    // *message = "After a first byte of ED, expecting 2nd byte between 80 and 9F.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte of ED, expecting 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte of ED, expecting two following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 3;
+        }
+        else if (u8a[i] >= 0xEE && u8a[i] <= 0xEF) /* EE..EF 80..BF 80..BF */ {
+            if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte between EE and EF, expecting 2nd byte between 80 and BF.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte between EE and EF, expecting 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte between EE and EF, two following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 3;
+        }
+        else if (u8a[i] === 0xF0) /* F0 90..BF 80..BF 80..BF */ {
+            if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+                if (u8a[i + 1] < 0x90 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte of F0, expecting 2nd byte between 90 and BF.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte of F0, expecting 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+                if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                    // *message = "After a first byte of F0, expecting 4th byte between 80 and BF.";
+                    // *faulty_bytes = 4;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte of F0, expecting three following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 4;
+        }
+        else if (u8a[i] >= 0xF1 && u8a[i] <= 0xF3) /* F1..F3 80..BF 80..BF 80..BF */ {
+            if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+                    // *message = "After a first byte of F1, F2, or F3, expecting a 2nd byte between 80 and BF.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte of F1, F2, or F3, expecting a 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+                if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                    // *message = "After a first byte of F1, F2, or F3, expecting a 4th byte between 80 and BF.";
+                    // *faulty_bytes = 4;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte of F1, F2, or F3, expecting three following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 4;
+        }
+        else if (u8a[i] === 0xF4) /* F4 80..8F 80..BF 80..BF */ {
+            if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+                if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x8F) {
+                    // *message = "After a first byte of F4, expecting 2nd byte between 80 and 8F.";
+                    // *faulty_bytes = 2;
+                    return false;
+                }
+                if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+                    // *message = "After a first byte of F4, expecting 3rd byte between 80 and BF.";
+                    // *faulty_bytes = 3;
+                    return false;
+                }
+                if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+                    // *message = "After a first byte of F4, expecting 4th byte between 80 and BF.";
+                    // *faulty_bytes = 4;
+                    return false;
+                }
+            }
+            else {
+                // *message = "After a first byte of F4, expecting three following bytes.";
+                // *faulty_bytes = 1;
+                return false;
+            }
+            i += 4;
+        }
+        else {
+            // *message = "Expecting bytes in the following ranges: 00..7F C2..F4.";
+            // *faulty_bytes = 1;
+            return false;
+        }
+    }
+    return true;
+}

package/is/wasm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @name isWasm
+ * @summary Tests if the input has a WASM header
+ * @description
+ * Checks to see if the input Uint8Array contains a valid WASM header
+ */
+export declare function isWasm(value?: unknown): value is Uint8Array;

package/{src/is/wasm.ts → is/wasm.js}

@@ -1,17 +1,12 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { u8aEq } from '../u8a/eq.js';
 import { isU8a } from './u8a.js';
-
 const WASM_MAGIC = new Uint8Array([0, 97, 115, 109]); // \0asm
-
 /**
  * @name isWasm
  * @summary Tests if the input has a WASM header
  * @description
  * Checks to see if the input Uint8Array contains a valid WASM header
  */
-export function isWasm (value?: unknown): value is Uint8Array {
-  return isU8a(value) && u8aEq(value.subarray(0, 4), WASM_MAGIC);
+export function isWasm(value) {
+    return isU8a(value) && u8aEq(value.subarray(0, 4), WASM_MAGIC);
 }

package/lazy.d.ts

@@ -0,0 +1,14 @@
+type AnyFn = (...args: unknown[]) => unknown;
+/**
+ * @name lazyMethod
+ * @description
+ * Creates a lazy, on-demand getter for the specific value. Upon get the value will be evaluated.
+ */
+export declare function lazyMethod<T, K, S>(result: Record<string, T> | AnyFn, item: K, creator: (item: K, index: number, self: S) => T, getName?: (item: K, index: number) => string, index?: number): void;
+/**
+ * @name lazyMethods
+ * @description
+ * Creates lazy, on-demand getters for the specific values.
+ */
+export declare function lazyMethods<T, K, S>(result: Record<string, T>, items: readonly K[], creator: (item: K, index: number, self: S) => T, getName?: (item: K, index: number) => string): Record<string, T>;
+export {};

package/lazy.js

@@ -0,0 +1,51 @@
+/**
+ * @name lazyMethod
+ * @description
+ * Creates a lazy, on-demand getter for the specific value. Upon get the value will be evaluated.
+ */
+export function lazyMethod(result, item, creator, getName, index = 0) {
+    const name = getName
+        ? getName(item, index)
+        : item.toString();
+    let value;
+    Object.defineProperty(result, name, {
+        // This allows for re-configuration with the embedded defineProperty below
+        // and ensures that on tested browsers and Node, it _will_ be redefined
+        // and thus short-circuited for future access
+        configurable: true,
+        enumerable: true,
+        // Use a function here, we don't want to capture the outer this, i.e.
+        // don't use arrow functions in this context since we have a this inside
+        get: function () {
+            // This check should _always_ be false and unneeded, since we override
+            // with a value below ... however we ensure we are quire vigilant against
+            // all environment failures, so we are rather be safe than sorry
+            if (value === undefined) {
+                value = creator(item, index, this);
+                try {
+                    // re-define the property as a value, next time around this
+                    // getter will only return the computed value
+                    Object.defineProperty(this, name, { value });
+                }
+                catch {
+                    // ignore any errors, since this _should_ not happen due to
+                    // the "configurable" property above. But if it ever does
+                    // from here-on we will be the cached value the next time
+                    // around (with a very slight dip in performance)
+                }
+            }
+            return value;
+        }
+    });
+}
+/**
+ * @name lazyMethods
+ * @description
+ * Creates lazy, on-demand getters for the specific values.
+ */
+export function lazyMethods(result, items, creator, getName) {
+    for (let i = 0, count = items.length; i < count; i++) {
+        lazyMethod(result, items[i], creator, getName, i);
+    }
+    return result;
+}

package/logger.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from './types.js';
+export declare function loggerFormat(value: unknown): unknown;
+/**
+ * @name Logger
+ * @summary Creates a consistent log interface for messages
+ * @description
+ * Returns a `Logger` that has `.log`, `.error`, `.warn` and `.debug` (controlled with environment `DEBUG=typeA,typeB`) methods. Logging is done with a consistent prefix (type of logger, date) followed by the actual message using the underlying console.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { logger } from '@polkadot/util';
+ *
+ * const l = logger('test');
+ * ```
+ */
+export declare function logger(origin: string): Logger;

package/logger.js

@@ -0,0 +1,118 @@
+import { xglobal } from '@pezkuwi/x-global';
+import { formatDate } from './format/formatDate.js';
+import { isBn } from './is/bn.js';
+import { isBuffer } from './is/buffer.js';
+import { isFunction } from './is/function.js';
+import { isObject } from './is/object.js';
+import { isU8a } from './is/u8a.js';
+import { u8aToHex } from './u8a/toHex.js';
+import { u8aToU8a } from './u8a/toU8a.js';
+import { noop } from './noop.js';
+const logTo = {
+    debug: 'log',
+    error: 'error',
+    log: 'log',
+    warn: 'warn'
+};
+function formatOther(value) {
+    if (value && isObject(value) && value.constructor === Object) {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = loggerFormat(v);
+        }
+        return result;
+    }
+    return value;
+}
+export function loggerFormat(value) {
+    if (Array.isArray(value)) {
+        return value.map(loggerFormat);
+    }
+    else if (isBn(value)) {
+        return value.toString();
+    }
+    else if (isU8a(value) || isBuffer(value)) {
+        return u8aToHex(u8aToU8a(value));
+    }
+    return formatOther(value);
+}
+function formatWithLength(maxLength) {
+    return (v) => {
+        if (maxLength <= 0) {
+            return v;
+        }
+        const r = `${v}`;
+        return r.length < maxLength
+            ? v
+            : `${r.substring(0, maxLength)} ...`;
+    };
+}
+function apply(log, type, values, maxSize = -1) {
+    if (values.length === 1 && isFunction(values[0])) {
+        const fnResult = values[0]();
+        return apply(log, type, Array.isArray(fnResult) ? fnResult : [fnResult], maxSize);
+    }
+    console[logTo[log]](formatDate(new Date()), type, ...values
+        .map(loggerFormat)
+        .map(formatWithLength(maxSize)));
+}
+function isDebugOn(e, type) {
+    return !!e && (e === '*' ||
+        type === e ||
+        (e.endsWith('*') &&
+            type.startsWith(e.slice(0, -1))));
+}
+function isDebugOff(e, type) {
+    return !!e && (e.startsWith('-') &&
+        (type === e.slice(1) ||
+            (e.endsWith('*') &&
+                type.startsWith(e.slice(1, -1)))));
+}
+function getDebugFlag(env, type) {
+    let flag = false;
+    for (const e of env) {
+        if (isDebugOn(e, type)) {
+            flag = true;
+        }
+        else if (isDebugOff(e, type)) {
+            flag = false;
+        }
+    }
+    return flag;
+}
+function parseEnv(type) {
+    const maxSize = parseInt(xglobal.process?.env?.['DEBUG_MAX'] || '-1', 10);
+    return [
+        getDebugFlag((xglobal.process?.env?.['DEBUG'] || '').toLowerCase().split(','), type),
+        isNaN(maxSize)
+            ? -1
+            : maxSize
+    ];
+}
+/**
+ * @name Logger
+ * @summary Creates a consistent log interface for messages
+ * @description
+ * Returns a `Logger` that has `.log`, `.error`, `.warn` and `.debug` (controlled with environment `DEBUG=typeA,typeB`) methods. Logging is done with a consistent prefix (type of logger, date) followed by the actual message using the underlying console.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { logger } from '@pezkuwi/util';
+ *
+ * const l = logger('test');
+ * ```
+ */
+export function logger(origin) {
+    const type = `${origin.toUpperCase()}:`.padStart(16);
+    const [isDebug, maxSize] = parseEnv(origin.toLowerCase());
+    return {
+        debug: isDebug
+            ? (...values) => apply('debug', type, values, maxSize)
+            : noop,
+        error: (...values) => apply('error', type, values),
+        log: (...values) => apply('log', type, values),
+        noop,
+        warn: (...values) => apply('warn', type, values)
+    };
+}

package/memoize.d.ts

@@ -0,0 +1,10 @@
+import type { Memoized } from './types.js';
+interface Options {
+    getInstanceId?: () => string;
+}
+/**
+ * @name memoize
+ * @description Memomize the function with a specific instanceId
+ */
+export declare function memoize<T, F extends (...args: any[]) => T>(fn: F, { getInstanceId }?: Options): Memoized<F>;
+export {};

package/memoize.js

@@ -0,0 +1,30 @@
+import { stringify } from './stringify.js';
+function defaultGetId() {
+    return 'none';
+}
+/**
+ * @name memoize
+ * @description Memomize the function with a specific instanceId
+ */
+export function memoize(fn, { getInstanceId = defaultGetId } = {}) {
+    const cache = {};
+    const memoized = (...args) => {
+        const stringParams = stringify(args);
+        const instanceId = getInstanceId();
+        if (!cache[instanceId]) {
+            cache[instanceId] = {};
+        }
+        if (cache[instanceId][stringParams] === undefined) {
+            cache[instanceId][stringParams] = fn(...args);
+        }
+        return cache[instanceId][stringParams];
+    };
+    memoized.unmemoize = (...args) => {
+        const stringParams = stringify(args);
+        const instanceId = getInstanceId();
+        if (cache[instanceId]?.[stringParams] !== undefined) {
+            delete cache[instanceId][stringParams];
+        }
+    };
+    return memoized;
+}

package/nextTick.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name nextTick
+ * @description Defer the operation to the queue for evaluation on the next tick
+ */
+export declare function nextTick(onExec: () => unknown, onError?: (error: Error) => unknown): void;

package/nextTick.js

@@ -0,0 +1,24 @@
+/**
+ * @name nextTick
+ * @description Defer the operation to the queue for evaluation on the next tick
+ */
+export function nextTick(onExec, onError) {
+    // While Promise.resolve().then(...) would defer to the nextTick, this
+    // actually does not play as nicely in browsers like the setTimeout(...)
+    // approach. So the safer, though less optimal approach is the one taken here
+    setTimeout(() => {
+        Promise
+            .resolve()
+            .then(() => {
+            onExec();
+        })
+            .catch((error) => {
+            if (onError) {
+                onError(error);
+            }
+            else {
+                console.error(error);
+            }
+        });
+    }, 0);
+}

package/noop.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A sharable identity function. Returns the input as-is with no transformation applied.
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * A sharable noop function. As the name suggests, does nothing
+ */
+export declare function noop(): void;

package/noop.js

@@ -0,0 +1,12 @@
+/**
+ * A sharable identity function. Returns the input as-is with no transformation applied.
+ */
+export function identity(value) {
+    return value;
+}
+/**
+ * A sharable noop function. As the name suggests, does nothing
+ */
+export function noop() {
+    // noop
+}

package/number/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @summary Utility methods to convert to and from `number` values
+ */
+export { numberToHex } from './toHex.js';
+export { numberToU8a } from './toU8a.js';

package/number/index.js

@@ -0,0 +1,5 @@
+/**
+ * @summary Utility methods to convert to and from `number` values
+ */
+export { numberToHex } from './toHex.js';
+export { numberToU8a } from './toU8a.js';

package/number/toHex.d.ts

@@ -0,0 +1,17 @@
+import type { HexString } from '../types.js';
+/**
+ * @name numberToHex
+ * @summary Creates a hex value from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `0x` result. `number` input values return the actual bytes value converted to a `hex`. With `bitLength` set, it converts the number to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToHex } from '@polkadot/util';
+ *
+ * numberToHex(0x1234); // => '0x1234'
+ * numberToHex(0x1234, 32); // => 0x00001234
+ * ```
+ */
+export declare function numberToHex(value?: number | null, bitLength?: number): HexString;

package/{src/number/toHex.ts → number/toHex.js}

@@ -1,10 +1,4 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '../types.js';
-
 import { hexFixLength } from '../hex/fixLength.js';
-
 /**
  * @name numberToHex
  * @summary Creates a hex value from a number.
@@ -20,8 +14,7 @@ import { hexFixLength } from '../hex/fixLength.js';
  * numberToHex(0x1234, 32); // => 0x00001234
  * ```
  */
-export function numberToHex (value?: number | null, bitLength = -1): HexString {
-  const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
-
-  return hexFixLength(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
+export function numberToHex(value, bitLength = -1) {
+    const hex = (!value || Number.isNaN(value) ? 0 : value).toString(16);
+    return hexFixLength(hex.length % 2 ? `0${hex}` : hex, bitLength, true);
 }

package/number/toU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name numberToU8a
+ * @summary Creates a Uint8Array object from a number.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `number` input values return the actual bytes value converted to a `Uint8Array`. With `bitLength`, it converts the value to the equivalent size.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { numberToU8a } from '@polkadot/util';
+ *
+ * numberToU8a(0x1234); // => [0x12, 0x34]
+ * ```
+ */
+export declare function numberToU8a(value?: number | null, bitLength?: number): Uint8Array;

package/{src/number/toU8a.ts → number/toU8a.js}

@@ -1,9 +1,5 @@
-// Copyright 2017-2025 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { hexToU8a } from '../hex/toU8a.js';
 import { numberToHex } from './toHex.js';
-
 /**
  * @name numberToU8a
  * @summary Creates a Uint8Array object from a number.
@@ -18,8 +14,6 @@ import { numberToHex } from './toHex.js';
  * numberToU8a(0x1234); // => [0x12, 0x34]
  * ```
  */
-export function numberToU8a (value?: number | null, bitLength = -1): Uint8Array {
-  return hexToU8a(
-    numberToHex(value, bitLength)
-  );
+export function numberToU8a(value, bitLength = -1) {
+    return hexToU8a(numberToHex(value, bitLength));
 }

package/object/clear.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectClear
+ * @summary Removes all the keys from the input object
+ */
+export declare function objectClear<T>(value: Record<string, T>): Record<string, T>;

package/object/clear.js

@@ -0,0 +1,11 @@
+/**
+ * @name objectClear
+ * @summary Removes all the keys from the input object
+ */
+export function objectClear(value) {
+    const keys = Object.keys(value);
+    for (let i = 0, count = keys.length; i < count; i++) {
+        delete value[keys[i]];
+    }
+    return value;
+}

package/object/copy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name objectCopy
+ * @summary Creates a shallow clone of the input object
+ */
+export declare function objectCopy<T extends object>(source: T): T;

package/object/copy.js

@@ -0,0 +1,8 @@
+import { objectSpread } from './spread.js';
+/**
+ * @name objectCopy
+ * @summary Creates a shallow clone of the input object
+ */
+export function objectCopy(source) {
+    return objectSpread({}, source);
+}

package/object/entries.d.ts

@@ -0,0 +1,9 @@
+type Entries<T> = {
+    [K in keyof T]: [K, T[K]];
+}[keyof T][];
+/**
+ * @name objectEntries
+ * @summary A version of Object.entries that is typed for TS
+ */
+export declare function objectEntries<T extends object>(obj: T): Entries<T>;
+export {};