@graphitation/supermassive 0.1.3 → 0.2.0

package/lib/jsutils/inspect.mjs

@@ -0,0 +1,82 @@
+const MAX_ARRAY_LENGTH = 10;
+const MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  const properties = entries.map(([key, value]) => key + ": " + formatValue(value, seenValues));
+  return "{ " + properties.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+  for (let i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items.push("... 1 more item");
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+  return "[" + items.join(", ") + "]";
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+export {
+  inspect
+};

package/lib/jsutils/instanceOf.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A replacement for instanceof which includes an error warning when multi-realm
+ * constructors are detected.
+ * See: https://expressjs.com/en/advanced/best-practice-performance.html#set-node_env-to-production
+ * See: https://webpack.js.org/guides/production/
+ */
+export declare const instanceOf: (value: unknown, constructor: Constructor) => boolean;
+interface Constructor extends Function {
+    prototype: {
+        [Symbol.toStringTag]: string;
+    };
+}
+export {};
+//# sourceMappingURL=instanceOf.d.ts.map

package/lib/jsutils/instanceOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instanceOf.d.ts","sourceRoot":"","sources":["../../src/jsutils/instanceOf.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,KAAK,OAsChE,CAAC;AAER,UAAU,WAAY,SAAQ,QAAQ;IACpC,SAAS,EAAE;QACT,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC;CACH"}

package/lib/jsutils/instanceOf.js

@@ -0,0 +1,55 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+__markAsModule(exports);
+__export(exports, {
+  instanceOf: () => instanceOf
+});
+var import_inspect = __toModule(require("./inspect"));
+const instanceOf = false ? function instanceOf2(value, constructor) {
+  return value instanceof constructor;
+} : function instanceOf3(value, constructor) {
+  var _a;
+  if (value instanceof constructor) {
+    return true;
+  }
+  if (typeof value === "object" && value !== null) {
+    const className = constructor.prototype[Symbol.toStringTag];
+    const valueClassName = Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_a = value.constructor) == null ? void 0 : _a.name;
+    if (className === valueClassName) {
+      const stringifiedValue = (0, import_inspect.inspect)(value);
+      throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+    }
+  }
+  return false;
+};

package/lib/jsutils/instanceOf.mjs

@@ -0,0 +1,32 @@
+import {inspect} from "./inspect";
+const instanceOf = false ? function instanceOf2(value, constructor) {
+  return value instanceof constructor;
+} : function instanceOf3(value, constructor) {
+  var _a;
+  if (value instanceof constructor) {
+    return true;
+  }
+  if (typeof value === "object" && value !== null) {
+    const className = constructor.prototype[Symbol.toStringTag];
+    const valueClassName = Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_a = value.constructor) == null ? void 0 : _a.name;
+    if (className === valueClassName) {
+      const stringifiedValue = inspect(value);
+      throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+    }
+  }
+  return false;
+};
+export {
+  instanceOf
+};

package/lib/jsutils/invariant.d.ts

@@ -0,0 +1,2 @@
+export declare function invariant(condition: unknown, message?: string): asserts condition;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/jsutils/invariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../src/jsutils/invariant.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CACvB,SAAS,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,CAQnB"}

package/lib/jsutils/invariant.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  invariant: () => invariant
+});
+function invariant(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : "Unexpected invariant triggered.");
+  }
+}

package/lib/jsutils/invariant.mjs

@@ -0,0 +1,9 @@
+function invariant(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : "Unexpected invariant triggered.");
+  }
+}
+export {
+  invariant
+};

package/lib/jsutils/isAsyncIterable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ */
+export declare function isAsyncIterable(maybeAsyncIterable: any): maybeAsyncIterable is AsyncIterable<unknown>;
+//# sourceMappingURL=isAsyncIterable.d.ts.map

package/lib/jsutils/isAsyncIterable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAsyncIterable.d.ts","sourceRoot":"","sources":["../../src/jsutils/isAsyncIterable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,kBAAkB,EAAE,GAAG,GACtB,kBAAkB,IAAI,aAAa,CAAC,OAAO,CAAC,CAE9C"}

