@rcompat/is 0.1.3 → 0.2.0

package/README.md

@@ -0,0 +1,383 @@
+# @rcompat/is
+
+Type guard predicates for JavaScript runtimes.
+
+## What is @rcompat/is?
+
+A cross-runtime module providing type guard functions for common value checks.
+All functions return boolean and include TypeScript type narrowing. Works
+consistently across Node, Deno, and Bun.
+
+## Installation
+
+```bash
+npm install @rcompat/is
+```
+
+```bash
+pnpm add @rcompat/is
+```
+
+```bash
+yarn add @rcompat/is
+```
+
+```bash
+bun add @rcompat/is
+```
+
+## Usage
+
+### nullish
+
+Checks if a value is `null` or `undefined`.
+
+```js
+import is from "@rcompat/is";
+
+is.nullish(null);      // true
+is.nullish(undefined); // true
+is.nullish(0);         // false
+is.nullish("");        // false
+is.nullish(false);     // false
+```
+
+### defined
+
+Checks if a value is not `undefined`.
+
+```js
+import is from "@rcompat/is";
+
+is.defined("hello");   // true
+is.defined(0);         // true
+is.defined(null);      // true
+is.defined(undefined); // false
+```
+
+### truthy
+
+Checks if a value is truthy.
+
+```js
+import is from "@rcompat/is";
+
+is.truthy(1);       // true
+is.truthy("hello"); // true
+is.truthy([]);      // true
+is.truthy(0);       // false
+is.truthy("");      // false
+is.truthy(null);    // false
+```
+
+### falsy
+
+Checks if a value is falsy.
+
+```js
+import is from "@rcompat/is";
+
+is.falsy(0);         // true
+is.falsy("");        // true
+is.falsy(null);      // true
+is.falsy(undefined); // true
+is.falsy(false);     // true
+is.falsy(NaN);       // true
+is.falsy(1);         // false
+```
+
+### empty
+
+Checks if a value is empty (strings, arrays, Sets, Maps, objects).
+
+```js
+import is from "@rcompat/is";
+
+is.empty("");        // true
+is.empty([]);        // true
+is.empty({});        // true
+is.empty(new Set()); // true
+is.empty(new Map()); // true
+is.empty("hello");   // false
+is.empty([1, 2]);    // false
+is.empty({ a: 1 });  // false
+```
+
+### blank
+
+Checks if a string is empty or contains only whitespace.
+
+```js
+import is from "@rcompat/is";
+
+is.blank("");      // true
+is.blank("   ");   // true
+is.blank("\t\n");  // true
+is.blank("hello"); // false
+is.blank(" hi ");  // false
+```
+
+### numeric
+
+Checks if a string represents a valid number.
+
+```js
+import is from "@rcompat/is";
+
+is.numeric("123");    // true
+is.numeric("-45.67"); // true
+is.numeric("1e10");   // true
+is.numeric("+3.14");  // true
+is.numeric("abc");    // false
+is.numeric("");       // false
+is.numeric("12px");   // false
+```
+
+### int
+
+Checks if a value is an integer number.
+
+```js
+import is from "@rcompat/is";
+
+is.int(42);   // true
+is.int(-10);  // true
+is.int(0);    // true
+is.int(3.14); // false
+is.int(NaN);  // false
+is.int("42"); // false
+```
+
+### uint
+
+Checks if a value is a positive integer (unsigned).
+
+```js
+import is from "@rcompat/is";
+
+is.uint(1);    // true
+is.uint(100);  // true
+is.uint(0);    // false
+is.uint(-1);   // false
+is.uint(3.14); // false
+```
+
+### safeint
+
+Checks if a value is a safe integer (within JavaScript's safe range).
+
+```js
+import is from "@rcompat/is";
+
+is.safeint(42);                          // true
+is.safeint(Number.MAX_SAFE_INTEGER);     // true
+is.safeint(Number.MAX_SAFE_INTEGER + 1); // false
+is.safeint(3.14);                        // false
+```
+
+### finite
+
+Checks if a number or bigint is finite.
+
+```js
+import is from "@rcompat/is";
+
+is.finite(42);        // true
+is.finite(3.14);      // true
+is.finite(100n);      // true (bigints are always finite)
+is.finite(Infinity);  // false
+is.finite(-Infinity); // false
+is.finite(NaN);       // false
+```
+
+### nan
+
+Checks if a value is `NaN`.
+
+```js
+import is from "@rcompat/is";
+
+is.nan(NaN);            // true
+is.nan(Number.NaN);     // true
+is.nan(0 / 0);          // true
+is.nan(42);             // false
+is.nan("NaN");          // false
+```
+
+### primitive
+
+Checks if a value is a primitive type.
+
+```js
+import is from "@rcompat/is";
+
+is.primitive("hello");   // true
+is.primitive(42);        // true
+is.primitive(true);      // true
+is.primitive(null);      // true
+is.primitive(undefined); // true
+is.primitive(Symbol());  // true
+is.primitive(100n);      // true
+is.primitive({});        // false
+is.primitive([]);        // false
+```
+
+### dict
+
+Checks if a value is a plain object (not array, Date, class instance, etc.).
+
+```js
+import is from "@rcompat/is";
+
+is.dict({});                  // true
+is.dict({ a: 1 });            // true
+is.dict(Object.create(null)); // true
+is.dict([]);                  // false
+is.dict(new Date());          // false
+is.dict(new Map());           // false
+is.dict(null);                // false
+```
+
+### newable
+
+Checks if a value is a constructor (can be called with `new`).
+
+```js
+import is from "@rcompat/is";
+
+is.newable(class {});      // true
+is.newable(function() {}); // true
+is.newable(Date);          // true
+is.newable(() => {});      // false (arrow functions)
+is.newable({});            // false
+```
+
+### boolish
+
+Checks if a value is the string `"true"` or `"false"`.
+
+```js
+import is from "@rcompat/is";
+
+is.boolish("true");  // true
+is.boolish("false"); // true
+is.boolish(true);    // false (not a string)
+is.boolish("yes");   // false
+is.boolish("1");     // false
+```
+
+## API Reference
+
+All functions follow the same pattern:
+
+```ts
+declare function is<Name>(value: unknown): value is <Type>;
+```
+
+| Function      | Type Guard          | Description                    |
+|---------------|---------------------|--------------------------------|
+| `nullish`     | `null \| undefined` | `null` or `undefined`          |
+| `defined`     | `unknown`           | not `undefined`                |
+| `truthy`      | `unknown`           | `true` in boolean contexts     |
+| `falsy`       | `unknown`           | `false` in boolean contexts    |
+| `empty`       | `unknown`           | empty collection/string/object |
+| `blank`       | `string`            | empty/whitespace string        |
+| `numeric`     | `string`            | numeric string                 |
+| `int`         | `number`            | integer number                 |
+| `uint`        | `number \| bigint`  | unsigned (positive) integer    |
+| `safeint`     | `number`            | safe integer                   |
+| `finite`      | `number \| bigint`  | finite number                  |
+| `nan`         | `number`            | `NaN`                          |
+| `primitive`   | `Primitive`         | primitive type                 |
+| `dict`        | `Dict`              | plain object                   |
+| `newable`     | `Newable`           | constructor                    |
+| `boolish`     | `"true" \| "false"` | boolean string                 |
+
+## Examples
+
+### Filter valid values
+
+```js
+import is from "@rcompat/is";
+
+const values = [1, null, 2, undefined, 3];
+
+values.filter(is.defined);     // [1, null, 2, 3]
+values.filter(v => !is.nullish(v));  // [1, 2, 3]
+```
+
+### Parse configuration
+
+```js
+import is from "@rcompat/is";
+
+function parseEnvVar(value) {
+  if (is.boolish(value)) return value === "true";
+  if (is.numeric(value)) return Number(value);
+  return value;
+}
+
+parseEnvVar("true");   // true
+parseEnvVar("42");     // 42
+parseEnvVar("hello");  // "hello"
+```
+
+### Validate input
+
+```js
+import is from "@rcompat/is";
+
+function validateForm(data) {
+  const errors = [];
+
+  if (is.blank(data.name)) {
+    errors.push("Name is required");
+  }
+
+  if (!uint(data.age)) {
+    errors.push("Age must be a positive integer");
+  }
+
+  return errors;
+}
+```
+
+### Type-safe guards
+
+```js
+import is from "@rcompat/is";
+
+function process(value) {
+  if (is.primitive(value)) {
+    // TypeScript knows: value is:
+    // string | number | boolean | bigint | symbol | null | undefined
+    return String(value);
+  }
+
+  if (is.dict(value)) {
+    // TypeScript knows: value is Record<string, unknown>
+    return JSON.stringify(value);
+  }
+
+  return "[complex object]";
+}
+```
+
+## Cross-Runtime Compatibility
+
+| Runtime | Supported |
+|---------|-----------|
+| Node.js | ✓         |
+| Deno    | ✓         |
+| Bun     | ✓         |
+
+No configuration required — just import and use.
+
+## License
+
+MIT
+
+## Contributing
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md) in the repository root.
+

