core-util-is 1.0.3: isArray, isBoolean, isBuffer

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 pkg:npm/core-util-is@1.0.3
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/core-util-is@1.0.3
Demonstrate these symbols/APIs:
  - isArray
  - isBoolean
  - isBuffer
  - isDate
  - isError
  - isFunction
  - isNull
  - isNullOrUndefined
  - isNumber
  - isObject
  - isPrimitive
  - isRegExp
  - isString
  - isSymbol
  - isUndefined

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:8410c8c6539478cb165cb743551d560daa1465e26b40608307806d9041f1f2ac","contract":["isArray returns true for arrays and false for non-arrays","isBoolean returns true for boolean primitives and false for other types","isBuffer returns true for Buffer instances and false for non-buffers","isDate returns true for Date instances and false for non-dates","isError returns true for Error instances and false for non-errors","isFunction returns true for functions and false for non-functions","isNull returns true only for null","isNullOrUndefined returns true for null or undefined and false for other values","isNumber returns true for number primitives including NaN and Infinity","isObject returns true for non-null objects including arrays and false for primitives","isPrimitive returns true for primitives (null, undefined, boolean, number, string, symbol)","isRegExp returns true for RegExp instances and false for non-regexes","isString returns true for string primitives and false for non-strings","isSymbol returns true for symbols and false for non-symbols","isUndefined returns true only for undefined"],"goal":"verify pkg:npm/core-util-is@1.0.3","kind":"HOW","packages":["pkg:npm/core-util-is@1.0.3"],"schemaVersion":1,"symbols":["isArray","isBoolean","isBuffer","isDate","isError","isFunction","isNull","isNullOrUndefined","isNumber","isObject","isPrimitive","isRegExp","isString","isSymbol","isUndefined"]},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/core-util-is@1.0.3"],"schemaVersion":1,"subject":"pkg:npm/core-util-is@1.0.3","symbols":["isArray","isBoolean","isBuffer","isDate","isError","isFunction","isNull","isNullOrUndefined","isNumber","isObject","isPrimitive","isRegExp","isString","isSymbol","isUndefined"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-core-util-is",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-core-util-is",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "core-util-is": "1.0.3"
      }
    },
    "node_modules/core-util-is": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
      "license": "MIT"
    }
  }
}