package/lib/jsutils/isAsyncIterable.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  isAsyncIterable: () => isAsyncIterable
+});
+function isAsyncIterable(maybeAsyncIterable) {
+  return typeof (maybeAsyncIterable == null ? void 0 : maybeAsyncIterable[Symbol.asyncIterator]) === "function";
+}

package/lib/jsutils/isAsyncIterable.mjs

@@ -0,0 +1,6 @@
+function isAsyncIterable(maybeAsyncIterable) {
+  return typeof (maybeAsyncIterable == null ? void 0 : maybeAsyncIterable[Symbol.asyncIterator]) === "function";
+}
+export {
+  isAsyncIterable
+};

package/lib/jsutils/isIterableObject.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the provided object is an Object (i.e. not a string literal)
+ * and implements the Iterator protocol.
+ *
+ * This may be used in place of [Array.isArray()][isArray] to determine if
+ * an object should be iterated-over e.g. Array, Map, Set, Int8Array,
+ * TypedArray, etc. but excludes string literals.
+ *
+ * @example
+ *
+ * isIterableObject([ 1, 2, 3 ]) // true
+ * isIterableObject(new Map()) // true
+ * isIterableObject('ABC') // false
+ * isIterableObject({ key: 'value' }) // false
+ * isIterableObject({ length: 1, 0: 'Alpha' }) // false
+ */
+export declare function isIterableObject(maybeIterable: any): maybeIterable is Iterable<unknown>;
+//# sourceMappingURL=isIterableObject.d.ts.map

package/lib/jsutils/isIterableObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIterableObject.d.ts","sourceRoot":"","sources":["../../src/jsutils/isIterableObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,GAAG,GACjB,aAAa,IAAI,QAAQ,CAAC,OAAO,CAAC,CAKpC"}

package/lib/jsutils/isIterableObject.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  isIterableObject: () => isIterableObject
+});
+function isIterableObject(maybeIterable) {
+  return typeof maybeIterable === "object" && typeof (maybeIterable == null ? void 0 : maybeIterable[Symbol.iterator]) === "function";
+}

package/lib/jsutils/isIterableObject.mjs

@@ -0,0 +1,6 @@
+function isIterableObject(maybeIterable) {
+  return typeof maybeIterable === "object" && typeof (maybeIterable == null ? void 0 : maybeIterable[Symbol.iterator]) === "function";
+}
+export {
+  isIterableObject
+};

package/lib/jsutils/isObjectLike.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return true if `value` is object-like. A value is object-like if it's not
+ * `null` and has a `typeof` result of "object".
+ */
+export declare function isObjectLike(value: unknown): value is {
+    [key: string]: unknown;
+};
+//# sourceMappingURL=isObjectLike.d.ts.map

package/lib/jsutils/isObjectLike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObjectLike.d.ts","sourceRoot":"","sources":["../../src/jsutils/isObjectLike.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAErC"}

package/lib/jsutils/isObjectLike.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  isObjectLike: () => isObjectLike
+});
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}

package/lib/jsutils/isObjectLike.mjs

@@ -0,0 +1,6 @@
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}
+export {
+  isObjectLike
+};

package/lib/jsutils/isPromise.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the value acts like a Promise, i.e. has a "then" function,
+ * otherwise returns false.
+ */
+export declare function isPromise(value: any): value is Promise<unknown>;
+//# sourceMappingURL=isPromise.d.ts.map

package/lib/jsutils/isPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPromise.d.ts","sourceRoot":"","sources":["../../src/jsutils/isPromise.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAE/D"}

package/lib/jsutils/isPromise.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  isPromise: () => isPromise
+});
+function isPromise(value) {
+  return typeof (value == null ? void 0 : value.then) === "function";
+}

package/lib/jsutils/isPromise.mjs