package/lib/private/array.d.ts

@@ -0,0 +1,3 @@
+declare const _default: (arg: any) => arg is any[];
+export default _default;
+//# sourceMappingURL=array.d.ts.map

package/lib/private/array.js

@@ -0,0 +1,2 @@
+export default Array.isArray;
+//# sourceMappingURL=array.js.map

package/lib/private/date.d.ts

@@ -0,0 +1,2 @@
+export default function isDate(x: unknown): x is Date;
+//# sourceMappingURL=date.d.ts.map

package/lib/private/date.js

@@ -0,0 +1,4 @@
+export default function isDate(x) {
+    return x instanceof Date;
+}
+//# sourceMappingURL=date.js.map

package/lib/private/dict.d.ts

@@ -0,0 +1,3 @@
+import type Dict from "@rcompat/type/Dict";
+export default function isDict(x: unknown): x is Dict;
+//# sourceMappingURL=dict.d.ts.map

package/lib/private/dict.js

@@ -0,0 +1,7 @@
+export default function isDict(x) {
+    if (typeof x !== "object" || x === null)
+        return false;
+    const prototype = Object.getPrototypeOf(x);
+    return prototype === Object.prototype || prototype === null;
+}
+//# sourceMappingURL=dict.js.map

package/lib/private/empty.js

