Move _assert into utils

Author: paulmillr

src/_arx.ts

@@ -36,8 +36,10 @@ xchacha [^2] uses the subkey and remaining 8 byte nonce with ChaCha20 as normal
 
  * @module
  */
-import { abool, abytes, anumber } from './_assert.ts';
-import { type XorStream, checkOpts, clean, copyBytes, u32 } from './utils.ts';
+// prettier-ignore
+import {
+  type XorStream, abool, abytes, anumber, checkOpts, clean, copyBytes, u32
+} from './utils.ts';
 
 // We can't make top-level var depend on utils.utf8ToBytes
 // because it's not present in all envs. Creating a similar fn here

src/_micro.ts

@@ -7,10 +7,10 @@
 /*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
 // prettier-ignore
 import { createCipher, rotl } from './_arx.ts';
-import { abytes } from './_assert.ts';
 import {
   type Cipher,
   type XorStream,
+  abytes,
   bytesToHex,
   concatBytes,
   equalBytes,

src/_poly1305.ts

@@ -16,8 +16,7 @@
  * Check out [original website](https://cr.yp.to/mac.html).
  * @module
  */
-import { abytes, aexists, aoutput } from './_assert.ts';
-import { Hash, type Input, clean, toBytes } from './utils.ts';
+import { Hash, type Input, abytes, aexists, aoutput, clean, toBytes } from './utils.ts';
 
 // Based on Public Domain poly1305-donna https://github.com/floodyberry/poly1305-donna
 const u8to16 = (a: Uint8Array, i: number) => (a[i++] & 0xff) | ((a[i++] & 0xff) << 8);

src/_polyval.ts

@@ -12,8 +12,11 @@
  *
  * @module
  */
-import { abytes, aexists, aoutput } from './_assert.ts';
-import { clean, copyBytes, createView, Hash, type Input, toBytes, u32 } from './utils.ts';
+// prettier-ignore
+import {
+  abytes, aexists, aoutput,
+  clean, copyBytes, createView, Hash, type Input, toBytes, u32,
+} from './utils.ts';
 
 const BLOCK_SIZE = 16;
 // TODO: rewrite

src/aes.ts

@@ -14,25 +14,13 @@
  * and [original proposal](https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf)
  * @module
  */
-import { abytes } from './_assert.ts';
 import { ghash, polyval } from './_polyval.ts';
+// prettier-ignore
 import {
-  type Cipher,
-  type CipherWithOutput,
-  clean,
-  complexOverlapBytes,
-  concatBytes,
-  copyBytes,
-  createView,
-  equalBytes,
-  getOutput,
-  isAligned32,
-  overlapBytes,
-  setBigUint64,
-  u32,
-  u64Lengths,
-  u8,
-  wrapCipher,
+  abytes, clean, complexOverlapBytes, concatBytes,
+  copyBytes, createView, equalBytes, getOutput, isAligned32, overlapBytes,
+  setBigUint64, u32, u64Lengths, u8, wrapCipher,
+  type Cipher, type CipherWithOutput,
 } from './utils.ts';
 
 const BLOCK_SIZE = 16;

src/ff1.ts

@@ -3,9 +3,8 @@
  * [NIST 800-38G](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38G.pdf).
  * @module
  */
-import { abytes, anumber } from './_assert.ts';
 import { unsafe } from './aes.ts';
-import { type Cipher, bytesToNumberBE, clean, numberToBytesBE } from './utils.ts';
+import { type Cipher, abytes, anumber, bytesToNumberBE, clean, numberToBytesBE } from './utils.ts';
 
 // NOTE: no point in inlining encrypt instead of encryptBlock, since BigInt stuff will be slow
 const { expandKeyLE, encryptBlock } = unsafe;

src/salsa.ts

@@ -14,9 +14,9 @@
  * @module
  */
 import { createCipher, rotl } from './_arx.ts';