@@ -0,0 +1,6 @@
+function isPromise(value) {
+  return typeof (value == null ? void 0 : value.then) === "function";
+}
+export {
+  isPromise
+};

package/lib/jsutils/keyMap.d.ts

@@ -0,0 +1,26 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * Creates a keyed JS object from an array, given a function to produce the keys
+ * for each value in the array.
+ *
+ * This provides a convenient lookup for the array items if the key function
+ * produces unique results.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: { name: 'Jon', num: '555-1234' },
+ *     //   Jenny: { name: 'Jenny', num: '867-5309' } }
+ *     const entriesByName = keyMap(
+ *       phoneBook,
+ *       entry => entry.name
+ *     )
+ *
+ *     // { name: 'Jenny', num: '857-6309' }
+ *     const jennyEntry = entriesByName['Jenny']
+ *
+ */
+export declare function keyMap<T>(list: ReadonlyArray<T>, keyFn: (item: T) => string): ObjMap<T>;
+//# sourceMappingURL=keyMap.d.ts.map

package/lib/jsutils/keyMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyMap.d.ts","sourceRoot":"","sources":["../../src/jsutils/keyMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GACzB,MAAM,CAAC,CAAC,CAAC,CAMX"}

package/lib/jsutils/keyMap.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  keyMap: () => keyMap
+});
+function keyMap(list, keyFn) {
+  const result = Object.create(null);
+  for (const item of list) {
+    result[keyFn(item)] = item;
+  }
+  return result;
+}

package/lib/jsutils/keyMap.mjs

@@ -0,0 +1,10 @@
+function keyMap(list, keyFn) {
+  const result = Object.create(null);
+  for (const item of list) {
+    result[keyFn(item)] = item;
+  }
+  return result;
+}
+export {
+  keyMap
+};

package/lib/jsutils/keyValMap.d.ts

@@ -0,0 +1,20 @@
+import type { ObjMap } from './ObjMap';
+/**
+ * Creates a keyed JS object from an array, given a function to produce the keys
+ * and a function to produce the values from each item in the array.
+ *
+ *     const phoneBook = [
+ *       { name: 'Jon', num: '555-1234' },
+ *       { name: 'Jenny', num: '867-5309' }
+ *     ]
+ *
+ *     // { Jon: '555-1234', Jenny: '867-5309' }
+ *     const phonesByName = keyValMap(
+ *       phoneBook,
+ *       entry => entry.name,
+ *       entry => entry.num
+ *     )
+ *
+ */
+export declare function keyValMap<T, V>(list: ReadonlyArray<T>, keyFn: (item: T) => string, valFn: (item: T) => V): ObjMap<V>;
+//# sourceMappingURL=keyValMap.d.ts.map

package/lib/jsutils/keyValMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyValMap.d.ts","sourceRoot":"","sources":["../../src/jsutils/keyValMap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC1B,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACpB,MAAM,CAAC,CAAC,CAAC,CAMX"}

package/lib/jsutils/keyValMap.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  keyValMap: () => keyValMap
+});
+function keyValMap(list, keyFn, valFn) {
+  const result = Object.create(null);
+  for (const item of list) {
+    result[keyFn(item)] = valFn(item);
+  }
+  return result;
+}

package/lib/jsutils/keyValMap.mjs

@@ -0,0 +1,10 @@
+function keyValMap(list, keyFn, valFn) {
+  const result = Object.create(null);
+  for (const item of list) {
+    result[keyFn(item)] = valFn(item);
+  }
+  return result;
+}
+export {
+  keyValMap
+};

package/lib/jsutils/mapValue.d.ts

@@ -0,0 +1,7 @@
+import type { ObjMap, ReadOnlyObjMap } from './ObjMap';
+/**
+ * Creates an object map with the same keys as `map` and values generated by
+ * running each value of `map` thru `fn`.
+ */
+export declare function mapValue<T, V>(map: ReadOnlyObjMap<T>, fn: (value: T, key: string) => V): ObjMap<V>;
+//# sourceMappingURL=mapValue.d.ts.map

