@ls-stack/utils 3.42.0 → 3.44.0

package/dist/matchPath.d.cts

@@ -0,0 +1,53 @@
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?` ? Optional : Param : never;
+type PathParam<Path extends string> = Path extends '*' | '/*' ? '*' : Path extends `${infer Rest}/*` ? '*' | _PathParam<Rest> : _PathParam<Path>;
+type ParamParseKey<Segment extends string> = [
+    PathParam<Segment>
+] extends [never] ? string : PathParam<Segment>;
+/** A PathPattern is used to match on some portion of a URL pathname. */
+interface PathPattern<Path extends string = string> {
+    /**
+     * A string to match against a URL pathname. May contain `:id`-style segments
+     * to indicate placeholders for dynamic parameters. May also end with `/*` to
+     * indicate matching the rest of the URL pathname.
+     */
+    path: Path;
+    /**
+     * Should be `true` if the static portions of the `path` should be matched in
+     * the same case.
+     */
+    caseSensitive?: boolean;
+    /** Should be `true` if this pattern should match the entire URL pathname. */
+    end?: boolean;
+}
+/** The parameters that were parsed from the URL path. */
+type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+type PathMatchGlob = {
+    matchPath: <K extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path) => PathMatch<K> | null;
+    path: string;
+};
+/** A PathMatch contains info about how a PathPattern matched on a URL pathname. */
+interface PathMatch<ParamKey extends string = string> {
+    /** The names and values of dynamic parameters in the URL. */
+    params: Params<ParamKey>;
+    /** The portion of the URL pathname that was matched. */
+    pathname: string;
+    /** The portion of the URL pathname that was matched before child routes. */
+    pathnameBase: string;
+    /** The pattern that was used to match. */
+    pattern: PathPattern;
+    glob: null | PathMatchGlob;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about the
+ * match.
+ *
+ * @see https://reactrouter.com/utils/match-path
+ */
+declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+declare function matchPathWith(path: string | undefined | null): {
+    patterns: <R>(patterns: Record<string, (match: PathMatch) => R>) => R | null;
+};
+
+export { type ParamParseKey, type Params, type PathMatch, type PathMatchGlob, type PathParam, type PathPattern, matchPath, matchPathWith };

package/dist/matchPath.d.ts

@@ -0,0 +1,53 @@
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?` ? Optional : Param : never;
+type PathParam<Path extends string> = Path extends '*' | '/*' ? '*' : Path extends `${infer Rest}/*` ? '*' | _PathParam<Rest> : _PathParam<Path>;
+type ParamParseKey<Segment extends string> = [
+    PathParam<Segment>
+] extends [never] ? string : PathParam<Segment>;
+/** A PathPattern is used to match on some portion of a URL pathname. */
+interface PathPattern<Path extends string = string> {
+    /**
+     * A string to match against a URL pathname. May contain `:id`-style segments
+     * to indicate placeholders for dynamic parameters. May also end with `/*` to
+     * indicate matching the rest of the URL pathname.
+     */
+    path: Path;
+    /**
+     * Should be `true` if the static portions of the `path` should be matched in
+     * the same case.
+     */
+    caseSensitive?: boolean;
+    /** Should be `true` if this pattern should match the entire URL pathname. */
+    end?: boolean;
+}
+/** The parameters that were parsed from the URL path. */
+type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+type PathMatchGlob = {
+    matchPath: <K extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path) => PathMatch<K> | null;
+    path: string;
+};
+/** A PathMatch contains info about how a PathPattern matched on a URL pathname. */
+interface PathMatch<ParamKey extends string = string> {
+    /** The names and values of dynamic parameters in the URL. */
+    params: Params<ParamKey>;
+    /** The portion of the URL pathname that was matched. */
+    pathname: string;
+    /** The portion of the URL pathname that was matched before child routes. */
+    pathnameBase: string;
+    /** The pattern that was used to match. */
+    pattern: PathPattern;
+    glob: null | PathMatchGlob;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about the
+ * match.
+ *
+ * @see https://reactrouter.com/utils/match-path
+ */
+declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+declare function matchPathWith(path: string | undefined | null): {
+    patterns: <R>(patterns: Record<string, (match: PathMatch) => R>) => R | null;
+};
+
+export { type ParamParseKey, type Params, type PathMatch, type PathMatchGlob, type PathParam, type PathPattern, matchPath, matchPathWith };

package/dist/matchPath.js

@@ -0,0 +1,107 @@
+import {
+  fastCache
+} from "./chunk-OIAGLRII.js";
+import "./chunk-5MNYPLZI.js";
+import "./chunk-HTCYUMDR.js";
+import "./chunk-II4R3VVX.js";
+import "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
+
+// src/matchPath.ts
+function matchPath(pattern, pathname) {
+  if (typeof pattern === "string") {
+    pattern = { path: pattern, caseSensitive: false, end: true };
+  }
+  const [matcher, compiledParams] = compilePath(
+    pattern.path,
+    pattern.caseSensitive,
+    pattern.end
+  );
+  const match = pathname.match(matcher);
+  if (!match) return null;
+  const matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+  const captureGroups = match.slice(1);
+  const params = compiledParams.reduce(
+    (memo, { paramName, isOptional }, index) => {
+      if (paramName === "*") {
+        const splatValue = captureGroups[index] || "";
+        pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+      }
+      const value = captureGroups[index];
+      if (isOptional && !value) {
+        memo[paramName] = void 0;
+      } else {
+        memo[paramName] = (value || "").replace(/%2F/g, "/");
+      }
+      return memo;
+    },
+    {}
+  );
+  const glob = params["*"];
+  const globPath = glob && `/${glob}`;
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern,
+    glob: globPath ? {
+      matchPath: (subPattern) => matchPath(subPattern, globPath),
+      path: globPath
+    } : null
+  };
+}
+function warning(condition, message) {
+  if (process.env.NODE_ENV === "development" && !condition) {
+    console.warn(message);
+  }
+}
+var cache = fastCache({ maxCacheSize: 5e3 });
+function compilePath(path, caseSensitive = false, end = true) {
+  return cache.getOrInsert(
+    `${path}-${caseSensitive ? "s" : "i"}${end ? "e" : ""}`,
+    () => {
+      warning(
+        path === "*" || !path.endsWith("*") || path.endsWith("/*"),
+        `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`
+      );
+      const params = [];
+      let regexpSource = `^${path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
+        /\/:([\w-]+)(\?)?/g,
+        (_, paramName, isOptional) => {
+          params.push({ paramName, isOptional: isOptional != null });
+          return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+        }
+      )}`;
+      if (path.endsWith("*")) {
+        params.push({ paramName: "*" });
+        regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+      } else if (end) {
+        regexpSource += "\\/*$";
+      } else if (path !== "" && path !== "/") {
+        regexpSource += "(?:(?=\\/|$))";
+      } else {
+      }
+      const matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
+      return [matcher, params];
+    }
+  );
+}
+function matchPathWith(path) {
+  return {
+    patterns: (patternsToMatch) => {
+      if (!path) return null;
+      for (const [key, pattern] of Object.entries(patternsToMatch)) {
+        const match = matchPath(key, path);
+        if (match) {
+          return pattern(match);
+        }
+      }
+      return null;
+    }
+  };
+}
+export {
+  matchPath,
+  matchPathWith
+};

