is.undefined(value);

is.null(value);

is.string(value);

is.number(value);

is.boolean(value);

is.symbol(value);

is.bigint(value);

is.array(value, assertion?)

is.array(value); // Validate `value` is an array.
is.array(value, is.number); // Validate `value` is an array and all of its items are numbers.

is.function(value);

is.buffer(value);

is.blob(value);

is.object(value);

is.numericString(value);

is.regExp(value);

is.date(value);

is.error(value);

is.nativePromise(value);

is.promise(value);

is.generator(value);

is.generatorFunction(value);

is.asyncFunction(value);

is.asyncFunction(async () => {});
// true

is.asyncFunction(() => {});
// false

is.asyncGenerator(value);

is.asyncGenerator(
  (async function* () {
    yield 4;
  })(),
);
// true

is.asyncGenerator(
  (function* () {
    yield 4;
  })(),
);
// false

is.asyncGeneratorFunction(value);

is.asyncGeneratorFunction(async function* () {
  yield 4;
});
// true

is.asyncGeneratorFunction(function* () {
  yield 4;
});
// false

is.boundFunction(value);

is.boundFunction(() => {});
// true

is.boundFunction(function () {}.bind(null));
// true

is.boundFunction(function () {});
// false

is.map(value);

is.set(value);

is.weakMap(value);

is.weakSet(value);

is.weakRef(value);

is.int8Array(value);

is.uint8Array(value);

is.uint8ClampedArray(value);

is.int16Array(value);

is.uint16Array(value);

is.int32Array(value);

is.uint32Array(value);

is.float32Array(value);

is.float64Array(value);

is.bigInt64Array(value);

is.bigUint64Array(value);

is.arrayBuffer(value);

is.sharedArrayBuffer(value);

is.dataView(value);

is.enumCase(value, enum)

enum Direction {
  Ascending = "ascending",
  Descending = "descending",
}
is.enumCase("ascending", Direction);
// true
is.enumCase("other", Direction);
// false

is.emptyString(value);

is.emptyStringOrWhitespace(value);

is.nonEmptyString(value);

is.nonEmptyStringAndNotWhitespace(value);

const values = ["property1", "", null, "property2", "    ", undefined];
values.filter(is.nonEmptyStringAndNotWhitespace);
// ['property1', 'property2']

is.emptyArray(value);

is.nonEmptyArray(value);

is.emptyObject(value);

const object1 = {};
Object.defineProperty(object1, "property1", {
  value: 42,
  writable: true,
  enumerable: false,
  configurable: true,
});
is.emptyObject(object1);
// true

is.nonEmptyObject(value);

is.emptySet(value);

is.nonEmptySet(Value);

is.emptyMap(value);

is.nonEmptyMap(value);

is.directInstanceOf(value, class)

is.directInstanceOf(new Error(), Error);
// true
class UnicornError extends Error {}
is.directInstanceOf(new UnicornError(), Error);
// false

is.urlInstance(value);

const url = new URL("https://example.com");
is.urlInstance(url);
// true

is.urlString(value);

const url = "https://example.com";
is.urlString(url);
// true
is.urlString(new URL(url));
// false

is.truthy(value);

is.truthy("🦕");
// true
is.truthy(undefined);
// false

is.falsy(value);

is.nan(value);

is.nullOrUndefined(value);

is.primitive(value);

is.integer(value);

is.safeInteger(value);

is.plainObject(value);

is.iterable(value);

is.asyncIterable(value);

is.class(value);

is.typedArray(value);

is.arrayLike(value);

is.arrayLike(document.forms);
// true

function foo() {
  is.arrayLike(arguments);
  // true
}
foo();

is.inRange(value, range);

is.inRange(3, [0, 5]);
is.inRange(3, [5, 0]);
is.inRange(0, [-2, 2]);

is.inRange(value, upperBound);

is.inRange(3, 10);

is.domElement(value);

is.nodeStream(value);

import fs from "node:fs";
is.nodeStream(fs.createReadStream("unicorn.png"));
// true

is.observable(value);

import { Observable } from "rxjs";
is.observable(new Observable());
// true

is.infinite(value);

is.evenInteger(value);

is.oddInteger(value);

is.propertyKey(value);

is.formData(value);

const data = new FormData();
is.formData(data);
// true

is.urlSearchParams(value);

const searchParams = new URLSearchParams();
is.urlSearchParams(searchParams);
// true

is.any(predicate | predicate[], ...values)

is.any(is.string, {}, true, "🦕");
// true
is.any(is.boolean, "denosaurs", [], new Map());
// false

is.any([is.string, is.number], {}, true, "🦕");
// true
is.any([is.boolean, is.number], "denosaurs", [], new Map());
// false

is.all(predicate, ...values);

is.all(is.object, {}, new Map(), new Set());
// true
is.all(is.string, "🦕", [], "denosaurs");
// false

import is from "https://deno.land/x/dis@0.2.0/mod.ts";
const padLeft = (value: string, padding: string | number) => {
  if (is.number(padding)) {
    // `padding` is typed as `number`
    return Array(padding + 1).join(" ") + value;
  }

  if (is.string(padding)) {
    // `padding` is typed as `string`
    return padding + value;
  }

  throw new TypeError(
    `Expected 'padding' to be of type 'string' or 'number', got '${
      is(padding)
    }'.`,
  );
};
padLeft("🦕", 3);
// '   🦕'

padLeft("🦕", "🌈");
// '🌈🦕'

import { assert } from "https://deno.land/x/dis@0.2.0/mod.ts";

const handleMovieRatingApiResponse = (response: unknown) => {
  assert.plainObject(response);
  // `response` is now typed as a plain `object` with `unknown` properties.

  assert.number(response.rating);
  // `response.rating` is now typed as a `number`.

  assert.string(response.title);
  // `response.title` is now typed as a `string`.

  return `${response.title} (${response.rating * 10})`;
};
handleMovieRatingApiResponse({ rating: 0.87, title: "The Matrix" });
// 'The Matrix (8.7)'

// This throws an error.
handleMovieRatingApiResponse({ rating: "🦕" });

import { assert } from "https://deno.land/x/dis@0.2.0/mod.ts";
async function badNumberAssumption(input: unknown) {
  // Bad assumption about the generic type parameter fools the compile-time type system.
  assert.promise<number>(input);
  // `input` is a `Promise` but only assumed to be `Promise<number>`.
  const resolved = await input;
  // `resolved` is typed as `number` but was not actually checked at runtime.
  // Multiplication will return NaN if the input promise did not actually contain a number.
  return 2 * resolved;
}
async function goodNumberAssertion(input: unknown) {
  assert.promise(input);
  // `input` is typed as `Promise<unknown>`
  const resolved = await input;
  // `resolved` is typed as `unknown`
  assert.number(resolved);
  // `resolved` is typed as `number`
  // Uses runtime checks so only numbers will reach the multiplication.
  return 2 * resolved;
}
badNumberAssumption(Promise.resolve("An unexpected string"));
// NaN
// This correctly throws an error because of the unexpected string value.
goodNumberAssertion(Promise.resolve("An unexpected string"));