@pezkuwi/util 14.0.7 → 14.0.11

package/build-tsc-esm/compact/fromU8a.js

@@ -0,0 +1,88 @@
+import { BN } from '../bn/index.js';
+import { u8aToBn, u8aToU8a } from '../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
+ * ```
+ */
+export function compactFromU8a(input) {
+    const u8a = 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 BN(u8a[0] >>> 2)];
+        case 0b01:
+            return [2, new 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 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 BN(u8a[1] + (u8a[2] << 8) + (u8a[3] << 16) + (u8a[4] * 0x1_00_00_00))];
+                case 6:
+                    return [6, new 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 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, u8aToBn(u8a.subarray(1, offset))];
+            }
+        }
+    }
+}
+/**
+ * @name compactFromU8aLim
+ * @description A limited version of [[compactFromU8a]], accepting only Uint8Array inputs for values <= 48 bits
+ */
+export 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/build-tsc-esm/compact/index.js

@@ -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/build-tsc-esm/compact/stripLength.js

@@ -0,0 +1,21 @@
+import { compactFromU8a } from './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]]
+ * ```
+ */
+export function compactStripLength(input) {
+    const [offset, length] = compactFromU8a(input);
+    const total = offset + length.toNumber();
+    return [
+        total,
+        input.subarray(offset, total)
+    ];
+}

package/build-tsc-esm/compact/toU8a.js

@@ -0,0 +1,45 @@
+import { BN, BN_ONE, BN_TWO, bnToBn, bnToU8a } from '../bn/index.js';
+import { u8aConcatStrict } from '../u8a/index.js';
+const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
+const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
+const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(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])
+ * ```
+ */
+export function compactToU8a(value) {
+    const bn = bnToBn(value);
+    if (bn.lte(MAX_U8)) {
+        return new Uint8Array([bn.toNumber() << 2]);
+    }
+    else if (bn.lte(MAX_U16)) {
+        return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
+    }
+    else if (bn.lte(MAX_U32)) {
+        return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
+    }
+    const u8a = 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 u8aConcatStrict([
+        // subtract 4 as minimum (also catered for in decoding)
+        new Uint8Array([((length - 4) << 2) + 0b11]),
+        u8a.subarray(0, length)
+    ]);
+}

package/build-tsc-esm/compact/types.js

@@ -0,0 +1 @@
+export {};

package/build-tsc-esm/detectPackage.js

@@ -0,0 +1,96 @@
+import { xglobal } from '@pezkuwi/x-global';
+import { isFunction } from './is/function.js';
+const DEDUPE = 'Either remove and explicitly install matching versions or dedupe using your package manager.\nThe following conflicting packages were found:';
+export const POLKADOTJS_DISABLE_ESM_CJS_WARNING_FLAG = 'POLKADOTJS_DISABLE_ESM_CJS_WARNING';
+/** @internal */
+function getEntry(name) {
+    const _global = 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 (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.
+ */
+export 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 = xglobal.process?.env?.[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);
+        }
+    }
+}

package/build-tsc-esm/extractTime.js

@@ -0,0 +1,53 @@
+const MIN_MS = 60 * 1000;
+const HR_MS = MIN_MS * 60;
+const DAY_MS = HR_MS * 24;
+const ZERO = { days: 0, hours: 0, milliseconds: 0, minutes: 0, seconds: 0 };
+/** @internal */
+function add(a, b) {
+    return {
+        days: (a.days || 0) + b.days,
+        hours: (a.hours || 0) + b.hours,
+        milliseconds: (a.milliseconds || 0) + b.milliseconds,
+        minutes: (a.minutes || 0) + b.minutes,
+        seconds: (a.seconds || 0) + b.seconds
+    };
+}
+/** @internal */
+function extractSecs(ms) {
+    const s = ms / 1000;
+    if (s < 60) {
+        const seconds = ~~s;
+        return add({ seconds }, extractTime(ms - (seconds * 1000)));
+    }
+    const m = s / 60;
+    if (m < 60) {
+        const minutes = ~~m;
+        return add({ minutes }, extractTime(ms - (minutes * MIN_MS)));
+    }
+    const h = m / 60;
+    if (h < 24) {
+        const hours = ~~h;
+        return add({ hours }, extractTime(ms - (hours * HR_MS)));
+    }
+    const days = ~~(h / 24);
+    return add({ days }, extractTime(ms - (days * DAY_MS)));
+}
+/**
+ * @name extractTime
+ * @summary Convert a quantity of seconds to Time array representing accumulated {days, minutes, hours, seconds, milliseconds}
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { extractTime } from '@pezkuwi/util';
+ *
+ * const { days, minutes, hours, seconds, milliseconds } = extractTime(6000); // 0, 0, 10, 0, 0
+ * ```
+ */
+export function extractTime(milliseconds) {
+    return !milliseconds
+        ? ZERO
+        : milliseconds < 1000
+            ? add({ milliseconds }, ZERO)
+            : extractSecs(milliseconds);
+}

