builtin-type 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/index.d.ts
+type BuiltinType = `undefined` | `null` | `boolean` | `number` | `bigint` | `string` | `symbol` | `Boolean` | `Number` | `String` | `Array` | `Map` | `Set` | `WeakMap` | `WeakSet` | `Function` | `GeneratorFunction` | `AsyncFunction` | `AsyncGeneratorFunction` | `Promise` | `Date` | `RegExp` | `URL` | `URLSearchParams` | `WeakRef` | `FinalizationRegistry` | `ArrayBuffer` | `SharedArrayBuffer` | `Buffer` | `Int8Array` | `Uint8Array` | `Uint8ClampedArray` | `Int16Array` | `Uint16Array` | `Int32Array` | `Uint32Array` | `BigInt64Array` | `BigUint64Array` | `Float16Array` | `Float32Array` | `Float64Array` | `DataView` | `Object`;
+declare const builtinType: (value: unknown) => BuiltinType;
+//#endregion
+export { BuiltinType, builtinType as default };

package/dist/index.js

@@ -0,0 +1 @@
+let e=e=>{if(e===null)return`null`;let n=typeof e;if(n==`object`){for(let n of t){let t=n(e);if(t)return t}return`Object`}if(n==`function`){let t=Function.prototype.toString.call(e),n=t.slice(0,t.indexOf(`(`));return`${n.includes(`async`)?`Async`:``}${n.includes(`*`)?`Generator`:``}Function`}return n},t=[...[[`Array`,`isArray`],[`Buffer`,`isBuffer`]].flatMap(([e,t])=>{let n=globalThis[e];if(!n)return[];let r=n[t];return t=>r(t)?e:void 0}),...[[`Boolean`,`valueOf`],[`Number`,`valueOf`],[`String`,`valueOf`],[`Map`,`has`],[`Set`,`has`],[`WeakMap`,`has`],[`WeakSet`,`has`],[`WeakRef`,`deref`],[`Promise`,`then`],[`Date`,`getDay`],[`RegExp`,`global`],[`URL`,`href`],[`URLSearchParams`,`size`],[`ArrayBuffer`,`byteLength`],[`SharedArrayBuffer`,`byteLength`],[`DataView`,`buffer`],[`FinalizationRegistry`,`unregister`,[{}]]].flatMap(([e,t,n=[]])=>{let r,i=globalThis[e]?.prototype;do{if(r=Object.getOwnPropertyDescriptor(i,t),r)break;i=Object.getPrototypeOf(i)}while(i);if(!r)return[];let a=r.value??r.get;return t=>{try{return a.apply(t,n)==null?void 0:e}catch{return}}})],n=Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype),Symbol.toStringTag)?.get;n&&t.push(e=>n.call(e));export{e as default};

package/license

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 Tomer Aberbach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "builtin-type",
+  "version": "0.0.1",
+  "author": {
+    "name": "Tomer Aberbach",
+    "email": "tomer@aberba.ch",
+    "url": "https://tomeraberba.ch"
+  },
+  "description": "What is the type of this builtin JS value?",
+  "keywords": [
+    "builtin",
+    "detect",
+    "ecmascript",
+    "type",
+    "typeof",
+    "types"
+  ],
+  "homepage": "https://github.com/TomerAberbach/builtin-type",
+  "repository": "TomerAberbach/builtin-type",
+  "bugs": {
+    "url": "https://github.com/TomerAberbach/builtin-type/issues"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/TomerAberbach"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "prettier": "@tomer/prettier-config",
+  "devDependencies": {
+    "@fast-check/vitest": "^0.3.0",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@tomer/eslint-config": "^4.6.1",
+    "@tomer/prettier-config": "^4.0.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "eslint": "^9.39.2",
+    "jsdom": "^29.0.1",
+    "magic-string": "^0.30.21",
+    "prettier": "^3.8.1",
+    "publint": "^0.3.18",
+    "tsdown": "^0.21.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0",
+    "which-builtin-type": "^1.2.1"
+  },
+  "scripts": {
+    "format": "prettier --cache --write .",
+    "lint": "eslint --cache --cache-location node_modules/.cache/eslint/ --fix .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "coverage": "vitest --coverage",
+    "bench": "vitest bench",
+    "build": "tsdown"
+  }
+}

package/readme.md

