@rcompat/is 0.4.1 → 0.4.3

package/lib/private/index.d.ts

@@ -5,9 +5,11 @@ import object from "#object";
 import primitive from "#primitive";
 import type { Dict, Nullish, UnknownFunction } from "@rcompat/type";
 declare function isArray(x: unknown): x is unknown[];
+declare function isArrayBuffer(x: unknown): x is ArrayBuffer;
 declare function isBigint(x: unknown): x is bigint;
 declare function isBlob(x: unknown): x is Blob;
 declare function isBoolean(x: unknown): x is boolean;
+declare function isBytes(x: unknown): x is Uint8Array;
 declare function isDate(x: unknown): x is Date;
 declare function isDefined(x: unknown): x is {} | null;
 declare function isDict(x: unknown): x is Dict;
@@ -22,6 +24,8 @@ declare function isNullish(x: unknown): x is Nullish;
 declare function isNumber(x: unknown): x is number;
 declare function isPromise(x: unknown): x is Promise<unknown>;
 declare function isRegExp(x: unknown): x is RegExp;
+declare function isRequest(x: unknown): x is Request;
+declare function isResponse(x: unknown): x is Response;
 declare function isSet(x: unknown): x is Set<unknown>;
 declare function isString(x: unknown): x is string;
 declare function isSymbol(x: unknown): x is symbol;
@@ -31,11 +35,13 @@ declare function isUndefined(x: unknown): x is undefined;
 declare function isURL(x: unknown): x is URL;
 declare const _default: {
     array: typeof isArray;
+    arraybuffer: typeof isArrayBuffer;
     bigint: typeof isBigint;
     blank: (x: unknown) => x is string;
     blob: typeof isBlob;
     boolish: (x: unknown) => x is import("@rcompat/type").Boolish;
     boolean: typeof isBoolean;
+    bytes: typeof isBytes;
     date: typeof isDate;
     defined: typeof isDefined;
     dict: typeof isDict;
@@ -49,8 +55,8 @@ declare const _default: {
     iterable: typeof isIterable;
     map: typeof isMap;
     nan: (x: unknown) => x is number;
+    nonempty: <T>(x: T | Nullish) => x is T;
     newable: typeof newable;
-    nonempty: (x: unknown) => boolean;
     null: typeof isNull;
     nullish: typeof isNullish;
     number: typeof isNumber;
@@ -58,6 +64,8 @@ declare const _default: {
     object: typeof object;
     primitive: typeof primitive;
     promise: typeof isPromise;
+    request: typeof isRequest;
+    response: typeof isResponse;
     regexp: typeof isRegExp;
     safeint: (x: unknown) => x is number;
     set: typeof isSet;

package/lib/private/index.js

@@ -8,6 +8,9 @@ import strings from "#strings";
 function isArray(x) {
     return Array.isArray(x);
 }
+function isArrayBuffer(x) {
+    return x instanceof ArrayBuffer;
+}
 function isBigint(x) {
     return typeof x === "bigint";
 }
@@ -17,6 +20,9 @@ function isBlob(x) {
 function isBoolean(x) {
     return typeof x === "boolean";
 }
+function isBytes(x) {
+    return x instanceof Uint8Array;
+}
 function isDate(x) {
     return x instanceof Date;
 }
@@ -62,6 +68,12 @@ function isPromise(x) {
 function isRegExp(x) {
     return x instanceof RegExp;
 }
+function isRequest(x) {
+    return x instanceof Request;
+}
+function isResponse(x) {
+    return x instanceof Response;
+}
 function isSet(x) {
     return x instanceof Set;
 }
@@ -85,11 +97,13 @@ function isURL(x) {
 }
 export default {
     array: isArray,
+    arraybuffer: isArrayBuffer,
     bigint: isBigint,
     blank: strings.isBlank,
     blob: isBlob,
     boolish: strings.isBoolish,
     boolean: isBoolean,
+    bytes: isBytes,
     date: isDate,
     defined: isDefined,
     dict: isDict,
@@ -103,8 +117,8 @@ export default {
     iterable: isIterable,
     map: isMap,
     nan: numbers.isNaN,
-    newable,
     nonempty: (x) => !empty(x),
+    newable,
     null: isNull,
     nullish: isNullish,
     number: isNumber,
@@ -112,8 +126,10 @@ export default {
     object,
     primitive,
     promise: isPromise,
+    request: isRequest,
+    response: isResponse,
     regexp: isRegExp,
-    safeint: numbers.isSafeint,
+    safeint: numbers.isSafeInt,
     set: isSet,
     string: isString,
     symbol: isSymbol,

package/lib/private/numbers.d.ts

@@ -1,13 +1,13 @@
 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 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;
+    isSafeInt: typeof isSafeInt;
     isUint: typeof isUint;
 };
 export default _default;

package/lib/private/numbers.js

@@ -15,7 +15,7 @@ function isInt(x) {
 function isNaN(x) {
     return typeof x === "number" && Number.isNaN(x);
 }
-function isSafeint(x) {
+function isSafeInt(x) {
     if (typeof x === "number")
         return Number.isSafeInteger(x);
     return false;
@@ -31,7 +31,7 @@ export default {
     isFinite,
     isInt,
     isNaN,
-    isSafeint,
+    isSafeInt,
     isUint,
 };
 //# sourceMappingURL=numbers.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcompat/is",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Standard library identity checks",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",