@pezkuwi/util 14.0.10 → 14.0.12

package/cjs/bn/toHex.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bnToHex = bnToHex;
+const index_js_1 = require("../u8a/index.js");
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name bnToHex
+ * @summary Creates a hex value from a BN.js bignumber object.
+ * @description
+ * `null` inputs returns a `0x` result, BN values return the actual value as a `0x` prefixed hex value. Anything that is not a BN object throws an error. With `bitLength` set, it fixes the number to the specified length.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToHex } from '@pezkuwi/util';
+ *
+ * bnToHex(new BN(0x123456)); // => '0x123456'
+ * ```
+ */
+function bnToHex(value, { bitLength = -1, isLe = false, isNegative = false } = {}) {
+    return (0, index_js_1.u8aToHex)((0, toU8a_js_1.bnToU8a)(value, { bitLength, isLe, isNegative }));
+}

package/cjs/bn/toU8a.d.ts

@@ -0,0 +1,17 @@
+import type { NumberOptions, ToBn } from '../types.js';
+import type { BN } from './bn.js';
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@pezkuwi/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+export declare function bnToU8a<ExtToBn extends ToBn>(value?: ExtToBn | BN | bigint | number | null, { bitLength, isLe, isNegative }?: NumberOptions): Uint8Array;

package/cjs/bn/toU8a.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bnToU8a = bnToU8a;
+const toBn_js_1 = require("./toBn.js");
+const DEFAULT_OPTS = { bitLength: -1, isLe: true, isNegative: false };
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@pezkuwi/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+    const valueBn = (0, toBn_js_1.bnToBn)(value);
+    const byteLength = bitLength === -1
+        ? Math.ceil(valueBn.bitLength() / 8)
+        : Math.ceil((bitLength || 0) / 8);
+    if (!value) {
+        return bitLength === -1
+            ? new Uint8Array(1)
+            : new Uint8Array(byteLength);
+    }
+    const output = new Uint8Array(byteLength);
+    const bn = isNegative
+        ? valueBn.toTwos(byteLength * 8)
+        : valueBn;
+    output.set(bn.toArray(isLe ? 'le' : 'be', byteLength), 0);
+    return output;
+}

package/cjs/buffer/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Utility methods to convert to and from `Buffer` objects
+ */
+export { bufferToU8a } from './toU8a.js';

package/cjs/buffer/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToU8a = void 0;
+/**
+ * @summary Utility methods to convert to and from `Buffer` objects
+ */
+var toU8a_js_1 = require("./toU8a.js");
+Object.defineProperty(exports, "bufferToU8a", { enumerable: true, get: function () { return toU8a_js_1.bufferToU8a; } });

package/cjs/buffer/toU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name bufferToU8a
+ * @summary Creates a Uint8Array value from a Buffer object.
+ * @description
+ * `null` inputs returns an empty result, `Buffer` values return the actual value as a `Uint8Array`. Anything that is not a `Buffer` object throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bufferToU8a } from '@pezkuwi/util';
+ *
+ * bufferToU8a(Buffer.from([1, 2, 3]));
+ * ```
+ */
+export declare function bufferToU8a(buffer?: Uint8Array | number[] | null): Uint8Array;

package/cjs/buffer/toU8a.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferToU8a = bufferToU8a;
+/**
+ * @name bufferToU8a
+ * @summary Creates a Uint8Array value from a Buffer object.
+ * @description
+ * `null` inputs returns an empty result, `Buffer` values return the actual value as a `Uint8Array`. Anything that is not a `Buffer` object throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bufferToU8a } from '@pezkuwi/util';
+ *
+ * bufferToU8a(Buffer.from([1, 2, 3]));
+ * ```
+ */
+function bufferToU8a(buffer) {
+    return new Uint8Array(buffer || []);
+}

