@pezkuwi/util 14.0.6 → 14.0.7

package/build-deno/u8a/toBn.ts

@@ -1,99 +0,0 @@
-
-import type { ToBnOptions } from '../types.ts';
-
-import { BN } from '../bn/bn.ts';
-
-/**
- * @name u8aToBn
- * @summary Creates a BN from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual BN. `null` or `undefined` values returns an `0x0` value.
- * @param value The value to convert
- * @param options Options to pass while converting
- * @param options.isLe Convert using Little Endian (default)
- * @param options.isNegative Convert using two's complement
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToBn (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): BN {
-  // slice + reverse is expensive, however SCALE is LE by default so this is the path
-  // we are most interested in (the BE is added for the sake of being comprehensive)
-  if (!isLe) {
-    value = value.slice().reverse();
-  }
-
-  const count = value.length;
-
-  // shortcut for <= u48 values - in this case the manual conversion
-  // here seems to be more efficient than passing the full array
-  if (isNegative && count && (value[count - 1] & 0x80)) {
-    // Most common case i{8, 16, 32} default LE SCALE-encoded
-    // For <= 32, we also optimize the xor to a single op
-    switch (count) {
-      case 0:
-        return new BN(0);
-
-      case 1:
-        return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
-
-      case 2:
-        return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-
-      case 3:
-        return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
-
-      case 4:
-        // 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 new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-
-      case 5:
-        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      case 6:
-        return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      default:
-        return new BN(value, 'le').fromTwos(count * 8);
-    }
-  }
-
-  // Most common case - u{8, 16, 32} default LE SCALE-encoded
-  //
-  // There are some slight benefits in unrolling this specific loop,
-  // however it comes with diminishing returns since here the actual
-  // `new BN` does seem to take up the bulk of the time
-  switch (count) {
-    case 0:
-      return new BN(0);
-
-    case 1:
-      return new BN(value[0]);
-
-    case 2:
-      return new BN(value[0] + (value[1] << 8));
-
-    case 3:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
-
-    case 4:
-      // 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 new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
-
-    case 5:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
-
-    case 6:
-      return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
-
-    default:
-      return new BN(value, 'le');
-  }
-}

package/build-deno/u8a/toBuffer.ts

@@ -1,28 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { BufferClass, BufferObject } from '../types.ts';
-
-import { xglobal } from 'https://deno.land/x/pezkuwi/x-global/mod.ts';
-
-import { hasBuffer } from '../has.ts';
-
-/**
- * @name u8aToBuffer
- * @summary Creates a Buffer object from a hex string.
- * @description
- * `null` inputs returns an empty `Buffer` result. `UInt8Array` input values return the actual bytes value converted to a `Buffer`. Anything that is not a `UInt8Array` throws an error.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBuffer } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * console.log('Buffer', u8aToBuffer(new Uint8Array([1, 2, 3])));
- * ```
- */
-export function u8aToBuffer <T = BufferObject> (value?: Uint8Array | null): T {
-  return hasBuffer
-    ? (xglobal.Buffer as unknown as BufferClass).from(value || [])
-    : new Uint8Array(value || []) as T;
-}

package/build-deno/u8a/toFloat.ts

@@ -1,24 +0,0 @@
-
-interface Options {
-  bitLength?: 32 | 64;
-  isLe?: boolean;
-}
-
-/**
- * @name u8aToFloat
- * @description Converts a Uint8Array value into the float (either 32 or 64-bit)
- * representation.
- */
-export function u8aToFloat (value: Uint8Array, { bitLength = 32, isLe = true }: Options = {}): number {
-  if (bitLength !== 32 && bitLength !== 64) {
-    throw new Error('Invalid bitLength provided, expected 32 or 64');
-  } else if (value.length < (bitLength / 8)) {
-    throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
-  }
-
-  const dv = new DataView(value.buffer, value.byteOffset);
-
-  return bitLength === 32
-    ? dv.getFloat32(0, isLe)
-    : dv.getFloat64(0, isLe);
-}

package/build-deno/u8a/toHex.ts