@@ -5,12 +5,6 @@ export default function isEmpty(x) {
         return x.size === 0;
     if (typeof x === "object" && x !== null)
         return Object.keys(x).length === 0;
-    if (x && typeof x === "object") {
-        const prototype = Object.getPrototypeOf(x);
-        if (prototype === Object.prototype || prototype === null) {
-            return Object.keys(x).length === 0;
-        }
-    }
     return false;
 }
 //# sourceMappingURL=empty.js.map

package/lib/private/finite.js

@@ -1,10 +1,8 @@
 export default function isFinite(x) {
-    if (typeof x === "bigint") {
+    if (typeof x === "bigint")
         return true;
-    }
-    if (typeof x === "number") {
+    if (typeof x === "number")
         return Number.isFinite(x);
-    }
     return false;
 }
 //# sourceMappingURL=finite.js.map

package/lib/private/index.d.ts

@@ -0,0 +1,48 @@
+import empty from "#empty";
+import newable from "#newable";
+import numeric from "#numeric";
+import object from "#object";
+import primitive from "#primitive";
+import type Dict from "@rcompat/type/Dict";
+import type Nullish from "@rcompat/type/Nullish";
+declare function isDate(x: unknown): x is Date;
+declare function isDefined(x: unknown): x is {} | null;
+declare function isDict(x: unknown): x is Dict;
+declare function isError(x: unknown): x is Error;
+declare function isFalsy(x: unknown): boolean;
+declare function isNullish(x: unknown): x is Nullish;
+declare function isPromise(x: unknown): x is Promise<unknown>;
+declare function isRegExp(x: unknown): x is RegExp;
+declare function isTruthy(x: unknown): boolean;
+declare function isURL(x: unknown): x is URL;
+declare function isMap(x: unknown): x is Map<unknown, unknown>;
+declare function isSet(x: unknown): x is Set<unknown>;
+declare const _default: {
+    array: (arg: any) => arg is any[];
+    blank: (x: unknown) => x is string;
+    boolish: (x: unknown) => x is import("@rcompat/type/Boolish").default;
+    date: typeof isDate;
+    defined: typeof isDefined;
+    dict: typeof isDict;
+    empty: typeof empty;
+    error: typeof isError;
+    falsy: typeof isFalsy;
+    finite: (x: unknown) => x is bigint | number;
+    int: (x: unknown) => x is bigint | number;
+    map: typeof isMap;
+    nan: (x: unknown) => x is number;
+    newable: typeof newable;
+    nullish: typeof isNullish;
+    numeric: typeof numeric;
+    object: typeof object;
+    primitive: typeof primitive;
+    promise: typeof isPromise;
+    regexp: typeof isRegExp;
+    safeint: (x: unknown) => x is number;
+    set: typeof isSet;
+    truthy: typeof isTruthy;
+    uint: (x: unknown) => x is bigint | number;
+    url: typeof isURL;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/private/index.js

@@ -0,0 +1,74 @@
+import empty from "#empty";
+import newable from "#newable";
+import numbers from "#numbers";
+import numeric from "#numeric";
+import object from "#object";
+import primitive from "#primitive";
+import strings from "#strings";
+function isDate(x) {
+    return x instanceof Date;
+}
+function isDefined(x) {
+    return x !== undefined;
+}
+function isDict(x) {
+    if (typeof x !== "object" || x === null)
+        return false;
+    const prototype = Object.getPrototypeOf(x);
+    return prototype === Object.prototype || prototype === null;
+}
+function isError(x) {
+    return x instanceof Error;
+}
+function isFalsy(x) {
+    return !x;
+}
+function isNullish(x) {
+    return x === null || x === undefined;
+}
+function isPromise(x) {
+    return x instanceof Promise;
+}
+function isRegExp(x) {
+    return x instanceof RegExp;
+}
+function isTruthy(x) {
+    return !!x;
+}
+function isURL(x) {
+    return x instanceof URL;
+}
+function isMap(x) {
+    return x instanceof Map;
+}
+function isSet(x) {
+    return x instanceof Set;
+}
+export default {
+    array: Array.isArray,
+    blank: strings.isBlank,
+    boolish: strings.isBoolish,
+    date: isDate,
+    defined: isDefined,
+    dict: isDict,
+    empty,
+    error: isError,
+    falsy: isFalsy,
+    finite: numbers.isFinite,
+    int: numbers.isInt,
+    map: isMap,
+    nan: numbers.isNaN,
+    newable,
+    nullish: isNullish,
+    numeric,
+    object,
+    primitive,
+    promise: isPromise,
+    regexp: isRegExp,
+    safeint: numbers.isSafeint,
+    set: isSet,
+    truthy: isTruthy,
+    uint: numbers.isUint,
+    url: isURL,
+};
+//# sourceMappingURL=index.js.map

package/lib/private/int.d.ts

@@ -0,0 +1,2 @@
+export default function isInt(x: unknown): x is number;
+//# sourceMappingURL=int.d.ts.map

package/lib/private/{integer.js → int.js}

@@ -1,6 +1,6 @@
-export default function isInteger(x) {
+export default function isInt(x) {
     if (typeof x === "number")
         return Number.isInteger(x);
     return false;
 }
-//# sourceMappingURL=integer.js.map
+//# sourceMappingURL=int.js.map

package/lib/private/numbers.d.ts

@@ -0,0 +1,14 @@
+declare function isFinite(x: unknown): x is bigint | number;
+declare function isInt(x: unknown): x is bigint | number;
+declare function isNaN(x: unknown): x is number;
+declare function isSafeint(x: unknown): x is number;
+declare function isUint(x: unknown): x is bigint | number;
+declare const _default: {
+    isFinite: typeof isFinite;
+    isInt: typeof isInt;
+    isNaN: typeof isNaN;
+    isSafeint: typeof isSafeint;
+    isUint: typeof isUint;
+};
+export default _default;
+//# sourceMappingURL=numbers.d.ts.map

package/lib/private/numbers.js

@@ -0,0 +1,37 @@
+function isFinite(x) {
+    if (typeof x === "bigint")
+        return true;
+    if (typeof x === "number")
+        return Number.isFinite(x);
+    return false;
+}
+function isInt(x) {
+    if (typeof x === "number")
+        return Number.isInteger(x);
+    if (typeof x === "bigint")
+        return true;
+    return false;
+}
+function isNaN(x) {
+    return typeof x === "number" && Number.isNaN(x);
+}
+function isSafeint(x) {
+    if (typeof x === "number")
+        return Number.isSafeInteger(x);
+    return false;
+}
+function isUint(x) {
+    if (typeof x === "bigint")
+        return x >= 0n;
+    if (typeof x === "number")
+        return Number.isInteger(x) && x >= 0;
+    return false;
+}
+export default {
+    isFinite,
+    isInt,
+    isNaN,
+    isSafeint,
+    isUint,
+};
+//# sourceMappingURL=numbers.js.map

package/lib/private/numeric.js

@@ -1,12 +1,10 @@
 const DECIMAL = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
 export default function isNumeric(x) {
-    if (typeof x !== "string") {
+    if (typeof x !== "string")
         return false;
-    }
     const trimmed = x.trim();
-    if (trimmed === "") {
+    if (trimmed === "")
         return false;
-    }
     return DECIMAL.test(trimmed);
 }
 //# sourceMappingURL=numeric.js.map

package/lib/private/object.d.ts

@@ -0,0 +1,2 @@
+export default function isObject(x: unknown): x is object;
+//# sourceMappingURL=object.d.ts.map

package/lib/private/object.js

@@ -0,0 +1,4 @@
+export default function isObject(x) {
+    return typeof x === "object" && x !== null;
+}
+//# sourceMappingURL=object.js.map

package/lib/private/primitive.js

@@ -1,8 +1,8 @@
 const primitives = [
-    "string",
-    "number",
-    "boolean",
     "bigint",
+    "boolean",
+    "number",
+    "string",
     "symbol",
     "undefined",
 ];

package/lib/private/promise.d.ts

@@ -0,0 +1,2 @@
+export default function isPromise(x: unknown): x is Promise<unknown>;
+//# sourceMappingURL=promise.d.ts.map

package/lib/private/promise.js

@@ -0,0 +1,4 @@
+export default function isPromise(x) {
+    return x instanceof Promise;
+}
+//# sourceMappingURL=promise.js.map

package/lib/private/regexp.d.ts

@@ -0,0 +1,2 @@
+export default function isRegExp(x: unknown): x is RegExp;
+//# sourceMappingURL=regexp.d.ts.map

package/lib/private/regexp.js

@@ -0,0 +1,4 @@
+export default function isRegExp(x) {
+    return x instanceof RegExp;
+}
+//# sourceMappingURL=regexp.js.map

package/lib/private/safeint.d.ts

@@ -0,0 +1,2 @@
+export default function isSafeint(x: unknown): x is number;
+//# sourceMappingURL=safeint.d.ts.map

package/lib/private/{safe-integer.js → safeint.js}

@@ -1,6 +1,6 @@
-export default function isSafeInteger(x) {
+export default function isSafeint(x) {
     if (typeof x === "number")
         return Number.isSafeInteger(x);
     return false;
 }
-//# sourceMappingURL=safe-integer.js.map
+//# sourceMappingURL=safeint.js.map

package/lib/private/strings.d.ts

@@ -0,0 +1,9 @@
+import type Boolish from "@rcompat/type/Boolish";
+declare function isBlank(x: unknown): x is string;
+declare function isBoolish(x: unknown): x is Boolish;
+declare const _default: {
+    isBlank: typeof isBlank;
+    isBoolish: typeof isBoolish;
+};
+export default _default;
+//# sourceMappingURL=strings.d.ts.map

package/lib/private/strings.js

@@ -0,0 +1,11 @@
+function isBlank(x) {
+    return typeof x === "string" && /^\s*$/.test(x);
+}
+function isBoolish(x) {
+    return x === "true" || x === "false";
+}
+export default {
+    isBlank,
+    isBoolish,
+};
+//# sourceMappingURL=strings.js.map

package/lib/private/uint.js

@@ -1,5 +1,5 @@
-import isInteger from "#integer";
+import int from "#int";
 export default function isUint(x) {
-    return isInteger(x) && BigInt(x) > 0n;
+    return int(x) && BigInt(x) >= 0n;
 }
 //# sourceMappingURL=uint.js.map

package/lib/private/url.d.ts

@@ -0,0 +1,2 @@
+export default function isURL(x: unknown): x is URL;
+//# sourceMappingURL=url.d.ts.map

package/lib/private/url.js

@@ -0,0 +1,4 @@
+export default function isURL(x) {
+    return x instanceof URL;
+}
+//# sourceMappingURL=url.js.map

package/lib/public/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "#index";
+//# sourceMappingURL=index.d.ts.map

package/lib/public/index.js

@@ -0,0 +1,2 @@
+export { default } from "#index";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rcompat/is",
-  "version": "0.1.3",
-  "description": "Standard library value qualifying",
+  "version": "0.2.0",
+  "description": "Standard library identity checks",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",
   "files": [
@@ -22,9 +22,9 @@
     }
   },
   "exports": {
-    "./*": {
-      "apekit": "./src/public/*.ts",
-      "default": "./lib/public/*.js"
+    ".": {
+      "apekit": "./src/public/index.ts",
+      "default": "./lib/public/index.js"
     }
   },
   "scripts": {

package/lib/private/integer.d.ts

@@ -1,2 +0,0 @@
-export default function isInteger(x: unknown): x is number;
-//# sourceMappingURL=integer.d.ts.map

package/lib/private/safe-integer.d.ts

@@ -1,2 +0,0 @@
-export default function isSafeInteger(x: unknown): x is number;
-//# sourceMappingURL=safe-integer.d.ts.map

package/lib/public/blank.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#blank";
-//# sourceMappingURL=blank.d.ts.map

package/lib/public/blank.js

@@ -1,2 +0,0 @@
-export { default } from "#blank";
-//# sourceMappingURL=blank.js.map

package/lib/public/boolish.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#boolish";
-//# sourceMappingURL=boolish.d.ts.map

package/lib/public/boolish.js

@@ -1,2 +0,0 @@
-export { default } from "#boolish";
-//# sourceMappingURL=boolish.js.map

package/lib/public/defined.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#defined";
-//# sourceMappingURL=defined.d.ts.map

package/lib/public/defined.js

@@ -1,2 +0,0 @@
-export { default } from "#defined";
-//# sourceMappingURL=defined.js.map

package/lib/public/empty.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#empty";
-//# sourceMappingURL=empty.d.ts.map

package/lib/public/empty.js

@@ -1,2 +0,0 @@
-export { default } from "#empty";
-//# sourceMappingURL=empty.js.map

package/lib/public/falsy.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#falsy";
-//# sourceMappingURL=falsy.d.ts.map

package/lib/public/falsy.js

@@ -1,2 +0,0 @@
-export { default } from "#falsy";
-//# sourceMappingURL=falsy.js.map

package/lib/public/finite.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#finite";
-//# sourceMappingURL=finite.d.ts.map

package/lib/public/finite.js

@@ -1,2 +0,0 @@
-export { default } from "#finite";
-//# sourceMappingURL=finite.js.map

package/lib/public/integer.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#integer";
-//# sourceMappingURL=integer.d.ts.map

package/lib/public/integer.js

@@ -1,2 +0,0 @@
-export { default } from "#integer";
-//# sourceMappingURL=integer.js.map

package/lib/public/nan.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#nan";
-//# sourceMappingURL=nan.d.ts.map

package/lib/public/nan.js

@@ -1,2 +0,0 @@
-export { default } from "#nan";
-//# sourceMappingURL=nan.js.map

package/lib/public/newable.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#newable";
-//# sourceMappingURL=newable.d.ts.map

package/lib/public/newable.js

@@ -1,2 +0,0 @@
-export { default } from "#newable";
-//# sourceMappingURL=newable.js.map

package/lib/public/nullish.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#nullish";
-//# sourceMappingURL=nullish.d.ts.map

package/lib/public/nullish.js

@@ -1,2 +0,0 @@
-export { default } from "#nullish";
-//# sourceMappingURL=nullish.js.map

package/lib/public/numeric.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#numeric";
-//# sourceMappingURL=numeric.d.ts.map

package/lib/public/numeric.js

@@ -1,2 +0,0 @@
-export { default } from "#numeric";
-//# sourceMappingURL=numeric.js.map

package/lib/public/primitive.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#primitive";
-//# sourceMappingURL=primitive.d.ts.map

package/lib/public/primitive.js

@@ -1,2 +0,0 @@
-export { default } from "#primitive";
-//# sourceMappingURL=primitive.js.map

package/lib/public/safe-integer.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#safe-integer";
-//# sourceMappingURL=safe-integer.d.ts.map

package/lib/public/safe-integer.js

@@ -1,2 +0,0 @@
-export { default } from "#safe-integer";
-//# sourceMappingURL=safe-integer.js.map

package/lib/public/truthy.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#truthy";
-//# sourceMappingURL=truthy.d.ts.map

package/lib/public/truthy.js

@@ -1,2 +0,0 @@
-export { default } from "#truthy";
-//# sourceMappingURL=truthy.js.map

package/lib/public/uint.d.ts

@@ -1,2 +0,0 @@
-export { default } from "#uint";
-//# sourceMappingURL=uint.d.ts.map

package/lib/public/uint.js

@@ -1,2 +0,0 @@
-export { default } from "#uint";
-//# sourceMappingURL=uint.js.map