package/cjs/bundle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @summary Utility methods for this package are split into groups
+ */
+export { packageInfo } from './packageInfo.js';
+export * from './array/index.js';
+export * from './assert.js';
+export * from './bi/index.js';
+export * from './bn/index.js';
+export * from './buffer/index.js';
+export * from './compact/index.js';
+export * from './detectPackage.js';
+export * from './extractTime.js';
+export * from './float/index.js';
+export * from './format/index.js';
+export * from './has.js';
+export * from './hex/index.js';
+export * from './is/index.js';
+export * from './lazy.js';
+export * from './logger.js';
+export * from './memoize.js';
+export * from './nextTick.js';
+export * from './noop.js';
+export * from './number/index.js';
+export * from './object/index.js';
+export * from './promisify.js';
+export * from './string/index.js';
+export * from './stringify.js';
+export * from './u8a/index.js';

package/cjs/bundle.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+const tslib_1 = require("tslib");
+/**
+ * @summary Utility methods for this package are split into groups
+ */
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+tslib_1.__exportStar(require("./array/index.js"), exports);
+tslib_1.__exportStar(require("./assert.js"), exports);
+tslib_1.__exportStar(require("./bi/index.js"), exports);
+tslib_1.__exportStar(require("./bn/index.js"), exports);
+tslib_1.__exportStar(require("./buffer/index.js"), exports);
+tslib_1.__exportStar(require("./compact/index.js"), exports);
+tslib_1.__exportStar(require("./detectPackage.js"), exports);
+tslib_1.__exportStar(require("./extractTime.js"), exports);
+tslib_1.__exportStar(require("./float/index.js"), exports);
+tslib_1.__exportStar(require("./format/index.js"), exports);
+tslib_1.__exportStar(require("./has.js"), exports);
+tslib_1.__exportStar(require("./hex/index.js"), exports);
+tslib_1.__exportStar(require("./is/index.js"), exports);
+tslib_1.__exportStar(require("./lazy.js"), exports);
+tslib_1.__exportStar(require("./logger.js"), exports);
+tslib_1.__exportStar(require("./memoize.js"), exports);
+tslib_1.__exportStar(require("./nextTick.js"), exports);
+tslib_1.__exportStar(require("./noop.js"), exports);
+tslib_1.__exportStar(require("./number/index.js"), exports);
+tslib_1.__exportStar(require("./object/index.js"), exports);
+tslib_1.__exportStar(require("./promisify.js"), exports);
+tslib_1.__exportStar(require("./string/index.js"), exports);
+tslib_1.__exportStar(require("./stringify.js"), exports);
+tslib_1.__exportStar(require("./u8a/index.js"), exports);

package/cjs/compact/addLength.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name compactAddLength
+ * @description Adds a length prefix to the input value
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactAddLength } from '@pezkuwi/util';
+ *
+ * console.log(compactAddLength(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))); // Uint8Array([4 << 2, 0xde, 0xad, 0xbe, 0xef])
+ * ```
+ */
+export declare function compactAddLength(input: Uint8Array): Uint8Array;

package/cjs/compact/addLength.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactAddLength = compactAddLength;
+const index_js_1 = require("../u8a/index.js");
+const toU8a_js_1 = require("./toU8a.js");
+/**
+ * @name compactAddLength
+ * @description Adds a length prefix to the input value
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactAddLength } from '@pezkuwi/util';
+ *
+ * console.log(compactAddLength(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))); // Uint8Array([4 << 2, 0xde, 0xad, 0xbe, 0xef])
+ * ```
+ */
+function compactAddLength(input) {
+    return (0, index_js_1.u8aConcatStrict)([
+        (0, toU8a_js_1.compactToU8a)(input.length),
+        input
+    ]);
+}

package/cjs/compact/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { BitLength } from './types.js';
+/** @internal */
+export declare const DEFAULT_BITLENGTH: BitLength;

package/cjs/compact/defaults.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BITLENGTH = void 0;
+/** @internal */
+exports.DEFAULT_BITLENGTH = 32;

package/cjs/compact/fromU8a.d.ts