@@ -1,66 +0,0 @@
-
-import type { HexString } from '../types.ts';
-
-const U8 = new Array<string>(256);
-const U16 = new Array<string>(256 * 256);
-
-for (let n = 0; n < 256; n++) {
-  U8[n] = n.toString(16).padStart(2, '0');
-}
-
-for (let i = 0; i < 256; i++) {
-  const s = i << 8;
-
-  for (let j = 0; j < 256; j++) {
-    U16[s | j] = U8[i] + U8[j];
-  }
-}
-
-/** @internal */
-function hex (value: Uint8Array, result: HexString): HexString {
-  const mod = (value.length % 2) | 0;
-  const length = (value.length - mod) | 0;
-
-  for (let i = 0; i < length; i += 2) {
-    result += U16[(value[i] << 8) | value[i + 1]];
-  }
-
-  if (mod) {
-    result += U8[value[length] | 0];
-  }
-
-  return result;
-}
-
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToHex (value?: Uint8Array | null, bitLength = -1, isPrefixed = true): HexString {
-  // this is not 100% correct sinmce we support isPrefixed = false....
-  const empty = isPrefixed
-    ? '0x'
-    : '' as HexString;
-
-  if (!value?.length) {
-    return empty;
-  } else if (bitLength > 0) {
-    const length = Math.ceil(bitLength / 8);
-
-    if (value.length > length) {
-      return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '' as HexString)}`;
-    }
-  }
-
-  return hex(value, empty);
-}

package/build-deno/u8a/toHexBuffer.ts

@@ -1,30 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { HexString } from '../types.ts';
-
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-export function u8aToHex (value?: Uint8Array | null, bitLength = -1, isPrefixed = true): HexString {
-  const length = Math.ceil(bitLength / 8);
-
-  return `${isPrefixed ? '0x' : ''}${
-    !value?.length
-      ? ''
-      : (bitLength > 0 && value.length > length)
-        ? `${Buffer.from(value.subarray(0, length / 2)).toString('hex')}…${Buffer.from(value.subarray(value.length - length / 2)).toString('hex')}`
-        : Buffer.from(value).toString('hex')
-  }` as HexString;
-}

package/build-deno/u8a/toNumber.ts

@@ -1,78 +0,0 @@
-
-import type { ToBnOptions } from '../types.ts';
-
-/**
- * @name u8aToNumber
- * @summary Creates a number from a Uint8Array object.
- */
-export function u8aToNumber (value: Uint8Array, { isLe = true, isNegative = false }: ToBnOptions = {}): number {
-  // slice + reverse is expensive, however SCALE is LE by default so this is the path
-  // we are most interested in (the BE is added for the sake of being comprehensive)
-  if (!isLe) {
-    value = value.slice().reverse();
-  }
-
-  const count = value.length;
-
-  // When the value is a i{8, 16, 24, 32, 40, 40} values and the top-most bit
-  // indicates a signed value, we use a two's complement conversion. If one of these
-  // flags are not set, we just do a normal unsigned conversion (the same shortcut
-  // applies in both the u8aTo{BigInt, Bn} conversions as well)
-  if (isNegative && count && (value[count - 1] & 0x80)) {
-    switch (count) {
-      case 0:
-        return 0;
-
-      case 1:
-        return (((value[0] ^ 0x0000_00ff) * -1) - 1);
-
-      case 2:
-        return ((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-
-      case 3:
-        return ((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
-
-      case 4:
-        // 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 ((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-
-      case 5:
-        return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      case 6:
-        return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
-
-      default:
-        throw new Error('Value more than 48-bits cannot be reliably converted');
-    }
-  }
-
-  switch (count) {
-    case 0:
-      return 0;
-
-    case 1:
-      return value[0];
-
-    case 2:
-      return value[0] + (value[1] << 8);
-
-    case 3:
-      return value[0] + (value[1] << 8) + (value[2] << 16);
-
-    case 4:
-      // 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 value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00);
-
-    case 5:
-      return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00);
-
-    case 6:
-      return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00);
-
-    default:
-      throw new Error('Value more than 48-bits cannot be reliably converted');
-  }
-}

package/build-deno/u8a/toString.ts

@@ -1,24 +0,0 @@
-
-import { TextDecoder } from 'https://deno.land/x/pezkuwi/x-textdecoder/mod.ts';
-
-const decoder = new TextDecoder('utf-8');
-
-/**
- * @name u8aToString
- * @summary Creates a utf-8 string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual decoded utf-8 string. `null` or `undefined` values returns an empty string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToString } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aToString(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f])); // hello
- * ```
- */
-export function u8aToString (value?: Uint8Array | null): string {
-  return value
-    ? decoder.decode(value)
-    : '';
-}

package/build-deno/u8a/toU8a.ts

@@ -1,46 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { U8aLike } from '../types.ts';
-
-import { hexToU8a } from '../hex/toU8a.ts';
-import { isBuffer } from '../is/buffer.ts';
-import { isHex } from '../is/hex.ts';
-import { isU8a } from '../is/u8a.ts';
-import { stringToU8a } from '../string/toU8a.ts';
-
-/**
- * @name u8aToU8a
- * @summary Creates a Uint8Array value from a Uint8Array, Buffer, string or hex input.
- * @description
- * `null` or `undefined` inputs returns a `[]` result, Uint8Array values returns the value, hex strings returns a Uint8Array representation.
- * If `strict` is true, `null` or `undefined` will throw an error instead of returning an empty array.
- * Supports input types: Uint8Array, Buffer, hex string, string, or number array.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aToU8a(new Uint8Array([0x12, 0x34]); // => Uint8Array([0x12, 0x34])
- * u8aToU8a(0x1234); // => Uint8Array([0x12, 0x34])
- * ```
- */
-export function u8aToU8a (value?: U8aLike | null, strict = false): Uint8Array {
-  if (strict && (value === null || value === undefined)) {
-    throw new Error('u8aToU8a: Expected non-null, non-undefined value');
-  }
-
-  return isU8a(value)
-    // NOTE isBuffer needs to go here since it actually extends
-    // Uint8Array on Node.js environments, so all Buffer are Uint8Array,
-    // but Uint8Array is not Buffer
-    ? isBuffer(value)
-      ? new Uint8Array(value)
-      : value
-    : isHex(value)
-      ? hexToU8a(value)
-      : Array.isArray(value)
-        ? new Uint8Array(value)
-        : stringToU8a(value);
-}

package/build-deno/u8a/wrap.ts

@@ -1,62 +0,0 @@
-
-
-import type { U8aLike } from '../types.ts';
-
-import { u8aConcatStrict } from './concat.ts';
-import { u8aEq } from './eq.ts';
-import { u8aToU8a } from './toU8a.ts';
-
-/** @internal */
-export const U8A_WRAP_ETHEREUM = /*#__PURE__*/ u8aToU8a('\x19Ethereum Signed Message:\n');
-
-/** @internal */
-export const U8A_WRAP_PREFIX = /*#__PURE__*/ u8aToU8a('<Bytes>');
-
-/** @internal */
-export const U8A_WRAP_POSTFIX = /*#__PURE__*/ u8aToU8a('</Bytes>');
-
-const WRAP_LEN = U8A_WRAP_PREFIX.length + U8A_WRAP_POSTFIX.length;
-
-/** @internal */
-export function u8aIsWrapped (u8a: Uint8Array, withEthereum: boolean): boolean {
-  return (
-    (
-      u8a.length >= WRAP_LEN &&
-      u8aEq(u8a.subarray(0, U8A_WRAP_PREFIX.length), U8A_WRAP_PREFIX) &&
-      u8aEq(u8a.slice(-U8A_WRAP_POSTFIX.length), U8A_WRAP_POSTFIX)
-    ) ||
-    (
-      withEthereum &&
-      u8a.length >= U8A_WRAP_ETHEREUM.length &&
-      u8aEq(u8a.subarray(0, U8A_WRAP_ETHEREUM.length), U8A_WRAP_ETHEREUM)
-    )
-  );
-}
-
-/**
- * @name u8aUnwrapBytes
- * @description Removes all <Bytes>...</Bytes> wrappers from the supplied value
- */
-export function u8aUnwrapBytes (bytes: U8aLike): Uint8Array {
-  const u8a = u8aToU8a(bytes);
-
-  // we don't want to unwrap Ethereum-style wraps
-  return u8aIsWrapped(u8a, false)
-    ? u8a.subarray(U8A_WRAP_PREFIX.length, u8a.length - U8A_WRAP_POSTFIX.length)
-    : u8a;
-}
-
-/**
- * @name u8aWrapBytes
- * @description
- * Adds a <Bytes>...</Bytes> wrapper to the supplied value, if
- * - We don't already have a Bytes wrapper
- * - The message is not an Ethereum-style message
- */
-export function u8aWrapBytes (bytes: U8aLike): Uint8Array {
-  const u8a = u8aToU8a(bytes);
-
-  return u8aIsWrapped(u8a, true)
-    ? u8a
-    : u8aConcatStrict([U8A_WRAP_PREFIX, u8a, U8A_WRAP_POSTFIX]);
-}

package/src/array/chunk.spec.ts

@@ -1,29 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { arrayChunk, arrayRange } from '../index.js';
-import { perf } from '../test/index.js';
-
-describe('arrayChunk', (): void => {
-  it('chunks with exact', (): void => {
-    expect(
-      arrayChunk([1, 2, 3, 4, 5, 6, 7, 8], 8)
-    ).toEqual([[1, 2, 3, 4, 5, 6, 7, 8]]);
-  });
-
-  it('chunks with unequal', (): void => {
-    expect(
-      arrayChunk([1, 2, 3, 4, 5, 6, 7], 3)
-    ).toEqual([[1, 2, 3], [4, 5, 6], [7]]);
-  });
-
-  it('chunks with non-empty results', (): void => {
-    expect(
-      arrayChunk([[1, 2], [3, 4], [5, 6], [7, 8]], 2)
-    ).toEqual([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);
-  });
-
-  perf('arrayChunk', 200_000, [[arrayRange(500), 50]], arrayChunk);
-});

package/src/array/chunk.ts

@@ -1,35 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @name arrayChunk
- * @summary Split T[] into T[][] based on the defind size
- * @description
- * Returns a set ao arrays based on the chunksize
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayChunk } from '@pezkuwi/util';
- *
- * arrayChunk([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]
- * ```
- */
-export function arrayChunk <T> (array: T[], chunkSize: number): T[][] {
-  const outputSize = Math.ceil(array.length / chunkSize);
-
-  // shortcut for the single-split case
-  if (outputSize === 1) {
-    return [array];
-  }
-
-  const output = Array<T[]>(outputSize);
-
-  for (let i = 0; i < outputSize; i++) {
-    const offset = i * chunkSize;
-
-    output[i] = array.slice(offset, offset + chunkSize);
-  }
-
-  return output;
-}

package/src/array/filter.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { arrayFilter } from './index.js';
-
-describe('filterArray', (): void => {
-  it('filters arrays, removing undefined', (): void => {
-    expect(
-      arrayFilter([0, '', null, false, undefined, NaN])
-    ).toEqual([0, '', null, false, NaN]);
-  });
-
-  it('filters arrays, removing undefined & null (allowNull = false)', (): void => {
-    expect(
-      arrayFilter([0, '', null, false, undefined, NaN], false)
-    ).toEqual([0, '', false, NaN]);
-  });
-});

package/src/array/filter.ts

@@ -1,24 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @name arrayFilter
- * @summary Filters undefined and (optionally) null values from an array
- * @description
- * Returns a new array with all `undefined` values removed. Optionally, when `allowNulls = false`, it removes the `null` values as well
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayFilter } from '@pezkuwi/util';
- *
- * arrayFilter([0, void 0, true, null, false, '']); // [0, true, null, false, '']
- * arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']
- * ```
- */
-export function arrayFilter <T = unknown> (array: readonly (T | null | undefined)[], allowNulls = true): T[] {
-  return array.filter((v): v is T =>
-    v !== undefined &&
-    (allowNulls || v !== null)
-  );
-}

package/src/array/flatten.spec.ts

@@ -1,33 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { perf } from '../test/index.js';
-import { arrayFlatten } from './index.js';
-
-const PERF_ONE = [[1, 2, 3, 4, 5]];
-const PERF_MUL = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
-
-describe('arrayFlatten', (): void => {
-  it('flattens arrays', (): void => {
-    expect(
-      arrayFlatten([[0], [1, 2, 3], [4, 5], [6], [], [7, 8]])
-    ).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
-  });
-
-  it('flattens a single entry', (): void => {
-    expect(
-      arrayFlatten([[1, 2, 3, 4, 5]])
-    ).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('flattens an empty', (): void => {
-    expect(
-      arrayFlatten([])
-    ).toEqual([]);
-  });
-
-  perf('arrayFlatten (single)', 10_000_000, [[PERF_ONE]], arrayFlatten);
-  perf('arrayFlatten (multi)', 700_000, [[PERF_MUL]], arrayFlatten);
-});

package/src/array/flatten.ts

@@ -1,51 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// This is supposed to be a faster concat...
-// https://dev.to/uilicious/javascript-array-push-is-945x-faster-than-array-concat-1oki
-
-/**
- * @name arrayFlatten
- * @summary Merge T[][] into T[]
- * @description
- * Returns a new array with all arrays merged into one
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayFlatten } from '@pezkuwi/util';
- *
- * arrayFlatten([[1, 2], [3, 4], [5]]); // [1, 2, 3, 4, 5]
- * ```
- */
-export function arrayFlatten <T> (arrays: readonly T[][]): T[] {
-  const num = arrays.length;
-
-  // shortcuts for the empty & single-entry case
-  if (num === 0) {
-    return [];
-  } else if (num === 1) {
-    return arrays[0];
-  }
-
-  // pre-allocate based on the combined size
-  let size = 0;
-
-  for (let i = 0; i < num; i++) {
-    size += arrays[i].length;
-  }
-
-  const output = new Array<T>(size);
-  let i = -1;
-
-  for (let j = 0; j < num; j++) {
-    const a = arrays[j];
-
-    // instead of pushing, we just set the entries
-    for (let e = 0, count = a.length; e < count; e++) {
-      output[++i] = a[e];
-    }
-  }
-
-  return output;
-}

package/src/array/index.ts

@@ -1,14 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @summary Utility methods that operates on arrays
- */
-
-export { arrayChunk } from './chunk.js';
-export { arrayFilter } from './filter.js';
-export { arrayFlatten } from './flatten.js';
-export { arrayRange } from './range.js';
-export { arrayShuffle } from './shuffle.js';
-export { arrayUnzip } from './unzip.js';
-export { arrayZip } from './zip.js';