@@ -0,0 +1,149 @@
+<h1 align="center">
+  builtin-type
+</h1>
+
+<div align="center">
+  <a href="https://npmjs.org/package/builtin-type">
+    <img src="https://badgen.net/npm/v/builtin-type" alt="version" />
+  </a>
+  <a href="https://github.com/TomerAberbach/builtin-type/actions">
+    <img src="https://github.com/TomerAberbach/builtin-type/workflows/CI/badge.svg" alt="CI" />
+  </a>
+  <a href="https://unpkg.com/builtin-type/dist/index.js">
+    <img src="https://deno.bundlejs.com/?q=builtin-type&badge" alt="gzip size" />
+  </a>
+  <a href="https://unpkg.com/builtin-type/dist/index.js">
+    <img src="https://deno.bundlejs.com/?q=builtin-type&config={%22compression%22:{%22type%22:%22brotli%22}}&badge" alt="brotli size" />
+  </a>
+  <a href="https://github.com/sponsors/TomerAberbach">
+    <img src="https://img.shields.io/static/v1?label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=%23fe8e86" alt="Sponsor" />
+  </a>
+</div>
+
+<div align="center">
+  What is the type of this builtin JS value?
+</div>
+
+## Features
+
+- **Comprehensive:** Supports a ton of builtin types
+- **Robust:** Works
+  [cross-realm](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms)
+- **Secure:** Resilient to spoofing
+- **Tiny:** One 635 B gzipped package instead of
+  [`which-builtin-type`'s 10.5 kB gzipped total size](https://bundlejs.com/?q=which-builtin-type%401.2.1)
+  with [50 dependencies](https://npmgraph.js.org/?q=which-builtin-type#zoom=w)
+
+## Install
+
+> [!NOTE]
+>
+> Determining the builtin type in a way that works cross-realm and is resilient
+> to spoofing is significantly slower than plain
+> [`instanceof`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof)
+> or
+> [`Object.prototype.toString.call(...)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString#using_tostring_to_detect_object_class).
+> If you don't need those guarantees, then just use these simpler options
+> directly.
+
+```sh
+$ npm i builtin-type
+```
+
+## Usage
+
+<!-- eslint-disable require-unicode-regexp, prefer-regex-literals, no-new-wrappers, unicorn/new-for-builtins, symbol-description -->
+
+```js
+import assert from 'node:assert'
+import builtinType from 'builtin-type'
+
+assert.equal(builtinType(undefined), `undefined`)
+assert.equal(builtinType(null), `null`)
+assert.equal(builtinType(false), `boolean`)
+assert.equal(builtinType(42), `number`)
+assert.equal(builtinType(42n), `bigint`)
+assert.equal(builtinType(`foo`), `string`)
+assert.equal(builtinType(Symbol()), `symbol`)
+assert.equal(builtinType(new Boolean(false)), `Boolean`)
+assert.equal(builtinType(new Number(42)), `Number`)
+assert.equal(builtinType(new String(`foo`)), `String`)
+assert.equal(builtinType([]), `Array`)
+assert.equal(builtinType(new Map()), `Map`)
+assert.equal(builtinType(new Set()), `Set`)
+assert.equal(builtinType(new WeakMap()), `WeakMap`)
+assert.equal(builtinType(new WeakSet()), `WeakSet`)
+assert.equal(
+  builtinType(() => {}),
+  `Function`,
+)
+assert.equal(
+  builtinType(function* () {}),
+  `GeneratorFunction`,
+)
+assert.equal(
+  builtinType(async () => {}),
+  `AsyncFunction`,
+)
+assert.equal(
+  builtinType(async function* () {}),
+  `AsyncGeneratorFunction`,
+)
+assert.equal(builtinType(Promise.resolve()), `Promise`)
+assert.equal(builtinType(new Date()), `Date`)
+assert.equal(builtinType(/a/g), `RegExp`)
+assert.equal(builtinType(new URL(`https://example.com/`)), `URL`)
+assert.equal(builtinType(new URLSearchParams()), `URLSearchParams`)
+assert.equal(builtinType(new WeakRef({})), `WeakRef`)
+assert.equal(
+  builtinType(new FinalizationRegistry(() => {})),
+  `FinalizationRegistry`,
+)
+assert.equal(builtinType(new ArrayBuffer()), `ArrayBuffer`)
+assert.equal(builtinType(new SharedArrayBuffer()), `SharedArrayBuffer`)
+assert.equal(builtinType(Buffer.from([])), `Buffer`)
+assert.equal(builtinType(new Int8Array()), `Int8Array`)
+assert.equal(builtinType(new Uint8Array()), `Uint8Array`)
+assert.equal(builtinType(new Uint8ClampedArray()), `Uint8ClampedArray`)
+assert.equal(builtinType(new Int16Array()), `Int16Array`)
+assert.equal(builtinType(new Uint16Array()), `Uint16Array`)
+assert.equal(builtinType(new Int32Array()), `Int32Array`)
+assert.equal(builtinType(new Uint32Array()), `Uint32Array`)
+assert.equal(builtinType(new BigInt64Array()), `BigInt64Array`)
+assert.equal(builtinType(new BigUint64Array()), `BigUint64Array`)
+assert.equal(builtinType(new Float16Array()), `Float16Array`)
+assert.equal(builtinType(new Float32Array()), `Float32Array`)
+assert.equal(builtinType(new Float64Array()), `Float64Array`)
+assert.equal(builtinType(new DataView(new ArrayBuffer())), `DataView`)
+assert.equal(builtinType({}), `Object`)
+```
+
+## Benchmarks
+
+`builtin-type` is at least as fast as
+[`which-builtin-type`](https://www.npmjs.com/package/which-builtin-type). It may
+be slightly faster, but that could just be noise in the benchmarks.
+
+Here's an example run of [the benchmark](./src/index.bench.ts):
+
+```
+ ✓ src/index.bench.ts 3333ms
+     name                   hz      min      max     mean      p75      p99     p995     p999     rme  samples
+   · whichBuiltinType  66.9824  14.6727  15.4056  14.9293  15.0297  15.4056  15.4056  15.4056  ±0.43%       34
+   · builtinType       71.4251  13.7500  14.6090  14.0007  14.0046  14.6090  14.6090  14.6090  ±0.41%       36
+
+  builtinType - src/index.bench.ts
+    1.07x faster than whichBuiltinType
+```
+
+## Contributing
+
+Stars are always welcome!
+
+For bugs and feature requests,
+[please create an issue](https://github.com/TomerAberbach/builtin-type/issues/new).
+
+## License
+
+[MIT](https://github.com/TomerAberbach/builtin-type/blob/main/license) ©
+[Tomer Aberbach](https://github.com/TomerAberbach)