package/lib/jsutils/mapValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapValue.d.ts","sourceRoot":"","sources":["../../src/jsutils/mapValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEvD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAC3B,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,EACtB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAC/B,MAAM,CAAC,CAAC,CAAC,CAOX"}

package/lib/jsutils/mapValue.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  mapValue: () => mapValue
+});
+function mapValue(map, fn) {
+  const result = Object.create(null);
+  for (const [key, value] of Object.entries(map)) {
+    result[key] = fn(value, key);
+  }
+  return result;
+}

package/lib/jsutils/mapValue.mjs

@@ -0,0 +1,10 @@
+function mapValue(map, fn) {
+  const result = Object.create(null);
+  for (const [key, value] of Object.entries(map)) {
+    result[key] = fn(value, key);
+  }
+  return result;
+}
+export {
+  mapValue
+};

package/lib/jsutils/memoize3.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Memoizes the provided three-argument function.
+ */
+export declare function memoize3<A1 extends object, A2 extends object, A3 extends object, R>(fn: (a1: A1, a2: A2, a3: A3) => R): (a1: A1, a2: A2, a3: A3) => R;
+//# sourceMappingURL=memoize3.d.ts.map

package/lib/jsutils/memoize3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize3.d.ts","sourceRoot":"","sources":["../../src/jsutils/memoize3.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,QAAQ,CACtB,EAAE,SAAS,MAAM,EACjB,EAAE,SAAS,MAAM,EACjB,EAAE,SAAS,MAAM,EACjB,CAAC,EACD,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,CAAC,CA4BlE"}

package/lib/jsutils/memoize3.js

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+__markAsModule(exports);
+__export(exports, {
+  memoize3: () => memoize3
+});
+function memoize3(fn) {
+  let cache0;
+  return function memoized(a1, a2, a3) {
+    if (cache0 === void 0) {
+      cache0 = new WeakMap();
+    }
+    let cache1 = cache0.get(a1);
+    if (cache1 === void 0) {
+      cache1 = new WeakMap();
+      cache0.set(a1, cache1);
+    }
+    let cache2 = cache1.get(a2);
+    if (cache2 === void 0) {
+      cache2 = new WeakMap();
+      cache1.set(a2, cache2);
+    }
+    let fnResult = cache2.get(a3);
+    if (fnResult === void 0) {
+      fnResult = fn(a1, a2, a3);
+      cache2.set(a3, fnResult);
+    }
+    return fnResult;
+  };
+}

package/lib/jsutils/memoize3.mjs

@@ -0,0 +1,27 @@
+function memoize3(fn) {
+  let cache0;
+  return function memoized(a1, a2, a3) {
+    if (cache0 === void 0) {
+      cache0 = new WeakMap();
+    }
+    let cache1 = cache0.get(a1);
+    if (cache1 === void 0) {
+      cache1 = new WeakMap();
+      cache0.set(a1, cache1);
+    }
+    let cache2 = cache1.get(a2);
+    if (cache2 === void 0) {
+      cache2 = new WeakMap();
+      cache1.set(a2, cache2);
+    }
+    let fnResult = cache2.get(a3);
+    if (fnResult === void 0) {
+      fnResult = fn(a1, a2, a3);
+      cache2.set(a3, fnResult);
+    }
+    return fnResult;
+  };
+}
+export {
+  memoize3
+};

package/lib/jsutils/naturalCompare.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a number indicating whether a reference string comes before, or after,
+ * or is the same as the given string in natural sort order.
+ *
+ * See: https://en.wikipedia.org/wiki/Natural_sort_order
+ *
+ */
+export declare function naturalCompare(aStr: string, bStr: string): number;
+//# sourceMappingURL=naturalCompare.d.ts.map

package/lib/jsutils/naturalCompare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naturalCompare.d.ts","sourceRoot":"","sources":["../../src/jsutils/naturalCompare.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA2CjE"}