fflate 0.8.3: unzipSync

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 fflate.unzipSync in pkg:npm/fflate@0.8.3
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/fflate@0.8.3
Demonstrate these symbols/APIs:
  - fflate.unzipSync

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:9bd643c96bda7818c7c828926ab663233359c70d311c74f4c3742f84f70e0b97","contract":["assert unzipSync decompresses a valid ZIP archive and returns an object mapping filenames to Uint8Array contents","assert unzipSync correctly restores multiple files including nested directory paths and empty files","assert unzipSync supports the filter option to selectively decompress matching files","assert unzipSync preserves exact byte content and data integrity across compression and decompression","assert unzipSync throws an error when provided with invalid or corrupted ZIP archive data"],"goal":"verify fflate.unzipSync in pkg:npm/fflate@0.8.3","kind":"HOW","packages":["pkg:npm/fflate@0.8.3"],"schemaVersion":1,"symbols":["fflate.unzipSync"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/fflate@0.8.3"],"schemaVersion":1,"subject":"pkg:npm/fflate@0.8.3","symbols":["fflate.unzipSync"],"verifierAdapter":"node-typescript@1"}

import { unzipSync, zipSync } from 'fflate';

/**
 * Decompresses a ZIP archive synchronously.
 *
 * @param {Uint8Array} data - Raw compressed ZIP archive bytes.
 * @param {object} [opts] - Unzip options including filter function.
 * @returns {Record<string, Uint8Array>} Mapping of file paths to uncompressed byte contents.
 */
export function extractZipSync(data, opts) {
  return unzipSync(data, opts);
}

/**
 * Creates a ZIP archive synchronously from an object mapping file paths to byte contents.
 *
 * @param {Record<string, Uint8Array>} files - Mapping of file paths to byte contents.
 * @param {object} [opts] - Zip options.
 * @returns {Uint8Array} Compressed ZIP archive bytes.
 */
export function archiveZipSync(files, opts) {
  return zipSync(files, opts);
}

export { unzipSync, zipSync };

{
  "name": "sample-fflate",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-fflate",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "fflate": "0.8.3"
      }
    },
    "node_modules/fflate": {
      "version": "0.8.3",
      "resolved": "https://registry.npmjs.org/fflate/-/fflate-0.8.3.tgz",
      "integrity": "sha512-tbZNuJrLwGUp3zshBtdy4W+ORxZuIh8a5ilyIEQDC5rY1f3U20JMry0Ll3WBzU58EZKsEuJFXhb5gwv8CsPvgA==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-fflate",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification for fflate.unzipSync in pkg:npm/fflate@0.8.3",
  "type": "module",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "fflate": "0.8.3"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify fflate.unzipSync in pkg:npm/fflate@0.8.3",
  "kind": "HOW",
  "packages": [
    "pkg:npm/fflate@0.8.3"
  ],
  "symbols": [
    "fflate.unzipSync"
  ]
}

import assert from 'node:assert/strict';
import { unzipSync, zipSync, extractZipSync, archiveZipSync } from '../index.mjs';

// 1. assert unzipSync decompresses a valid ZIP archive and returns an object mapping filenames to Uint8Array contents
{
  const encoder = new TextEncoder();
  const originalText = 'Hello fflate unzipSync test!';
  const fileBytes = encoder.encode(originalText);
  const archive = archiveZipSync({ 'greeting.txt': fileBytes });

  assert.ok(archive instanceof Uint8Array, 'ZIP archive must be a Uint8Array');
  assert.ok(archive.length > 0, 'ZIP archive must not be empty');

  const extracted = extractZipSync(archive);
  assert.ok(typeof extracted === 'object' && extracted !== null, 'unzipSync must return an object');
  assert.ok('greeting.txt' in extracted, 'Extracted archive must contain greeting.txt');
  assert.ok(extracted['greeting.txt'] instanceof Uint8Array, 'Extracted entry must be a Uint8Array');
  assert.deepStrictEqual(extracted['greeting.txt'], fileBytes, 'Extracted file bytes must match original content');

  const decoder = new TextDecoder();
  assert.strictEqual(decoder.decode(extracted['greeting.txt']), originalText, 'Decoded string must match original text');
}

// 2. assert unzipSync correctly restores multiple files including nested directory paths and empty files
{
  const encoder = new TextEncoder();
  const file1 = encoder.encode('File 1 root level');
  const file2 = encoder.encode('Nested deep level file content');
  const emptyFile = new Uint8Array(0);

  const archive = zipSync({
    'file1.txt': file1,
    'dir/subdir/file2.txt': file2,
    'empty.dat': emptyFile
  });

  const extracted = unzipSync(archive);
  const fileNames = Object.keys(extracted).sort();
  assert.deepStrictEqual(fileNames, ['dir/subdir/file2.txt', 'empty.dat', 'file1.txt'], 'All files must be extracted with preserved paths');
  assert.deepStrictEqual(extracted['file1.txt'], file1, 'file1.txt content must match');
  assert.deepStrictEqual(extracted['dir/subdir/file2.txt'], file2, 'nested file content must match');
  assert.strictEqual(extracted['empty.dat'].length, 0, 'empty file must have length 0');
}

// 3. assert unzipSync supports the filter option to selectively decompress matching files
{
  const encoder = new TextEncoder();
  const archive = zipSync({
    'keep1.txt': encoder.encode('keep me 1'),
    'keep2.txt': encoder.encode('keep me 2'),
    'ignore.log': encoder.encode('ignore this file'),
    'assets/image.png': new Uint8Array([0x89, 0x50, 0x4e, 0x47])
  });

  const filtered = unzipSync(archive, {
    filter: (file) => file.name.endsWith('.txt')
  });

  const extractedNames = Object.keys(filtered).sort();
  assert.deepStrictEqual(extractedNames, ['keep1.txt', 'keep2.txt'], 'Filter must only extract matching .txt files');
  assert.ok(!('ignore.log' in filtered), 'Non-matching log file must be excluded');
  assert.ok(!('assets/image.png' in filtered), 'Non-matching png file must be excluded');
}

// 4. assert unzipSync preserves exact byte content and data integrity across compression and decompression
{
  const binaryData = new Uint8Array(4096);
  for (let i = 0; i < binaryData.length; i++) {
    binaryData[i] = (i * 31 + 17) & 0xff;
  }

  const archive = zipSync({ 'data.bin': binaryData }, { level: 9 });
  const extracted = unzipSync(archive);

  assert.ok('data.bin' in extracted, 'data.bin must exist in extracted output');
  assert.strictEqual(extracted['data.bin'].length, binaryData.length, 'Length must match original binary size');
  assert.deepStrictEqual(extracted['data.bin'], binaryData, 'Decompressed binary data must exactly match input bytes');
}

// 5. assert unzipSync throws an error when provided with invalid or corrupted ZIP archive data
{
  const invalidData = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04]);
  assert.throws(
    () => unzipSync(invalidData),
    (err) => {
      assert.ok(err instanceof Error, 'Expected error to be an instance of Error');
      return true;
    },
    'unzipSync must throw an Error when given invalid zip data'
  );
}

console.log('All contract assertions passed.');