@@ -0,0 +1,22 @@
+import type { U8aLike } from '../types.js';
+import { BN } from '../bn/index.js';
+/**
+ * @name compactFromU8a
+ * @description Retrives the offset and encoded length from a compact-prefixed value
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactFromU8a } from '@pezkuwi/util';
+ *
+ * const [offset, length] = compactFromU8a(new Uint8Array([254, 255, 3, 0]));
+ *
+ * console.log('value offset=', offset, 'length=', length); // 4, 0xffff
+ * ```
+ */
+export declare function compactFromU8a(input: U8aLike): [number, BN];
+/**
+ * @name compactFromU8aLim
+ * @description A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits
+ */
+export declare function compactFromU8aLim(u8a: Uint8Array): [number, number];

package/cjs/compact/fromU8a.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactFromU8a = compactFromU8a;
+exports.compactFromU8aLim = compactFromU8aLim;
+const index_js_1 = require("../bn/index.js");
+const index_js_2 = require("../u8a/index.js");
+/**
+ * @name compactFromU8a
+ * @description Retrives the offset and encoded length from a compact-prefixed value
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactFromU8a } from '@pezkuwi/util';
+ *
+ * const [offset, length] = compactFromU8a(new Uint8Array([254, 255, 3, 0]));
+ *
+ * console.log('value offset=', offset, 'length=', length); // 4, 0xffff
+ * ```
+ */
+function compactFromU8a(input) {
+    const u8a = (0, index_js_2.u8aToU8a)(input);
+    // The u8a is manually converted here for 1, 2 & 4 lengths, it is 2x faster
+    // than doing an additional call to u8aToBn (as with variable length)
+    switch (u8a[0] & 0b11) {
+        case 0b00:
+            return [1, new index_js_1.BN(u8a[0] >>> 2)];
+        case 0b01:
+            return [2, new index_js_1.BN((u8a[0] + (u8a[1] << 8)) >>> 2)];
+        case 0b10:
+            // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
+            // 32-bit, in the case where the top-most bit is set this yields a negative value
+            return [4, new index_js_1.BN((u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2)];
+        // 0b11
+        default: {
+            // add 5 to shifted (4 for base length, 1 for this byte)
+            const offset = (u8a[0] >>> 2) + 5;
+            // we unroll the loop
+            switch (offset) {
+                // there still could be 4 bytes data, similar to 0b10 above (with offsets)
+                case 5:
+                    // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
+                    // 32-bit, in the case where the top-most bit is set this yields a negative value
+                    return [5, new index_js_1.BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00))];
+                case 6:
+                    return [6, new index_js_1.BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00))];
+                // 6 bytes data is the maximum, 48 bits (56 would overflow)
+                case 7:
+                    return [7, new index_js_1.BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00))];
+                // for anything else, use the non-unrolled version
+                default:
+                    return [offset, (0, index_js_2.u8aToBn)(u8a.subarray(1, offset))];
+            }
+        }
+    }
+}
+/**
+ * @name compactFromU8aLim
+ * @description A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits
+ */
+function compactFromU8aLim(u8a) {
+    // The u8a is manually converted here for 1, 2 & 4 lengths, it is 2x faster
+    // than doing an additional call to u8aToBn (as with variable length)
+    switch (u8a[0] & 0b11) {
+        case 0b00:
+            return [1, u8a[0] >>> 2];
+        case 0b01:
+            return [2, (u8a[0] + (u8a[1] << 8)) >>> 2];
+        case 0b10:
+            // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
+            // 32-bit, in the case where the top-most bit is set this yields a negative value
+            return [4, (u8a[0] + (u8a[1] << 8) + (u8a[2] << 16) + (u8a[3] * 0x1_00_00_00)) >>> 2];
+        // 0b11
+        default: {
+            // add 5 to shifted (4 for base length, 1 for this byte)
+            // we unroll the loop
+            switch ((u8a[0] >>> 2) + 5) {
+                // there still could be 4 bytes data, similar to 0b10 above (with offsets)
+                case 5:
+                    return [5, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00)];
+                case 6:
+                    return [6, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8)) * 0x1_00_00_00)];
+                // 6 bytes data is the maximum, 48 bits (56 would overflow)
+                case 7:
+                    return [7, u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + ((u8a[4] + (u8a[5] << 8) + (u8a[6] << 16)) * 0x1_00_00_00)];
+                // for anything else, we are above the actual MAX_SAFE_INTEGER - bail out
+                default:
+                    throw new Error('Compact input is > Number.MAX_SAFE_INTEGER');
+            }
+        }
+    }
+}