package/build-tsc-esm/float/index.js

@@ -0,0 +1 @@
+export { floatToU8a } from './toU8a.js';

package/build-tsc-esm/float/toU8a.js

@@ -0,0 +1,19 @@
+/**
+ * @name floatToU8a
+ * @description Converts a float into a U8a representation (While we don't use BE in SCALE
+ * we still allow for either representation, although, as elsewhere, isLe is default)
+ */
+export function floatToU8a(value = 0.0, { bitLength = 32, isLe = true } = {}) {
+    if (bitLength !== 32 && bitLength !== 64) {
+        throw new Error('Invalid bitLength provided, expected 32 or 64');
+    }
+    const result = new Uint8Array(bitLength / 8);
+    const dv = new DataView(result.buffer, result.byteOffset);
+    if (bitLength === 32) {
+        dv.setFloat32(0, Number(value), isLe);
+    }
+    else {
+        dv.setFloat64(0, Number(value), isLe);
+    }
+    return result;
+}

package/build-tsc-esm/format/formatBalance.js

@@ -0,0 +1,85 @@
+import { bnToBn } from '../bn/toBn.js';
+import { isBoolean } from '../is/boolean.js';
+import { formatDecimal } from './formatDecimal.js';
+import { getSeparator } from './getSeparator.js';
+import { calcSi, findSi, SI, SI_MID } from './si.js';
+const DEFAULT_DECIMALS = 0;
+const DEFAULT_UNIT = SI[SI_MID].text;
+let defaultDecimals = DEFAULT_DECIMALS;
+let defaultUnit = DEFAULT_UNIT;
+function _formatBalance(input, { decimals = defaultDecimals, forceUnit, locale = 'en', withAll = false, withSi = true, withSiFull = false, withUnit = true, withZero = true } = {}) {
+    // we only work with string inputs here - convert anything
+    // into the string-only value
+    let text = bnToBn(input).toString();
+    if (text.length === 0 || text === '0') {
+        return '0';
+    }
+    // strip the negative sign so we can work with clean groupings, re-add this in the
+    // end when we return the result (from here on we work with positive numbers)
+    let sign = '';
+    if (text[0].startsWith('-')) {
+        sign = '-';
+        text = text.substring(1);
+    }
+    // We start at midpoint (8) minus 1 - this means that values display as
+    // 123.4567 instead of 0.1234 k (so we always have the most relevant).
+    const si = calcSi(text, decimals, forceUnit);
+    const mid = text.length - (decimals + si.power);
+    const pre = mid <= 0 ? '0' : text.substring(0, mid);
+    // get the post from the midpoint onward and then first add max decimals
+    // before trimming to the correct (calculated) amount of decimals again
+    let post = text
+        .padStart(mid < 0 ? decimals : 1, '0')
+        .substring(mid < 0 ? 0 : mid)
+        .padEnd(withAll ? Math.max(decimals, 4) : 4, '0')
+        .substring(0, withAll ? Math.max(4, decimals + si.power) : 4);
+    // remove all trailing 0's (if required via flag)
+    if (!withZero) {
+        let end = post.length - 1;
+        // This looks inefficient, however it is better to do the checks and
+        // only make one final slice than it is to do it in multiples
+        do {
+            if (post[end] === '0') {
+                end--;
+            }
+        } while (post[end] === '0');
+        post = post.substring(0, end + 1);
+    }
+    // the display unit
+    const unit = isBoolean(withUnit)
+        ? SI[SI_MID].text
+        : withUnit;
+    // format the units for display based on the flags
+    const units = withSi || withSiFull
+        ? si.value === '-'
+            ? withUnit
+                ? ` ${unit}`
+                : ''
+            : ` ${withSiFull ? `${si.text}${withUnit ? ' ' : ''}` : si.value}${withUnit ? unit : ''}`
+        : '';
+    const { decimal, thousand } = getSeparator(locale);
+    return `${sign}${formatDecimal(pre, thousand)}${post && `${decimal}${post}`}${units}`;
+}
+export const formatBalance = _formatBalance;
+formatBalance.calcSi = (text, decimals = defaultDecimals) => calcSi(text, decimals);
+formatBalance.findSi = findSi;
+formatBalance.getDefaults = () => {
+    return {
+        decimals: defaultDecimals,
+        unit: defaultUnit
+    };
+};
+formatBalance.getOptions = (decimals = defaultDecimals) => {
+    return SI.filter(({ power }) => power < 0
+        ? (decimals + power) >= 0
+        : true);
+};
+formatBalance.setDefaults = ({ decimals, unit }) => {
+    defaultDecimals = (Array.isArray(decimals)
+        ? decimals[0]
+        : decimals) ?? defaultDecimals;
+    defaultUnit = (Array.isArray(unit)
+        ? unit[0]
+        : unit) ?? defaultUnit;
+    SI[SI_MID].text = defaultUnit;
+};