{
  "name": "sample-core-util-is",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification sample for core-util-is",
  "main": "src/index.js",
  "scripts": {
    "test": "node test/contract.js"
  },
  "dependencies": {
    "core-util-is": "1.0.3"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/core-util-is@1.0.3",
  "kind": "HOW",
  "packages": [
    "pkg:npm/core-util-is@1.0.3"
  ],
  "symbols": [
    "isArray",
    "isBoolean",
    "isBuffer",
    "isDate",
    "isError",
    "isFunction",
    "isNull",
    "isNullOrUndefined",
    "isNumber",
    "isObject",
    "isPrimitive",
    "isRegExp",
    "isString",
    "isSymbol",
    "isUndefined"
  ]
}

const coreUtil = require('core-util-is');

function checkType(type, value) {
  if (typeof coreUtil[type] === 'function') {
    return coreUtil[type](value);
  }
  throw new Error('Unknown type check: ' + type);
}

module.exports = {
  checkType,
  isArray: coreUtil.isArray,
  isBoolean: coreUtil.isBoolean,
  isBuffer: coreUtil.isBuffer,
  isDate: coreUtil.isDate,
  isError: coreUtil.isError,
  isFunction: coreUtil.isFunction,
  isNull: coreUtil.isNull,
  isNullOrUndefined: coreUtil.isNullOrUndefined,
  isNumber: coreUtil.isNumber,
  isObject: coreUtil.isObject,
  isPrimitive: coreUtil.isPrimitive,
  isRegExp: coreUtil.isRegExp,
  isString: coreUtil.isString,
  isSymbol: coreUtil.isSymbol,
  isUndefined: coreUtil.isUndefined
};

const assert = require('node:assert');
const coreUtil = require('core-util-is');
const {
  checkType,
  isArray,
  isBoolean,
  isBuffer,
  isDate,
  isError,
  isFunction,
  isNull,
  isNullOrUndefined,
  isNumber,
  isObject,
  isPrimitive,
  isRegExp,
  isString,
  isSymbol,
  isUndefined
} = require('../src/index.js');

// 1. isArray
assert.strictEqual(isArray([]), true, 'empty array is array');
assert.strictEqual(isArray([1, 2, 3]), true, 'array is array');
assert.strictEqual(isArray(new Array(5)), true, 'new Array is array');
assert.strictEqual(isArray({}), false, 'object is not array');
assert.strictEqual(isArray('abc'), false, 'string is not array');
assert.strictEqual(checkType('isArray', [1]), true, 'checkType isArray true');
assert.strictEqual(checkType('isArray', 'not-array'), false, 'checkType isArray false');

// 2. isBoolean
assert.strictEqual(isBoolean(true), true, 'true is boolean');
assert.strictEqual(isBoolean(false), true, 'false is boolean');
assert.strictEqual(isBoolean(0), false, '0 is not boolean');
assert.strictEqual(isBoolean('true'), false, 'string is not boolean');
assert.strictEqual(isBoolean(null), false, 'null is not boolean');
assert.strictEqual(checkType('isBoolean', true), true, 'checkType isBoolean');

// 3. isBuffer
assert.strictEqual(isBuffer(Buffer.from('hello')), true, 'Buffer.from is buffer');
assert.strictEqual(isBuffer(Buffer.alloc(8)), true, 'Buffer.alloc is buffer');
assert.strictEqual(isBuffer(new Uint8Array(8)), false, 'plain Uint8Array is not Buffer');
assert.strictEqual(isBuffer('hello'), false, 'string is not buffer');
assert.strictEqual(isBuffer({}), false, 'object is not buffer');
assert.strictEqual(checkType('isBuffer', Buffer.alloc(1)), true, 'checkType isBuffer');

// 4. isDate
assert.strictEqual(isDate(new Date()), true, 'new Date() is date');
assert.strictEqual(isDate(new Date('2026-01-01')), true, 'constructed Date is date');
assert.strictEqual(isDate(Date.now()), false, 'timestamp is not date');
assert.strictEqual(isDate('2026-01-01'), false, 'date string is not date');
assert.strictEqual(isDate({}), false, 'object is not date');
assert.strictEqual(checkType('isDate', new Date()), true, 'checkType isDate');

// 5. isError
assert.strictEqual(isError(new Error('fail')), true, 'new Error is error');
assert.strictEqual(isError(new TypeError('type err')), true, 'new TypeError is error');
assert.strictEqual(isError(new RangeError('range err')), true, 'new RangeError is error');
assert.strictEqual(isError({ message: 'fake error' }), false, 'plain object is not error');
assert.strictEqual(isError('error'), false, 'string is not error');
assert.strictEqual(checkType('isError', new Error('test')), true, 'checkType isError');

// 6. isFunction
assert.strictEqual(isFunction(function() {}), true, 'function declaration is function');
assert.strictEqual(isFunction(() => {}), true, 'arrow function is function');
assert.strictEqual(isFunction(class MyClass {}), true, 'class constructor is function');
assert.strictEqual(isFunction({}), false, 'object is not function');
assert.strictEqual(isFunction(null), false, 'null is not function');
assert.strictEqual(checkType('isFunction', () => {}), true, 'checkType isFunction');

// 7. isNull
assert.strictEqual(isNull(null), true, 'null is null');
assert.strictEqual(isNull(undefined), false, 'undefined is not null');
assert.strictEqual(isNull(0), false, '0 is not null');
assert.strictEqual(isNull(false), false, 'false is not null');
assert.strictEqual(isNull(''), false, 'empty string is not null');
assert.strictEqual(checkType('isNull', null), true, 'checkType isNull');

// 8. isNullOrUndefined
assert.strictEqual(isNullOrUndefined(null), true, 'null is nullOrUndefined');
assert.strictEqual(isNullOrUndefined(undefined), true, 'undefined is nullOrUndefined');
assert.strictEqual(isNullOrUndefined(void 0), true, 'void 0 is nullOrUndefined');
assert.strictEqual(isNullOrUndefined(0), false, '0 is not nullOrUndefined');
assert.strictEqual(isNullOrUndefined(false), false, 'false is not nullOrUndefined');
assert.strictEqual(isNullOrUndefined(''), false, 'empty string is not nullOrUndefined');
assert.strictEqual(isNullOrUndefined({}), false, 'object is not nullOrUndefined');
assert.strictEqual(checkType('isNullOrUndefined', undefined), true, 'checkType isNullOrUndefined');

// 9. isNumber
assert.strictEqual(isNumber(0), true, '0 is number');
assert.strictEqual(isNumber(42), true, '42 is number');
assert.strictEqual(isNumber(-3.14), true, '-3.14 is number');
assert.strictEqual(isNumber(NaN), true, 'NaN is number');
assert.strictEqual(isNumber(Infinity), true, 'Infinity is number');
assert.strictEqual(isNumber('42'), false, 'string is not number');
assert.strictEqual(isNumber(null), false, 'null is not number');
assert.strictEqual(checkType('isNumber', 123), true, 'checkType isNumber');

// 10. isObject
assert.strictEqual(isObject({}), true, 'empty object is object');
assert.strictEqual(isObject({ a: 1 }), true, 'object with keys is object');
assert.strictEqual(isObject([]), true, 'array is object');
assert.strictEqual(isObject(new Date()), true, 'Date is object');
assert.strictEqual(isObject(null), false, 'null is not object');
assert.strictEqual(isObject(undefined), false, 'undefined is not object');
assert.strictEqual(isObject(42), false, 'number is not object');
assert.strictEqual(isObject('str'), false, 'string is not object');
assert.strictEqual(checkType('isObject', { test: true }), true, 'checkType isObject');

// 11. isPrimitive
assert.strictEqual(isPrimitive(null), true, 'null is primitive');
assert.strictEqual(isPrimitive(undefined), true, 'undefined is primitive');
assert.strictEqual(isPrimitive(true), true, 'boolean is primitive');
assert.strictEqual(isPrimitive(123), true, 'number is primitive');
assert.strictEqual(isPrimitive('hello'), true, 'string is primitive');
assert.strictEqual(isPrimitive(Symbol('sym')), true, 'symbol is primitive');
assert.strictEqual(isPrimitive({}), false, 'object is not primitive');
assert.strictEqual(isPrimitive([]), false, 'array is not primitive');
assert.strictEqual(isPrimitive(() => {}), false, 'function is not primitive');
assert.strictEqual(checkType('isPrimitive', 'text'), true, 'checkType isPrimitive');

// 12. isRegExp
assert.strictEqual(isRegExp(/abc/), true, 'regex literal is regex');
assert.strictEqual(isRegExp(new RegExp('xyz')), true, 'new RegExp is regex');
assert.strictEqual(isRegExp('/abc/'), false, 'string regex is not regex');
assert.strictEqual(isRegExp({}), false, 'object is not regex');
assert.strictEqual(checkType('isRegExp', /test/), true, 'checkType isRegExp');

// 13. isString
assert.strictEqual(isString('hello'), true, 'string is string');
assert.strictEqual(isString(''), true, 'empty string is string');
assert.strictEqual(isString(123), false, 'number is not string');
assert.strictEqual(isString(null), false, 'null is not string');
assert.strictEqual(isString({}), false, 'object is not string');
assert.strictEqual(checkType('isString', 'world'), true, 'checkType isString');

// 14. isSymbol
assert.strictEqual(isSymbol(Symbol('id')), true, 'Symbol() is symbol');
assert.strictEqual(isSymbol(Symbol.iterator), true, 'Symbol.iterator is symbol');
assert.strictEqual(isSymbol('symbol'), false, 'string is not symbol');
assert.strictEqual(isSymbol(123), false, 'number is not symbol');
assert.strictEqual(checkType('isSymbol', Symbol('test')), true, 'checkType isSymbol');

// 15. isUndefined
assert.strictEqual(isUndefined(undefined), true, 'undefined is undefined');
assert.strictEqual(isUndefined(void 0), true, 'void 0 is undefined');
assert.strictEqual(isUndefined(null), false, 'null is not undefined');
assert.strictEqual(isUndefined(0), false, '0 is not undefined');
assert.strictEqual(isUndefined(''), false, 'empty string is not undefined');
assert.strictEqual(checkType('isUndefined', undefined), true, 'checkType isUndefined');

console.log('All 15 type check contract tests passed successfully.');