package/cjs/compact/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @description
+ * Encoding and decoding of parity-codec compact numbers. The codec is created
+ * to take up the least amount of space for a specific number. It performs the
+ * same function as Length, however differs in that it uses a variable number of
+ * bytes to do the actual encoding. From the Rust implementation for compact
+ * encoding:
+ *
+ *     0b00 00 00 00 / 00 00 00 00 / 00 00 00 00 / 00 00 00 00
+ * (0 ... 2**6 - 1)    (u8)
+ *     xx xx xx 00
+ * (2**6 ... 2**14 - 1)  (u8, u16)  low LH high
+ *     yL yL yL 01 / yH yH yH yL
+ * (2**14 ... 2**30 - 1)  (u16, u32)  low LMMH high
+ *     zL zL zL 10 / zM zM zM zL / zM zM zM zM / zH zH zH zM
+ * (2**30 ... 2**536 - 1)  (u32, u64, u128, U256, U512, U520) straight LE-encoded
+ *     nn nn nn 11 [ / zz zz zz zz ]{4 + n}
+ *
+ * Note: we use *LOW BITS* of the LSB in LE encoding to encode the 2 bit key.
+ */
+export { compactAddLength } from './addLength.js';
+export { compactFromU8a, compactFromU8aLim } from './fromU8a.js';
+export { compactStripLength } from './stripLength.js';
+export { compactToU8a } from './toU8a.js';

package/cjs/compact/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactToU8a = exports.compactStripLength = exports.compactFromU8aLim = exports.compactFromU8a = exports.compactAddLength = void 0;
+/**
+ * @description
+ * Encoding and decoding of parity-codec compact numbers. The codec is created
+ * to take up the least amount of space for a specific number. It performs the
+ * same function as Length, however differs in that it uses a variable number of
+ * bytes to do the actual encoding. From the Rust implementation for compact
+ * encoding:
+ *
+ *     0b00 00 00 00 / 00 00 00 00 / 00 00 00 00 / 00 00 00 00
+ * (0 ... 2**6 - 1)    (u8)
+ *     xx xx xx 00
+ * (2**6 ... 2**14 - 1)  (u8, u16)  low LH high
+ *     yL yL yL 01 / yH yH yH yL
+ * (2**14 ... 2**30 - 1)  (u16, u32)  low LMMH high
+ *     zL zL zL 10 / zM zM zM zL / zM zM zM zM / zH zH zH zM
+ * (2**30 ... 2**536 - 1)  (u32, u64, u128, U256, U512, U520) straight LE-encoded
+ *     nn nn nn 11 [ / zz zz zz zz ]{4 + n}
+ *
+ * Note: we use *LOW BITS* of the LSB in LE encoding to encode the 2 bit key.
+ */
+var addLength_js_1 = require("./addLength.js");
+Object.defineProperty(exports, "compactAddLength", { enumerable: true, get: function () { return addLength_js_1.compactAddLength; } });
+var fromU8a_js_1 = require("./fromU8a.js");
+Object.defineProperty(exports, "compactFromU8a", { enumerable: true, get: function () { return fromU8a_js_1.compactFromU8a; } });
+Object.defineProperty(exports, "compactFromU8aLim", { enumerable: true, get: function () { return fromU8a_js_1.compactFromU8aLim; } });
+var stripLength_js_1 = require("./stripLength.js");
+Object.defineProperty(exports, "compactStripLength", { enumerable: true, get: function () { return stripLength_js_1.compactStripLength; } });
+var toU8a_js_1 = require("./toU8a.js");
+Object.defineProperty(exports, "compactToU8a", { enumerable: true, get: function () { return toU8a_js_1.compactToU8a; } });