-import { abytes } from './_assert.ts';
 import { poly1305 } from './_poly1305.ts';
 import {
+  abytes,
   type ARXCipher,
   type CipherWithOutput,
   clean,

src/webcrypto.ts

@@ -10,8 +10,7 @@
  */
 // Use full path so that Node.js can rewrite it to `cryptoNode.js`.
 import { crypto } from '@noble/ciphers/crypto';
-import { abytes, anumber } from './_assert.ts';
-import { type AsyncCipher, type Cipher, concatBytes } from './utils.ts';
+import { abytes, anumber, type AsyncCipher, type Cipher, concatBytes } from './utils.ts';
 
 /**
  * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.

test/utils.test.js

@@ -1,7 +1,7 @@
 import fc from 'fast-check';
 import { describe, should } from 'micro-should';
 import { deepStrictEqual, throws } from 'node:assert';
-import * as assert from '../esm/_assert.js';
+import * as u from '../esm/utils.js';
 import {
   bytesToHex,
   bytesToUtf8,
@@ -201,38 +201,38 @@ describe('utils', () => {
 
 describe('assert', () => {
   should('anumber', () => {
-    deepStrictEqual(assert.anumber(10), undefined);
-    throws(() => assert.anumber(1.2));
-    throws(() => assert.anumber('1'));
-    throws(() => assert.anumber(true));
-    throws(() => assert.anumber(NaN));
+    deepStrictEqual(u.anumber(10), undefined);
+    throws(() => u.anumber(1.2));
+    throws(() => u.anumber('1'));
+    throws(() => u.anumber(true));
+    throws(() => u.anumber(NaN));
   });
   should('abytes', () => {
-    deepStrictEqual(assert.abytes(new Uint8Array(0)), undefined);
-    if (typeof Buffer !== 'undefined') deepStrictEqual(assert.abytes(Buffer.alloc(10)), undefined);
-    deepStrictEqual(assert.abytes(new Uint8Array(10)), undefined);
-    assert.abytes(new Uint8Array(11), 11, 12);
-    assert.abytes(new Uint8Array(12), 12, 12);
-    throws(() => assert.abytes('test'));
-    throws(() => assert.abytes(new Uint8Array(10), 11, 12));
-    throws(() => assert.abytes(new Uint8Array(10), 11, 12));
+    deepStrictEqual(u.abytes(new Uint8Array(0)), undefined);
+    if (typeof Buffer !== 'undefined') deepStrictEqual(u.abytes(Buffer.alloc(10)), undefined);
+    deepStrictEqual(u.abytes(new Uint8Array(10)), undefined);
+    u.abytes(new Uint8Array(11), 11, 12);
+    u.abytes(new Uint8Array(12), 12, 12);
+    throws(() => u.abytes('test'));
+    throws(() => u.abytes(new Uint8Array(10), 11, 12));
+    throws(() => u.abytes(new Uint8Array(10), 11, 12));
   });
   should('ahash', () => {
     const sha256 = () => {};
     sha256.blockLen = 1;
     sha256.outputLen = 1;
     sha256.create = () => {};
-    deepStrictEqual(assert.ahash(sha256), undefined);
-    throws(() => assert.ahash({}));
-    throws(() => assert.ahash({ blockLen: 1, outputLen: 1, create: () => {} }));
+    deepStrictEqual(u.ahash(sha256), undefined);
+    throws(() => u.ahash({}));
+    throws(() => u.ahash({ blockLen: 1, outputLen: 1, create: () => {} }));
   });
   should('aexists', () => {
-    deepStrictEqual(assert.aexists({}), undefined);
-    throws(() => assert.aexists({ destroyed: true }));
+    deepStrictEqual(u.aexists({}), undefined);
+    throws(() => u.aexists({ destroyed: true }));
   });
   should('aoutput', () => {
-    deepStrictEqual(assert.aoutput(new Uint8Array(10), { outputLen: 5 }), undefined);
-    throws(() => assert.aoutput(new Uint8Array(1), { outputLen: 5 }));
+    deepStrictEqual(u.aoutput(new Uint8Array(10), { outputLen: 5 }), undefined);
+    throws(() => u.aoutput(new Uint8Array(1), { outputLen: 5 }));
   });
 });