base64-js 1.5.1: byteLength

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify base64-js.byteLength in pkg:npm/base64-js@1.5.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/base64-js@1.5.1
Demonstrate these symbols/APIs:
  - base64-js.byteLength

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:dc5e6b01e326a37ab15ca20a181be8f2fdbfc3711b418e8c626ac392abbb056f","contract":["byteLength calculates the decoded byte length for unpadded base64 strings","byteLength calculates the decoded byte length for single-padding base64 strings","byteLength calculates the decoded byte length for double-padding base64 strings","byteLength returns zero for empty base64 strings","byteLength matches the length of decoded byte array from toByteArray","byteLength throws an error when string length is not a multiple of four","byteLength calculates the decoded byte length for URL-safe base64 strings"],"goal":"verify base64-js.byteLength in pkg:npm/base64-js@1.5.1","kind":"HOW","packages":["pkg:npm/base64-js@1.5.1"],"schemaVersion":1,"symbols":["base64-js.byteLength"]},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/base64-js@1.5.1"],"schemaVersion":1,"subject":"pkg:npm/base64-js@1.5.1","symbols":["base64-js.byteLength"],"verifierAdapter":"node-typescript@1"}

{
  "name": "base64-js-sample",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "base64-js-sample",
      "version": "1.0.0",
      "dependencies": {
        "base64-js": "1.5.1"
      }
    },
    "node_modules/base64-js": {
      "version": "1.5.1",
      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/feross"
        },
        {
          "type": "patreon",
          "url": "https://www.patreon.com/feross"
        },
        {
          "type": "consulting",
          "url": "https://feross.org/support"
        }
      ],
      "license": "MIT"
    }
  }
}

{
  "name": "base64-js-sample",
  "version": "1.0.0",
  "dependencies": {
    "base64-js": "1.5.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify base64-js.byteLength in pkg:npm/base64-js@1.5.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/base64-js@1.5.1"
  ],
  "symbols": [
    "base64-js.byteLength"
  ]
}

const base64 = require('base64-js');

/**
 * Calculates the byte length of a decoded base64 string.
 *
 * @param {string} b64 - Base64 encoded string.
 * @returns {number} The byte length of the decoded data.
 */
function getByteLength(b64) {
  return base64.byteLength(b64);
}

/**
 * Decodes a base64 string to a byte array.
 *
 * @param {string} b64 - Base64 encoded string.
 * @returns {Uint8Array} Decoded byte array.
 */
function toByteArray(b64) {
  return base64.toByteArray(b64);
}

/**
 * Encodes a byte array to a base64 string.
 *
 * @param {Uint8Array} uint8 - Byte array to encode.
 * @returns {string} Base64 encoded string.
 */
function fromByteArray(uint8) {
  return base64.fromByteArray(uint8);
}

module.exports = {
  getByteLength,
  toByteArray,
  fromByteArray,
};

const assert = require('node:assert/strict');
const {
  getByteLength,
  toByteArray,
  fromByteArray,
} = require('../src/index.js');

function testUnpaddedStrings() {
  assert.strictEqual(getByteLength('AQID'), 3);
  assert.strictEqual(getByteLength('YW55'), 3);
  assert.strictEqual(getByteLength('MDEyMzQ1'), 6);
}

function testSinglePaddingStrings() {
  assert.strictEqual(getByteLength('YWI='), 2);
  assert.strictEqual(getByteLength('aGVsbG8='), 5);
  assert.strictEqual(getByteLength('AQIDBAU='), 5);
}

function testDoublePaddingStrings() {
  assert.strictEqual(getByteLength('YQ=='), 1);
  assert.strictEqual(getByteLength('aGVsbA=='), 4);
  assert.strictEqual(getByteLength('AQIDBA=='), 4);
}

function testEmptyString() {
  assert.strictEqual(getByteLength(''), 0);
}

function testMatchesToByteArrayLength() {
  const testLengths = [0, 1, 2, 3, 4, 5, 7, 8, 15, 16, 32, 64];
  for (const len of testLengths) {
    const bytes = new Uint8Array(len);
    for (let i = 0; i < len; i++) {
      bytes[i] = (i * 37 + 13) & 0xff;
    }
    const encoded = fromByteArray(bytes);
    const calculatedLength = getByteLength(encoded);
    const decodedBytes = toByteArray(encoded);

    assert.strictEqual(calculatedLength, bytes.length);
    assert.strictEqual(calculatedLength, decodedBytes.length);
  }
}

function testThrowsOnInvalidLength() {
  const invalidStrings = ['a', 'ab', 'abc', 'abcde', '1234567'];
  for (const str of invalidStrings) {
    assert.throws(
      () => getByteLength(str),
      {
        name: 'Error',
        message: 'Invalid string. Length must be a multiple of 4',
      }
    );
  }
}

function testUrlSafeStrings() {
  assert.strictEqual(getByteLength('-_-_'), 3);
  assert.strictEqual(getByteLength('-_-='), 2);
  assert.strictEqual(getByteLength('-_=='), 1);
  assert.strictEqual(getByteLength('--__--__'), 6);
}

function main() {
  testUnpaddedStrings();
  testSinglePaddingStrings();
  testDoublePaddingStrings();
  testEmptyString();
  testMatchesToByteArrayLength();
  testThrowsOnInvalidLength();
  testUrlSafeStrings();
}

main();