package/cjs/compact/stripLength.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name compactStripLength
+ * @description Removes the length prefix, returning both the total length (including the value + compact encoding) and the decoded value with the correct length
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactStripLength } from '@pezkuwi/util';
+ *
+ * console.log(compactStripLength(new Uint8Array([2 << 2, 0xde, 0xad]))); // [2, Uint8Array[0xde, 0xad]]
+ * ```
+ */
+export declare function compactStripLength(input: Uint8Array): [number, Uint8Array];

package/cjs/compact/stripLength.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactStripLength = compactStripLength;
+const fromU8a_js_1 = require("./fromU8a.js");
+/**
+ * @name compactStripLength
+ * @description Removes the length prefix, returning both the total length (including the value + compact encoding) and the decoded value with the correct length
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactStripLength } from '@pezkuwi/util';
+ *
+ * console.log(compactStripLength(new Uint8Array([2 << 2, 0xde, 0xad]))); // [2, Uint8Array[0xde, 0xad]]
+ * ```
+ */
+function compactStripLength(input) {
+    const [offset, length] = (0, fromU8a_js_1.compactFromU8a)(input);
+    const total = offset + length.toNumber();
+    return [
+        total,
+        input.subarray(offset, total)
+    ];
+}

package/cjs/compact/toU8a.d.ts

@@ -0,0 +1,14 @@
+import { BN } from '../bn/index.js';
+/**
+ * @name compactToU8a
+ * @description Encodes a number into a compact representation
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactToU8a } from '@pezkuwi/util';
+ *
+ * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
+ * ```
+ */
+export declare function compactToU8a(value: BN | bigint | number): Uint8Array;

package/cjs/compact/toU8a.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactToU8a = compactToU8a;
+const index_js_1 = require("../bn/index.js");
+const index_js_2 = require("../u8a/index.js");
+const MAX_U8 = index_js_1.BN_TWO.pow(new index_js_1.BN(8 - 2)).isub(index_js_1.BN_ONE);
+const MAX_U16 = index_js_1.BN_TWO.pow(new index_js_1.BN(16 - 2)).isub(index_js_1.BN_ONE);
+const MAX_U32 = index_js_1.BN_TWO.pow(new index_js_1.BN(32 - 2)).isub(index_js_1.BN_ONE);
+const BL_16 = { bitLength: 16 };
+const BL_32 = { bitLength: 32 };
+/**
+ * @name compactToU8a
+ * @description Encodes a number into a compact representation
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactToU8a } from '@pezkuwi/util';
+ *
+ * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
+ * ```
+ */
+function compactToU8a(value) {
+    const bn = (0, index_js_1.bnToBn)(value);
+    if (bn.lte(MAX_U8)) {
+        return new Uint8Array([bn.toNumber() << 2]);
+    }
+    else if (bn.lte(MAX_U16)) {
+        return (0, index_js_1.bnToU8a)(bn.shln(2).iadd(index_js_1.BN_ONE), BL_16);
+    }
+    else if (bn.lte(MAX_U32)) {
+        return (0, index_js_1.bnToU8a)(bn.shln(2).iadd(index_js_1.BN_TWO), BL_32);
+    }
+    const u8a = (0, index_js_1.bnToU8a)(bn);
+    let length = u8a.length;
+    // adjust to the minimum number of bytes
+    while (u8a[length - 1] === 0) {
+        length--;
+    }
+    if (length < 4) {
+        throw new Error('Invalid length, previous checks match anything less than 2^30');
+    }
+    return (0, index_js_2.u8aConcatStrict)([
+        // subtract 4 as minimum (also catered for in decoding)
+        new Uint8Array([((length - 4) << 2) + 0b11]),
+        u8a.subarray(0, length)
+    ]);
+}

package/cjs/compact/types.d.ts

@@ -0,0 +1 @@
+export type BitLength = 8 | 16 | 32 | 64 | 128 | 256;

package/cjs/compact/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/detectPackage.d.ts