package/build-tsc-esm/format/formatDate.js

@@ -0,0 +1,17 @@
+/** @internal */
+function zeroPad(value) {
+    return value.toString().padStart(2, '0');
+}
+/**
+ * @name formatDate
+ * @description Formats a date in CCYY-MM-DD HH:MM:SS format
+ */
+export function formatDate(date) {
+    const year = date.getFullYear().toString();
+    const month = zeroPad((date.getMonth() + 1));
+    const day = zeroPad(date.getDate());
+    const hour = zeroPad(date.getHours());
+    const minute = zeroPad(date.getMinutes());
+    const second = zeroPad(date.getSeconds());
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}

package/build-tsc-esm/format/formatDecimal.js

@@ -0,0 +1,16 @@
+const NUMBER_REGEX = new RegExp('(\\d+?)(?=(\\d{3})+(?!\\d)|$)', 'g');
+/**
+ * @name formatDecimal
+ * @description Formats a number into string format with thousand separators
+ */
+export function formatDecimal(value, separator = ',') {
+    // We can do this by adjusting the regx, however for the sake of clarity
+    // we rather strip and re-add the negative sign in the output
+    const isNegative = value[0].startsWith('-');
+    const matched = isNegative
+        ? value.substring(1).match(NUMBER_REGEX)
+        : value.match(NUMBER_REGEX);
+    return matched
+        ? `${isNegative ? '-' : ''}${matched.join(separator)}`
+        : value;
+}

package/build-tsc-esm/format/formatElapsed.js