package/dist/partialEqual.cjs

@@ -0,0 +1,289 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/partialEqual.ts
+var partialEqual_exports = {};
+__export(partialEqual_exports, {
+  match: () => match,
+  partialEqual: () => partialEqual
+});
+module.exports = __toCommonJS(partialEqual_exports);
+
+// src/deepEqual.ts
+var has = Object.prototype.hasOwnProperty;
+function find(iter, tar, maxDepth) {
+  for (const key of iter.keys()) {
+    if (deepEqual(key, tar, maxDepth)) return key;
+  }
+}
+function deepEqual(foo, bar, maxDepth = 20) {
+  let ctor, len, tmp;
+  if (foo === bar) return true;
+  if (maxDepth && maxDepth <= 0) return false;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date)
+      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
+      }
+      return len === -1;
+    }
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp, maxDepth - 1);
+          if (!tmp) return false;
+        }
+        if (!bar.has(tmp)) return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === "object") {
+          tmp = find(bar, tmp, maxDepth - 1);
+          if (!tmp) return false;
+        }
+        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof foo === "object") {
+      len = 0;
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
+          return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+  return foo !== foo && bar !== bar;
+}
+
+// src/partialEqual.ts
+var has2 = Object.prototype.hasOwnProperty;
+var Comparisons = class {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var match = {
+  hasType: {
+    string: new Comparisons(["hasType", "string"]),
+    number: new Comparisons(["hasType", "number"]),
+    boolean: new Comparisons(["hasType", "boolean"]),
+    object: new Comparisons(["hasType", "object"]),
+    array: new Comparisons(["hasType", "array"]),
+    function: new Comparisons(["hasType", "function"])
+  },
+  isInstanceOf: (constructor) => new Comparisons(["isInstanceOf", constructor]),
+  str: {
+    contains: (substring) => new Comparisons(["strContains", substring]),
+    startsWith: (substring) => new Comparisons(["strStartsWith", substring]),
+    endsWith: (substring) => new Comparisons(["strEndsWith", substring]),
+    matchesRegex: (regex) => new Comparisons(["strMatchesRegex", regex])
+  },
+  num: {
+    isGreaterThan: (value) => new Comparisons(["numIsGreaterThan", value]),
+    isGreaterThanOrEqual: (value) => new Comparisons(["numIsGreaterThanOrEqual", value]),
+    isLessThan: (value) => new Comparisons(["numIsLessThan", value]),
+    isLessThanOrEqual: (value) => new Comparisons(["numIsLessThanOrEqual", value]),
+    isInRange: (value) => new Comparisons(["numIsInRange", value])
+  },
+  jsonString: {
+    hasPartial: (value) => new Comparisons(["jsonStringHasPartial", value])
+  },
+  equal: (value) => new Comparisons(["deepEqual", value]),
+  partialEqual: (value) => new Comparisons(["partialEqual", value]),
+  custom: (isEqual) => new Comparisons(["custom", isEqual]),
+  not: {
+    hasType: {
+      string: new Comparisons(["not", ["hasType", "string"]]),
+      number: new Comparisons(["not", ["hasType", "number"]]),
+      boolean: new Comparisons(["not", ["hasType", "boolean"]]),
+      object: new Comparisons(["not", ["hasType", "object"]]),
+      array: new Comparisons(["not", ["hasType", "array"]]),
+      function: new Comparisons(["not", ["hasType", "function"]])
+    },
+    isInstanceOf: (constructor) => new Comparisons(["not", ["isInstanceOf", constructor]]),
+    str: {
+      contains: (substring) => new Comparisons(["not", ["strContains", substring]]),
+      startsWith: (substring) => new Comparisons(["not", ["strStartsWith", substring]]),
+      endsWith: (substring) => new Comparisons(["not", ["strEndsWith", substring]]),
+      matchesRegex: (regex) => new Comparisons(["not", ["strMatchesRegex", regex]])
+    },
+    num: {
+      isGreaterThan: (value) => new Comparisons(["not", ["numIsGreaterThan", value]]),
+      isGreaterThanOrEqual: (value) => new Comparisons(["not", ["numIsGreaterThanOrEqual", value]]),
+      isLessThan: (value) => new Comparisons(["not", ["numIsLessThan", value]]),
+      isLessThanOrEqual: (value) => new Comparisons(["not", ["numIsLessThanOrEqual", value]]),
+      isInRange: (value) => new Comparisons(["not", ["numIsInRange", value]])
+    },
+    jsonString: {
+      hasPartial: (value) => new Comparisons(["not", ["jsonStringHasPartial", value]])
+    },
+    equal: (value) => new Comparisons(["not", ["deepEqual", value]]),
+    partialEqual: (value) => new Comparisons(["not", ["partialEqual", value]]),
+    custom: (value) => new Comparisons(["not", ["custom", value]])
+  }
+};
+function find2(iter, tar) {
+  for (const key of iter.keys()) {
+    if (partialEqual(key, tar)) return key;
+  }
+}
+function executeComparison(target, comparison) {
+  const [type, value] = comparison;
+  switch (type) {
+    case "hasType":
+      switch (value) {
+        case "string":
+          return typeof target === "string";
+        case "number":
+          return typeof target === "number";
+        case "boolean":
+          return typeof target === "boolean";
+        case "function":
+          return typeof target === "function";
+        case "array":
+          return Array.isArray(target);
+        case "object":
+          return typeof target === "object" && target !== null && !Array.isArray(target);
+        default:
+          return false;
+      }
+    case "isInstanceOf":
+      return target instanceof value;
+    case "strStartsWith":
+      return typeof target === "string" && target.startsWith(value);
+    case "strEndsWith":
+      return typeof target === "string" && target.endsWith(value);
+    case "strContains":
+      return typeof target === "string" && target.includes(value);
+    case "strMatchesRegex":
+      return typeof target === "string" && value.test(target);
+    case "numIsGreaterThan":
+      return typeof target === "number" && target > value;
+    case "numIsGreaterThanOrEqual":
+      return typeof target === "number" && target >= value;
+    case "numIsLessThan":
+      return typeof target === "number" && target < value;
+    case "numIsLessThanOrEqual":
+      return typeof target === "number" && target <= value;
+    case "numIsInRange":
+      return typeof target === "number" && target >= value[0] && target <= value[1];
+    case "jsonStringHasPartial":
+      if (typeof target !== "string") return false;
+      try {
+        const parsed = JSON.parse(target);
+        return partialEqual(parsed, value);
+      } catch {
+        return false;
+      }
+    case "deepEqual":
+      return deepEqual(target, value);
+    case "partialEqual":
+      return partialEqual(target, value);
+    case "custom":
+      return value(target);
+    case "not":
+      return !executeComparison(target, value);
+    default:
+      return false;
+  }
+}
+function partialEqual(target, sub) {
+  if (sub === target) return true;
+  if (sub instanceof Comparisons) {
+    return executeComparison(target, sub.type);
+  }
+  if (sub && target && sub.constructor === target.constructor) {
+    const ctor = sub.constructor;
+    if (ctor === Date) {
+      return sub.getTime() === target.getTime();
+    }
+    if (ctor === RegExp) {
+      return sub.toString() === target.toString();
+    }
+    if (ctor === Array) {
+      if (sub.length > target.length) return false;
+      for (let i = 0; i < sub.length; i++) {
+        if (!partialEqual(target[i], sub[i])) return false;
+      }
+      return true;
+    }
+    if (ctor === Set) {
+      if (sub.size > target.size) return false;
+      for (const value of sub) {
+        let found = false;
+        if (value && typeof value === "object") {
+          found = !!find2(target, value);
+        } else {
+          found = target.has(value);
+        }
+        if (!found) return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (sub.size > target.size) return false;
+      for (const [key, value] of sub) {
+        let targetKey = key;
+        if (key && typeof key === "object") {
+          targetKey = find2(target, key);
+          if (!targetKey) return false;
+        }
+        if (!target.has(targetKey) || !partialEqual(target.get(targetKey), value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof sub === "object") {
+      for (const key in sub) {
+        if (has2.call(sub, key)) {
+          if (!has2.call(target, key) || !partialEqual(target[key], sub[key])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  }
+  return sub !== sub && target !== target;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  match,
+  partialEqual
+});

package/dist/partialEqual.d.cts

@@ -0,0 +1,71 @@
+type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [
+    type: 'hasType',
+    value: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function'
+] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'not', value: ComparisonsType];
+declare class Comparisons {
+    type: ComparisonsType;
+    constructor(type: ComparisonsType);
+}
+declare const match: {
+    hasType: {
+        string: Comparisons;
+        number: Comparisons;
+        boolean: Comparisons;
+        object: Comparisons;
+        array: Comparisons;
+        function: Comparisons;
+    };
+    isInstanceOf: (constructor: new (...args: any[]) => any) => Comparisons;
+    str: {
+        contains: (substring: string) => Comparisons;
+        startsWith: (substring: string) => Comparisons;
+        endsWith: (substring: string) => Comparisons;
+        matchesRegex: (regex: RegExp) => Comparisons;
+    };
+    num: {
+        isGreaterThan: (value: number) => Comparisons;
+        isGreaterThanOrEqual: (value: number) => Comparisons;
+        isLessThan: (value: number) => Comparisons;
+        isLessThanOrEqual: (value: number) => Comparisons;
+        isInRange: (value: [number, number]) => Comparisons;
+    };
+    jsonString: {
+        hasPartial: (value: any) => Comparisons;
+    };
+    equal: (value: any) => Comparisons;
+    partialEqual: (value: any) => Comparisons;
+    custom: (isEqual: (value: unknown) => boolean) => Comparisons;
+    not: {
+        hasType: {
+            string: Comparisons;
+            number: Comparisons;
+            boolean: Comparisons;
+            object: Comparisons;
+            array: Comparisons;
+            function: Comparisons;
+        };
+        isInstanceOf: (constructor: new (...args: any[]) => any) => Comparisons;
+        str: {
+            contains: (substring: string) => Comparisons;
+            startsWith: (substring: string) => Comparisons;
+            endsWith: (substring: string) => Comparisons;
+            matchesRegex: (regex: RegExp) => Comparisons;
+        };
+        num: {
+            isGreaterThan: (value: number) => Comparisons;
+            isGreaterThanOrEqual: (value: number) => Comparisons;
+            isLessThan: (value: number) => Comparisons;
+            isLessThanOrEqual: (value: number) => Comparisons;
+            isInRange: (value: [number, number]) => Comparisons;
+        };
+        jsonString: {
+            hasPartial: (value: any) => Comparisons;
+        };
+        equal: (value: any) => Comparisons;
+        partialEqual: (value: any) => Comparisons;
+        custom: (value: (target: unknown) => boolean) => Comparisons;
+    };
+};
+declare function partialEqual(target: any, sub: any): boolean;
+
+export { match, partialEqual };

package/dist/partialEqual.d.ts

@@ -0,0 +1,71 @@
+type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [
+    type: 'hasType',
+    value: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function'
+] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'not', value: ComparisonsType];
+declare class Comparisons {
+    type: ComparisonsType;
+    constructor(type: ComparisonsType);
+}
+declare const match: {
+    hasType: {
+        string: Comparisons;
+        number: Comparisons;
+        boolean: Comparisons;
+        object: Comparisons;
+        array: Comparisons;
+        function: Comparisons;
+    };
+    isInstanceOf: (constructor: new (...args: any[]) => any) => Comparisons;
+    str: {
+        contains: (substring: string) => Comparisons;
+        startsWith: (substring: string) => Comparisons;
+        endsWith: (substring: string) => Comparisons;
+        matchesRegex: (regex: RegExp) => Comparisons;
+    };
+    num: {
+        isGreaterThan: (value: number) => Comparisons;
+        isGreaterThanOrEqual: (value: number) => Comparisons;
+        isLessThan: (value: number) => Comparisons;
+        isLessThanOrEqual: (value: number) => Comparisons;
+        isInRange: (value: [number, number]) => Comparisons;
+    };
+    jsonString: {
+        hasPartial: (value: any) => Comparisons;
+    };
+    equal: (value: any) => Comparisons;
+    partialEqual: (value: any) => Comparisons;
+    custom: (isEqual: (value: unknown) => boolean) => Comparisons;
+    not: {
+        hasType: {
+            string: Comparisons;
+            number: Comparisons;
+            boolean: Comparisons;
+            object: Comparisons;
+            array: Comparisons;
+            function: Comparisons;
+        };
+        isInstanceOf: (constructor: new (...args: any[]) => any) => Comparisons;
+        str: {
+            contains: (substring: string) => Comparisons;
+            startsWith: (substring: string) => Comparisons;
+            endsWith: (substring: string) => Comparisons;
+            matchesRegex: (regex: RegExp) => Comparisons;
+        };
+        num: {
+            isGreaterThan: (value: number) => Comparisons;
+            isGreaterThanOrEqual: (value: number) => Comparisons;
+            isLessThan: (value: number) => Comparisons;
+            isLessThanOrEqual: (value: number) => Comparisons;
+            isInRange: (value: [number, number]) => Comparisons;
+        };
+        jsonString: {
+            hasPartial: (value: any) => Comparisons;
+        };
+        equal: (value: any) => Comparisons;
+        partialEqual: (value: any) => Comparisons;
+        custom: (value: (target: unknown) => boolean) => Comparisons;
+    };
+};
+declare function partialEqual(target: any, sub: any): boolean;
+
+export { match, partialEqual };