@@ -0,0 +1,17 @@
+interface VersionPath {
+    path: string;
+    type: string;
+    version: string;
+}
+interface PackageInfo extends VersionPath {
+    name: string;
+}
+type FnString = () => string | undefined;
+export declare const POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = "POLKADOTJS_DISABLE_ESM_CJS_WARNING";
+/**
+ * @name detectPackage
+ * @summary Checks that a specific package is only imported once
+ * @description A `@pezkuwi/*` version detection utility, checking for one occurrence of a package in addition to checking for dependency versions.
+ */
+export declare function detectPackage({ name, path, type, version }: PackageInfo, pathOrFn?: FnString | string | false | null, deps?: PackageInfo[]): void;
+export {};

package/cjs/detectPackage.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = void 0;
+exports.detectPackage = detectPackage;
+const x_global_1 = require("@pezkuwi/x-global");
+const function_js_1 = require("./is/function.js");
+const DEDUPE = 'Either remove and explicitly install matching versions or dedupe using your package manager.\nThe following conflicting packages were found:';
+exports.POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = 'POLKADOTJS_DISABLE_ESM_CJS_WARNING';
+/** @internal */
+function getEntry(name) {
+    const _global = x_global_1.xglobal;
+    if (!_global.__polkadotjs) {
+        _global.__polkadotjs = {};
+    }
+    if (!_global.__polkadotjs[name]) {
+        _global.__polkadotjs[name] = [];
+    }
+    return _global.__polkadotjs[name];
+}
+/** @internal */
+function formatDisplay(all, fmt) {
+    let max = 0;
+    for (let i = 0, count = all.length; i < count; i++) {
+        max = Math.max(max, all[i].version.length);
+    }
+    return all
+        .map((d) => `\t${fmt(d.version.padEnd(max), d).join('\t')}`)
+        .join('\n');
+}
+/** @internal */
+function formatInfo(version, { name }) {
+    return [
+        version,
+        name
+    ];
+}
+/** @internal */
+function formatVersion(version, { path, type }) {
+    let extracted;
+    if (path && path.length >= 5) {
+        const nmIndex = path.indexOf('node_modules');
+        extracted = nmIndex === -1
+            ? path
+            : path.substring(nmIndex);
+    }
+    else {
+        extracted = '<unknown>';
+    }
+    return [
+        `${`${type || ''}`.padStart(3)} ${version}`,
+        extracted
+    ];
+}
+/** @internal */
+function getPath(infoPath, pathOrFn) {
+    if (infoPath) {
+        return infoPath;
+    }
+    else if ((0, function_js_1.isFunction)(pathOrFn)) {
+        try {
+            return pathOrFn() || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    return pathOrFn || '';
+}
+/** @internal */
+function warn(pre, all, fmt) {
+    console.warn(`${pre}\n${DEDUPE}\n${formatDisplay(all, fmt)}`);
+}
+/**
+ * @name detectPackage
+ * @summary Checks that a specific package is only imported once
+ * @description A `@pezkuwi/*` version detection utility, checking for one occurrence of a package in addition to checking for dependency versions.
+ */
+function detectPackage({ name, path, type, version }, pathOrFn, deps = []) {
+    if (!name.startsWith('@pezkuwi')) {
+        throw new Error(`Invalid package descriptor ${name}`);
+    }
+    const entry = getEntry(name);
+    entry.push({ path: getPath(path, pathOrFn), type, version });
+    // if we have more than one entry at DIFFERENT version types then warn. If there is
+    // more than one entry at the same version and ESM/CJS dual warnings are disabled,
+    // then do not display warnings
+    const entriesSameVersion = entry.every((e) => e.version === version);
+    const esmCjsWarningDisabled = x_global_1.xglobal.process?.env?.[exports.POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG] === '1';
+    const multipleEntries = entry.length !== 1;
+    const disableWarnings = esmCjsWarningDisabled && entriesSameVersion;
+    if (multipleEntries && !disableWarnings) {
+        warn(`${name} has multiple versions, ensure that there is only one installed.`, entry, formatVersion);
+    }
+    else {
+        const mismatches = deps.filter((d) => d && d.version !== version);
+        if (mismatches.length) {
+            warn(`${name} requires direct dependencies exactly matching version ${version}.`, mismatches, formatInfo);
+        }
+    }
+}