@@ -0,0 +1,27 @@
+import { bnToBn } from '../bn/toBn.js';
+/** @internal */
+function formatValue(elapsed) {
+    if (elapsed < 15) {
+        return `${elapsed.toFixed(1)}s`;
+    }
+    else if (elapsed < 60) {
+        return `${elapsed | 0}s`;
+    }
+    else if (elapsed < 3600) {
+        return `${elapsed / 60 | 0}m`;
+    }
+    return `${elapsed / 3600 | 0}h`;
+}
+/**
+ * @name formatElapsed
+ * @description Formats an elapsed value into s, m, h or day segments
+ */
+export function formatElapsed(now, value) {
+    const tsNow = now?.getTime() || 0;
+    const tsValue = value instanceof Date
+        ? value.getTime()
+        : bnToBn(value).toNumber();
+    return (tsNow && tsValue)
+        ? formatValue(Math.max(Math.abs(tsNow - tsValue), 0) / 1000)
+        : '0.0s';
+}

package/build-tsc-esm/format/formatNumber.js

@@ -0,0 +1,11 @@
+import { bnToBn } from '../bn/toBn.js';
+import { formatDecimal } from './formatDecimal.js';
+import { getSeparator } from './getSeparator.js';
+/**
+ * @name formatNumber
+ * @description Formats a number into string format with thousand separators
+ */
+export function formatNumber(value, { locale = 'en' } = {}) {
+    const { thousand } = getSeparator(locale);
+    return formatDecimal(bnToBn(value).toString(), thousand);
+}

package/build-tsc-esm/format/getSeparator.js

@@ -0,0 +1,11 @@
+/**
+ * Get the decimal and thousand separator of a locale
+ * @param locale
+ * @returns {decimal: string, thousand: string}
+ */
+export function getSeparator(locale) {
+    return {
+        decimal: (0.1).toLocaleString(locale, { useGrouping: false }).charAt(1),
+        thousand: (1000).toLocaleString(locale, { useGrouping: true }).replace(/\d/g, '').charAt(0)
+    };
+}

package/build-tsc-esm/format/index.js

@@ -0,0 +1,6 @@
+export { formatBalance } from './formatBalance.js';
+export { formatDate } from './formatDate.js';
+export { formatDecimal } from './formatDecimal.js';
+export { formatElapsed } from './formatElapsed.js';
+export { formatNumber } from './formatNumber.js';
+export { calcSi, findSi } from './si.js';

package/build-tsc-esm/format/si.js

@@ -0,0 +1,40 @@
+/** @internal */
+export const SI_MID = 8;
+/** @internal */
+export const SI = [
+    { power: -24, text: 'yocto', value: 'y' },
+    { power: -21, text: 'zepto', value: 'z' },
+    { power: -18, text: 'atto', value: 'a' },
+    { power: -15, text: 'femto', value: 'f' },
+    { power: -12, text: 'pico', value: 'p' },
+    { power: -9, text: 'nano', value: 'n' },
+    { power: -6, text: 'micro', value: 'µ' },
+    { power: -3, text: 'milli', value: 'm' },
+    { power: 0, text: 'Unit', value: '-' }, // position 8
+    { power: 3, text: 'Kilo', value: 'k' },
+    { power: 6, text: 'Mill', value: 'M' }, // Mega, M
+    { power: 9, text: 'Bill', value: 'B' }, // Giga, G
+    { power: 12, text: 'Tril', value: 'T' }, // Tera, T
+    { power: 15, text: 'Peta', value: 'P' },
+    { power: 18, text: 'Exa', value: 'E' },
+    { power: 21, text: 'Zeta', value: 'Z' },
+    { power: 24, text: 'Yotta', value: 'Y' }
+];
+/** @internal */
+export function findSi(type) {
+    // use a loop here, better RN support (which doesn't have [].find)
+    for (let i = 0, count = SI.length; i < count; i++) {
+        if (SI[i].value === type) {
+            return SI[i];
+        }
+    }
+    return SI[SI_MID];
+}
+/** @internal */
+export function calcSi(text, decimals, forceUnit) {
+    if (forceUnit) {
+        return findSi(forceUnit);
+    }
+    const siDefIndex = (SI_MID - 1) + Math.ceil((text.length - decimals) / 3);
+    return SI[siDefIndex] || SI[siDefIndex < 0 ? 0 : SI.length - 1];
+}

