@tool-belt/type-predicates/dist/index.mjs

A comprehensive collection of performant type guards and assertions with excellent TypeScript support

const o = (r) => Object.prototype.toString.call(r);
function t(r, e) {
  return e ? (n) => r(n, e) : (n) => r(n);
}
function u(...r) {
  return function(e) {
    for (const n of r)
      if (n(e))
        return !0;
    return !1;
  };
}
const s = t(
  (r) => typeof r == "object" && r !== null
), m = t(
  (r) => s(r) && (o(r) === "[object ArrayBuffer]" || r instanceof ArrayBuffer)
), p = t(
  (r) => s(r) && (o(r) === "[object SharedArrayBuffer]" || r instanceof SharedArrayBuffer)
), l = u(
  m,
  p
);
function lr(r, e) {
  if (!l(r))
    throw new TypeError(e?.message);
}
const S = t(
  (r) => typeof r == "object" && r !== null && Object.prototype.toString.call(r) === "[object Arguments]"
);
function Sr(r, e) {
  if (!S(r))
    throw new TypeError(e?.message);
}
function dr(r, e) {
  if (!Array.isArray(r))
    throw new TypeError(e?.message);
  if (e?.valueValidator && !r.every(e.valueValidator))
    throw new TypeError(e.message);
}
function Or(r, e) {
  if (!m(r))
    throw new TypeError(e?.message);
}
const i = t(
  (r) => r instanceof Object.getPrototypeOf(Int8Array) || r instanceof Object.getPrototypeOf(Uint8Array)
), d = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Int8Array"
)(r), O = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Uint8Array"
)(r), B = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Uint8ClampedArray"
)(r), N = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Int16Array"
)(r), V = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Uint16Array"
)(r), k = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Int32Array"
)(r), F = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Uint32Array"
)(r), U = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Float32Array"
)(r), G = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "Float64Array"
)(r), P = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "BigInt64Array"
)(r), R = (r) => t(
  (e) => i(e) && e[Symbol.toStringTag] === "BigUint64Array"
)(r), b = t(
  (r) => s(r) && (o(r) === "[object DataView]" || r instanceof DataView)
), M = t(
  (r) => i(r) || b(r)
);
function Br(r, e) {
  if (!M(r))
    throw new TypeError(e?.message);
}
function D(r) {
  return t(
    (e) => typeof e == "function" && o(e) === "[object AsyncFunction]"
  )(r);
}
function Nr(r, e) {
  if (!D(r))
    throw new TypeError(e?.message);
}
function x(r) {
  return t(
    (e) => s(e) && o(e) === "[object AsyncGenerator]"
  )(r);
}
function Vr(r, e) {
  if (!x(r))
    throw new TypeError(e?.message);
}
function W(r) {
  return t(
    (e) => typeof e == "function" && o(e) === "[object AsyncGeneratorFunction]"
  )(r);
}
function kr(r, e) {
  if (!W(r))
    throw new TypeError(e?.message);
}
function C(r) {
  return t(
    (e) => s(e) && typeof Reflect.get(e, Symbol.asyncIterator) == "function"
  )(r);
}
function Fr(r, e) {
  if (!C(r))
    throw new TypeError(e?.message);
}
const q = t(
  (r) => typeof r == "bigint"
);
function Ur(r, e) {
  if (!q(r))
    throw new TypeError(e?.message);
}
const I = t(
  (r) => typeof r == "object" && r !== null && Object.prototype.toString.call(r) === "[object BigInt]"
);
function Gr(r, e) {
  if (!I(r))
    throw new TypeError(e?.message);
}
const z = t(
  (r) => typeof r == "boolean"
);
function Pr(r, e) {
  if (!z(r))
    throw new TypeError(e?.message);
}
const E = t(
  (r) => s(r) && o(r) === "[object Boolean]" && typeof r.valueOf() == "boolean"
);
function Rr(r, e) {
  if (!E(r))
    throw new TypeError(e?.message);
}
const h = t(
  (r) => s(r) && o(r) === "[object Number]" && typeof r.valueOf() == "number"
), T = t(
  (r) => s(r) && o(r) === "[object String]" && typeof r.valueOf() == "string"
), A = t(
  (r) => typeof r == "object" && r !== null && Object.prototype.toString.call(r) === "[object Symbol]"
), H = t(
  (r) => E(r) || h(r) || T(r) || I(r) || A(r)
);
function Mr(r, e) {
  if (!H(r))
    throw new TypeError(e?.message);
}
const J = t(
  (r) => typeof Buffer < "u" && r instanceof Buffer
);
function Dr(r, e) {
  if (!J(r))
    throw new TypeError(e?.message);
}
function xr(r, e) {
  if (!b(r))
    throw new TypeError(e?.message);
}
const K = t(
  (r) => s(r) && (o(r) === "[object Date]" || r instanceof Date)
);
function Wr(r, e) {
  if (!K(r))
    throw new TypeError(e?.message);
}
const c = t(
  (r) => r === void 0
);
function Cr(r, e) {
  if (c(r))
    throw new TypeError(e?.message);
}
function j(r, e) {
  return t(
    (n) => Array.isArray(n) && (!e?.valueValidator || n.every(e.valueValidator))
  )(r);
}
const L = t(
  (r) => j(r) && r.length === 0
);
function qr(r, e) {
  if (!L(r))
    throw new TypeError(e?.message);
}
const Q = t(
  (r) => s(r) && !Array.isArray(r) && Object.keys(r).length === 0
);
function zr(r, e) {
  if (!Q(r))
    throw new TypeError(e?.message);
}
const y = t(
  (r) => typeof r == "string"
), X = t(
  (r) => y(r) && r.length === 0
);
function Hr(r, e) {
  if (!X(r))
    throw new TypeError(e?.message);
}
function Y(r) {
  return t(
    (e) => s(e) && (o(e) === "[object Error]" || e instanceof Error)
  )(r);
}
function Jr(r, e) {
  if (!Y(r))
    throw new TypeError(e?.message);
}
const Z = t(
  (r) => typeof r == "number" && Number.isFinite(r)
);
function Kr(r, e) {
  if (!Z(r))
    throw new TypeError(e?.message);
}
function _(r) {
  return t(
    (e) => typeof e == "function" && o(e) === "[object Function]"
  )(r);
}
function Lr(r, e) {
  if (!_(r))
    throw new TypeError(e?.message);
}
function $(r) {
  return t(
    (e) => s(e) && o(e) === "[object Generator]"
  )(r);
}
function Qr(r, e) {
  if (!$(r))
    throw new TypeError(e?.message);
}
function v(r) {
  return t(
    (e) => typeof e == "function" && o(e) === "[object GeneratorFunction]"
  )(r);
}
function Xr(r, e) {
  if (!v(r))
    throw new TypeError(e?.message);
}
const rr = t(
  (r) => typeof r == "number" && Number.isInteger(r)
);
function Yr(r, e) {
  if (!rr(r))
    throw new TypeError(e?.message);
}
function er(r) {
  return t(
    (e) => s(e) && typeof Reflect.get(e, Symbol.iterator) == "function" || y(e)
  )(r);
}
function Zr(r, e) {
  if (!er(r))
    throw new TypeError(e?.message);
}
function tr(r) {
  return t(
    (e) => s(e) && typeof Reflect.get(e, "next") == "function"
  )(r);
}
function _r(r, e) {
  if (!tr(r))
    throw new TypeError(e?.message);
}
function nr(r, e) {
  return t((n) => {
    if (!(n instanceof Map) && (!s(n) || o(n) !== "[object Map]"))
      return !1;
    const f = n;
    if (e?.valueValidator) {
      for (const a of f.values())
        if (!e.valueValidator(a))
          return !1;
    }
    if (e?.keyValidator) {
      for (const a of f.keys())
        if (!e.keyValidator(a))
          return !1;
    }
    return !0;
  })(r);
}
function $r(r, e) {
  if (!nr(r))
    throw new TypeError(e?.message);
  if (e?.keyValidator && ![...r.keys()].every(e.keyValidator))
    throw new TypeError(e.message);
  if (e?.valueValidator && ![...r.values()].every(e.valueValidator))
    throw new TypeError(e.message);
}
const sr = t(
  (r) => typeof r == "object" && r !== null && Object.prototype.toString.call(r) === "[object Map Iterator]"
);
function vr(r, e) {
  if (!sr(r))
    throw new TypeError(e?.message);
}
const or = t(
  (r) => typeof r == "number" && Number.isNaN(r)
);
function re(r, e) {
  if (!or(r))
    throw new TypeError(e?.message);
}
const ir = t(
  (r) => r instanceof Error || r instanceof EvalError || r instanceof RangeError || r instanceof ReferenceError || r instanceof SyntaxError || r instanceof TypeError || r instanceof URIError || typeof AggregateError < "u" && r instanceof AggregateError
);
function ee(r, e) {
  if (!ir(r))
    throw new TypeError(e?.message);
}
const ar = t(
  (r) => j(r) && r.length > 0
);
function te(r, e) {
  if (!ar(r))
    throw new TypeError(e?.message);
}
const fr = t(
  (r) => y(r) && r.length > 0
);
function ne(r, e) {
  if (!fr(r))
    throw new TypeError(e?.message);
}
const g = t((r) => r === null);
function se(r, e) {
  if (g(r))
    throw new TypeError(e?.message);
}
function oe(r, e) {
  if (c(r) || g(r))
    throw new TypeError(e?.message);
}
function ie(r, e) {
  if (!g(r))
    throw new TypeError(e?.message);
}
const cr = u(g, c);
function ae(r, e) {
  if (!cr(r))
    throw new TypeError(e?.message);
}
const yr = t(
  (r) => typeof r == "number"
);
function fe(r, e) {
  if (!yr(r))
    throw new TypeError(e?.message);
}
function ce(r, e) {
  if (!h(r))
    throw new TypeError(e?.message);
}
function ye(r, e) {
  if (!s(r))
    throw new TypeError(e?.message);
}
function w(r) {
  try {
    return Object.getPrototypeOf(r);
  } catch {
    return null;
  }
}
const gr = t(
  (r) => {
    if (r === null || typeof r != "object")
      return !1;
    const e = w(r);
    return e === null || e === Object.prototype ? !0 : w(e) === null;
  }
);
function ge(r, e) {
  if (!gr(r))
    throw new TypeError(e?.message);
}
function wr(r) {
  return t(
    (e) => e instanceof Promise || s(e) && typeof Reflect.get(e, "then") == "function"
  )(r);
}
function we(r, e) {
  if (!wr(r))
    throw new TypeError(e?.message);
}
function ur(r, e) {
  return t(
    (n) => s(n) && o(n) === "[object Object]" && (!e?.valueValidator || Object.values(n).every(e.valueValidator)) && (!e?.keyValidator || Object.keys(n).every(e.keyValidator))
  )(r);
}
function ue(r, e) {
  if (!ur(r))
    throw new TypeError(e?.message);
  if (e?.keyValidator && !Object.keys(r).every(e.keyValidator))
    throw new TypeError(e.message);
  if (e?.valueValidator && !Object.values(r).every(e.valueValidator))
    throw new TypeError(e.message);
}
const mr = t(
  (r) => s(r) && (o(r) === "[object RegExp]" || r instanceof RegExp)
);
function me(r, e) {
  if (!mr(r))
    throw new TypeError(e?.message);
}
const pr = t(
  (r) => typeof r == "number" && Number.isSafeInteger(r)
);
function pe(r, e) {
  if (!pr(r))
    throw new TypeError(e?.message);
}
function br(r, e) {
  return t((n) => {
    if (!s(n) || o(n) !== "[object Set]" && !(n instanceof Set))
      return !1;
    const f = n;
    if (e?.valueValidator) {
      for (const a of f)
        if (!e.valueValidator(a))
          return !1;
    }
    return !0;
  })(r);
}
function be(r, e) {
  if (!br(r))
    throw new TypeError(e?.message);
  if (e?.valueValidator && ![...r].every(e.valueValidator))
    throw new TypeError(e.message);
}
const Ir = t(
  (r) => typeof r == "object" && r !== null && Object.prototype.toString.call(r) === "[object Set Iterator]"
);
function Ie(r, e) {
  if (!Ir(r))
    throw new TypeError(e?.message);
}
function Ee(r, e) {
  if (!p(r))
    throw new TypeError(e?.message);
}
function he(r, e) {
  if (!y(r))
    throw new TypeError(e?.message);
}
function Te(r, e) {
  if (!T(r))
    throw new TypeError(e?.message);
}
const Er = t(
  (r) => typeof r == "symbol"
);
function Ae(r, e) {
  if (!Er(r))
    throw new TypeError(e?.message);
}
function je(r, e) {
  if (!A(r))
    throw new TypeError(e?.message);
}
function le(r, e) {
  if (!P(r))
    throw new TypeError(e?.message);
}
function Se(r, e) {
  if (!R(r))
    throw new TypeError(e?.message);
}
function de(r, e) {
  if (!U(r))
    throw new TypeError(e?.message);
}
function Oe(r, e) {
  if (!G(r))
    throw new TypeError(e?.message);
}
function Be(r, e) {
  if (!N(r))
    throw new TypeError(e?.message);
}
function Ne(r, e) {
  if (!k(r))
    throw new TypeError(e?.message);
}
function Ve(r, e) {
  if (!d(r))
    throw new TypeError(e?.message);
}
function ke(r, e) {
  if (!i(r))
    throw new TypeError(e?.message);
}
function Fe(r, e) {
  if (!V(r))
    throw new TypeError(e?.message);
}
function Ue(r, e) {
  if (!F(r))
    throw new TypeError(e?.message);
}
function Ge(r, e) {
  if (!O(r))
    throw new TypeError(e?.message);
}
function Pe(r, e) {
  if (!B(r))
    throw new TypeError(e?.message);
}
function Re(r, e) {
  if (!c(r))
    throw new TypeError(e?.message);
}
function hr(r) {
  return t(
    (e) => e instanceof WeakMap || s(e) && o(e) === "[object WeakMap]"
  )(r);
}
function Me(r, e) {
  if (!hr(r))
    throw new TypeError(e?.message);
}
function Tr(r) {
  return t(
    (e) => e instanceof WeakSet || s(e) && o(e) === "[object WeakSet]"
  )(r);
}
function De(r, e) {
  if (!Tr(r))
    throw new TypeError(e?.message);
}
function Ar(r) {
  return r !== void 0;
}
function jr(r) {
  return r !== null;
}
function xe(r) {
  return Ar(r) && jr(r);
}
export {
  lr as assertIsAnyArrayBuffer,
  Sr as assertIsArgumentsObject,
  dr as assertIsArray,
  Or as assertIsArrayBuffer,
  Br as assertIsArrayBufferView,
  Nr as assertIsAsyncFunction,
  Vr as assertIsAsyncGenerator,
  kr as assertIsAsyncGeneratorFunction,
  Fr as assertIsAsyncIterable,
  Ur as assertIsBigInt,
  le as assertIsBigInt64Array,
  Gr as assertIsBigIntObject,
  Se as assertIsBigUint64Array,
  Pr as assertIsBoolean,
  Rr as assertIsBooleanObject,
  Mr as assertIsBoxedPrimitive,
  Dr as assertIsBuffer,
  xr as assertIsDataView,
  Wr as assertIsDate,
  Cr as assertIsDefined,
  qr as assertIsEmptyArray,
  zr as assertIsEmptyObject,
  Hr as assertIsEmptyString,
  Jr as assertIsError,
  Kr as assertIsFinite,
  de as assertIsFloat32Array,
  Oe as assertIsFloat64Array,
  Lr as assertIsFunction,
  Qr as assertIsGenerator,
  Xr as assertIsGeneratorFunction,
  Be as assertIsInt16Array,
  Ne as assertIsInt32Array,
  Ve as assertIsInt8Array,
  Yr as assertIsInteger,
  Zr as assertIsIterable,
  _r as assertIsIterator,
  $r as assertIsMap,
  vr as assertIsMapIterator,
  re as assertIsNaN,
  ee as assertIsNativeError,
  te as assertIsNonEmptyArray,
  ne as assertIsNonEmptyString,
  se as assertIsNotNull,
  oe as assertIsNotNullish,
  ie as assertIsNull,
  ae as assertIsNullish,
  fe as assertIsNumber,
  ce as assertIsNumberObject,
  ye as assertIsObject,
  ge as assertIsPlainObject,
  we as assertIsPromise,
  ue as assertIsRecord,
  me as assertIsRegExp,
  pe as assertIsSafeInteger,
  be as assertIsSet,
  Ie as assertIsSetIterator,
  Ee as assertIsSharedArrayBuffer,
  he as assertIsString,
  Te as assertIsStringObject,
  Ae as assertIsSymbol,
  je as assertIsSymbolObject,
  ke as assertIsTypedArray,
  Fe as assertIsUint16Array,
  Ue as assertIsUint32Array,
  Ge as assertIsUint8Array,
  Pe as assertIsUint8ClampedArray,
  Re as assertIsUndefined,
  Me as assertIsWeakMap,
  De as assertIsWeakSet,
  t as createTypeGuard,
  l as isAnyArrayBuffer,
  S as isArgumentsObject,
  j as isArray,
  m as isArrayBuffer,
  M as isArrayBufferView,
  D as isAsyncFunction,
  x as isAsyncGenerator,
  W as isAsyncGeneratorFunction,
  C as isAsyncIterable,
  q as isBigInt,
  P as isBigInt64Array,
  I as isBigIntObject,
  R as isBigUint64Array,
  z as isBoolean,
  E as isBooleanObject,
  H as isBoxedPrimitive,
  J as isBuffer,
  b as isDataView,
  K as isDate,
  Ar as isDefined,
  L as isEmptyArray,
  Q as isEmptyObject,
  X as isEmptyString,
  Y as isError,
  Z as isFinite,
  U as isFloat32Array,
  G as isFloat64Array,
  _ as isFunction,
  $ as isGenerator,
  v as isGeneratorFunction,
  N as isInt16Array,
  k as isInt32Array,
  d as isInt8Array,
  rr as isInteger,
  er as isIterable,
  tr as isIterator,
  nr as isMap,
  sr as isMapIterator,
  or as isNaN,
  ir as isNativeError,
  ar as isNonEmptyArray,
  fr as isNonEmptyString,
  jr as isNotNull,
  xe as isNotNullish,
  g as isNull,
  cr as isNullish,
  yr as isNumber,
  h as isNumberObject,
  s as isObject,
  gr as isPlainObject,
  wr as isPromise,
  ur as isRecord,
  mr as isRegExp,
  pr as isSafeInteger,
  br as isSet,
  Ir as isSetIterator,
  p as isSharedArrayBuffer,
  y as isString,
  T as isStringObject,
  Er as isSymbol,
  A as isSymbolObject,
  i as isTypedArray,
  V as isUint16Array,
  F as isUint32Array,
  O as isUint8Array,
  B as isUint8ClampedArray,
  c as isUndefined,
  u as isUnion,
  hr as isWeakMap,
  Tr as isWeakSet
};
//# sourceMappingURL=index.mjs.map