package/build-tsc-esm/has.js

@@ -0,0 +1,16 @@
+import { BigInt } from '@pezkuwi/x-bigint';
+import { xglobal } from '@pezkuwi/x-global';
+/** true if the environment has proper BigInt support */
+export const hasBigInt = typeof BigInt === 'function' && typeof BigInt.asIntN === 'function';
+/** true if the environment is CJS */
+export const hasCjs = typeof require === 'function' && typeof module !== 'undefined';
+/** true if the environment has __dirname available */
+export const hasDirname = typeof __dirname !== 'undefined';
+/** true if the environment is ESM */
+export const hasEsm = !hasCjs;
+/** true if the environment has WebAssembly available */
+export const hasWasm = typeof WebAssembly !== 'undefined';
+/** true if the environment has support for Buffer (typically Node.js) */
+export const hasBuffer = typeof xglobal.Buffer === 'function' && typeof xglobal.Buffer.isBuffer === 'function';
+/** true if the environment has process available (typically Node.js) */
+export const hasProcess = typeof xglobal.process === 'object';

package/build-tsc-esm/hex/addPrefix.js

@@ -0,0 +1,20 @@
+import { hexHasPrefix } from './hasPrefix.js';
+/**
+ * @name hexAddPrefix
+ * @summary Adds the `0x` prefix to string values.
+ * @description
+ * Returns a `0x` prefixed string from the input value. If the input is already prefixed, it is returned unchanged.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexAddPrefix } from '@pezkuwi/util';
+ *
+ * console.log('With prefix', hexAddPrefix('0a0b12')); // => 0x0a0b12
+ * ```
+ */
+export function hexAddPrefix(value) {
+    return value && hexHasPrefix(value)
+        ? value
+        : `0x${value && value.length % 2 === 1 ? '0' : ''}${value || ''}`;
+}

package/build-tsc-esm/hex/fixLength.js

@@ -0,0 +1,27 @@
+import { hexAddPrefix } from './addPrefix.js';
+import { hexStripPrefix } from './stripPrefix.js';
+/**
+ * @name hexFixLength
+ * @summary Shifts a hex string to a specific bitLength
+ * @description
+ * Returns a `0x` prefixed string with the specified number of bits contained in the return value. (If bitLength is -1, length checking is not done). Values with more bits are trimmed to the specified length. Input values with less bits are returned as-is by default. When `withPadding` is set, shorter values are padded with `0`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexFixLength } from '@pezkuwi/util';
+ *
+ * console.log('fixed', hexFixLength('0x12', 16)); // => 0x12
+ * console.log('fixed', hexFixLength('0x12', 16, true)); // => 0x0012
+ * console.log('fixed', hexFixLength('0x0012', 8)); // => 0x12
+ * ```
+ */
+export function hexFixLength(value, bitLength = -1, withPadding = false) {
+    const strLength = Math.ceil(bitLength / 4);
+    const hexLength = strLength + 2;
+    return hexAddPrefix((bitLength === -1 || value.length === hexLength || (!withPadding && value.length < hexLength))
+        ? hexStripPrefix(value)
+        : (value.length > hexLength)
+            ? hexStripPrefix(value).slice(-1 * strLength)
+            : `${'0'.repeat(strLength)}${hexStripPrefix(value)}`.slice(-1 * strLength));
+}

package/build-tsc-esm/hex/hasPrefix.js

@@ -0,0 +1,18 @@
+import { isHex } from '../is/hex.js';
+/**
+ * @name hexHasPrefix
+ * @summary Tests for the existence of a `0x` prefix.
+ * @description
+ * Checks for a valid hex input value and if the start matched `0x`
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexHasPrefix } from '@pezkuwi/util';
+ *
+ * console.log('has prefix', hexHasPrefix('0x1234')); // => true
+ * ```
+ */
+export function hexHasPrefix(value) {
+    return !!value && isHex(value, -1);
+}