atom.io 0.28.0 → 0.28.2

package/dist/chunk-D52JNVER.js

@@ -1,721 +0,0 @@
-import * as Internal from 'atom.io/internal';
-import { createRegularAtom, deposit, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily, createReadonlySelectorFamily } from 'atom.io/internal';
-import { getState } from 'atom.io';
-
-// introspection/src/attach-introspection-states.ts
-var attachAtomIndex = (store = IMPLICIT.STORE) => {
-  const atomTokenIndexState__INTERNAL = createRegularAtom(
-    store,
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
-      default: () => {
-        const base = /* @__PURE__ */ new Map();
-        for (const [key, val] of store.atoms) {
-          if (!key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-            const token = deposit(val);
-            if (val.family) {
-              let familyNode = base.get(val.family.key);
-              if (!familyNode || !(`familyMembers` in familyNode)) {
-                familyNode = {
-                  key: val.family.key,
-                  familyMembers: /* @__PURE__ */ new Map()
-                };
-                base.set(val.family.key, familyNode);
-              }
-              familyNode.familyMembers.set(val.family.subKey, token);
-            } else {
-              base.set(key, token);
-            }
-          }
-        }
-        return base;
-      },
-      effects: [
-        ({ setSelf }) => {
-          store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
-            if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-              return;
-            }
-            setSelf((self) => {
-              if (atomToken.family) {
-                const { key: familyKey, subKey } = atomToken.family;
-                let familyNode = self.get(familyKey);
-                if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
-                  familyNode = {
-                    key: familyKey,
-                    familyMembers: /* @__PURE__ */ new Map()
-                  };
-                  self.set(familyKey, familyNode);
-                }
-                familyNode.familyMembers.set(subKey, atomToken);
-              } else {
-                self.set(atomToken.key, atomToken);
-              }
-              return self;
-            });
-          });
-          store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
-            setSelf((self) => {
-              if (atomToken.family) {
-                const { key: familyKey, subKey } = atomToken.family;
-                const familyNode = self.get(familyKey);
-                if (familyNode && `familyMembers` in familyNode) {
-                  familyNode.familyMembers.delete(subKey);
-                  if (familyNode.familyMembers.size === 0) {
-                    self.delete(familyKey);
-                  }
-                }
-              } else {
-                self.delete(atomToken.key);
-              }
-              return self;
-            });
-          });
-        }
-      ]
-    },
-    void 0
-  );
-  return createStandaloneSelector(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
-    get: ({ get }) => get(atomTokenIndexState__INTERNAL)
-  });
-};
-var attachSelectorIndex = (store = IMPLICIT.STORE) => {
-  const readonlySelectorTokenIndexState__INTERNAL = createRegularAtom(
-    store,
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index (Internal)`,
-      default: () => {
-        const base = /* @__PURE__ */ new Map();
-        for (const map2 of [store.readonlySelectors, store.selectors]) {
-          for (const [key, val] of map2) {
-            if (!key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-              const token = deposit(val);
-              if (val.family) {
-                let familyNode = base.get(val.family.key);
-                if (!familyNode || !(`familyMembers` in familyNode)) {
-                  familyNode = {
-                    key: val.family.key,
-                    familyMembers: /* @__PURE__ */ new Map()
-                  };
-                  base.set(val.family.key, familyNode);
-                }
-                familyNode.familyMembers.set(val.family.subKey, token);
-              } else {
-                base.set(key, token);
-              }
-            }
-          }
-        }
-        return base;
-      },
-      effects: [
-        ({ setSelf }) => {
-          store.on.selectorCreation.subscribe(
-            `introspection`,
-            (selectorToken) => {
-              if (selectorToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-                return;
-              }
-              setSelf((self) => {
-                if (selectorToken.family) {
-                  const { key: familyKey, subKey } = selectorToken.family;
-                  let familyNode = self.get(familyKey);
-                  if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
-                    familyNode = {
-                      key: familyKey,
-                      familyMembers: /* @__PURE__ */ new Map()
-                    };
-                    self.set(familyKey, familyNode);
-                  }
-                  familyNode.familyMembers.set(subKey, selectorToken);
-                } else {
-                  self.set(selectorToken.key, selectorToken);
-                }
-                return self;
-              });
-            }
-          );
-          store.on.selectorDisposal.subscribe(
-            `introspection`,
-            (selectorToken) => {
-              setSelf((self) => {
-                if (selectorToken.family) {
-                  const { key: familyKey, subKey } = selectorToken.family;
-                  const familyNode = self.get(familyKey);
-                  if (familyNode && `familyMembers` in familyNode) {
-                    familyNode.familyMembers.delete(subKey);
-                    if (familyNode.familyMembers.size === 0) {
-                      self.delete(familyKey);
-                    }
-                  }
-                } else {
-                  self.delete(selectorToken.key);
-                }
-                return self;
-              });
-            }
-          );
-        }
-      ]
-    },
-    void 0
-  );
-  return createStandaloneSelector(IMPLICIT.STORE, {
-    key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
-    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
-  });
-};
-var attachTimelineFamily = (store = IMPLICIT.STORE) => {
-  const findTimelineLogState__INTERNAL = createRegularAtomFamily(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
-    default: (key) => store.timelines.get(key) ?? {
-      type: `timeline`,
-      key: ``,
-      at: 0,
-      timeTraveling: null,
-      history: [],
-      selectorTime: null,
-      transactionKey: null,
-      install: () => {
-      },
-      subject: new Subject(),
-      subscriptions: /* @__PURE__ */ new Map()
-    },
-    effects: (key) => [
-      ({ setSelf }) => {
-        const tl = store.timelines.get(key);
-        tl?.subject.subscribe(`introspection`, (_) => {
-          setSelf({ ...tl });
-        });
-      }
-    ]
-  });
-  const findTimelineLogState = createSelectorFamily(
-    store,
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
-      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
-    }
-  );
-  return findTimelineLogState;
-};
-var attachTimelineIndex = (store = IMPLICIT.STORE) => {
-  const timelineTokenIndexState__INTERNAL = createRegularAtom(
-    store,
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index (Internal)`,
-      default: () => [...store.timelines].map(([key]) => {
-        return { key, type: `timeline` };
-      }),
-      effects: [
-        ({ setSelf }) => {
-          store.on.timelineCreation.subscribe(
-            `introspection`,
-            (timelineToken) => {
-              setSelf((state) => [...state, timelineToken]);
-            }
-          );
-        }
-      ]
-    },
-    void 0
-  );
-  const timelineTokenIndex = createStandaloneSelector(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
-    get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
-  });
-  return timelineTokenIndex;
-};
-var attachTransactionIndex = (store = IMPLICIT.STORE) => {
-  const transactionTokenIndexState__INTERNAL = createRegularAtom(
-    store,
-    {
-      key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index (Internal)`,
-      default: () => [...store.transactions].map(([key]) => {
-        return { key, type: `transaction` };
-      }),
-      effects: [
-        ({ setSelf }) => {
-          store.on.transactionCreation.subscribe(
-            `introspection`,
-            (transactionToken) => {
-              setSelf((state) => [...state, transactionToken]);
-            }
-          );
-        }
-      ]
-    },
-    void 0
-  );
-  const transactionTokenIndex = createStandaloneSelector(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
-    get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
-  });
-  return transactionTokenIndex;
-};
-var attachTransactionLogs = (store = IMPLICIT.STORE) => {
-  const transactionUpdateLogAtoms = createRegularAtomFamily(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
-    default: () => [],
-    effects: (key) => [
-      ({ setSelf }) => {
-        const tx = store.transactions.get(key);
-        tx?.subject.subscribe(`introspection`, (transactionUpdate) => {
-          if (transactionUpdate.key === key) {
-            setSelf((state) => [...state, transactionUpdate]);
-          }
-        });
-      }
-    ]
-  });
-  const findTransactionUpdateLogState = createSelectorFamily(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
-    get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
-  });
-  return findTransactionUpdateLogState;
-};
-
-// introspection/src/refinery.ts
-var Refinery = class {
-  supported;
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (_) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (__) {
-        }
-      }
-    }
-    return null;
-  }
-};
-var primitiveRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  null: (input) => input === null
-});
-var jsonTreeRefinery = new Refinery({
-  object: (input) => {
-    if (!input) {
-      return false;
-    }
-    const prototype = Object.getPrototypeOf(input);
-    return prototype === Object.prototype;
-  },
-  array: (input) => Array.isArray(input)
-});
-var jsonRefinery = new Refinery({
-  ...primitiveRefinery.supported,
-  ...jsonTreeRefinery.supported
-});
-var discoverType = (input) => {
-  if (input === void 0) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
-};
-
-// introspection/src/attach-type-selectors.ts
-var attachTypeSelectors = (store = IMPLICIT.STORE) => {
-  const typeSelectors = createReadonlySelectorFamily(store, {
-    key: `\u{1F441}\u200D\u{1F5E8} State Type`,
-    get: (token) => ({ get }) => {
-      let state;
-      try {
-        state = get(token);
-      } catch (error) {
-        return `error`;
-      }
-      const typeOfState = discoverType(state);
-      return typeOfState;
-    }
-  });
-  return typeSelectors;
-};
-
-// introspection/src/attach-introspection-states.ts
-var attachIntrospectionStates = (store = Internal.IMPLICIT.STORE) => {
-  return {
-    atomIndex: attachAtomIndex(store),
-    selectorIndex: attachSelectorIndex(store),
-    transactionIndex: attachTransactionIndex(store),
-    transactionLogSelectors: attachTransactionLogs(store),
-    timelineIndex: attachTimelineIndex(store),
-    timelineSelectors: attachTimelineFamily(store),
-    typeSelectors: attachTypeSelectors(store)
-  };
-};
-var Auditor = class _Auditor {
-  /**
-   * @param {Store} store - The store to audit.
-   */
-  constructor(store = Internal.IMPLICIT.STORE) {
-    this.store = store;
-    this.atomIndex = attachAtomIndex(this.store);
-    this.selectorIndex = attachSelectorIndex(this.store);
-    this.unsubscribeFromAtomCreation = this.store.on.atomCreation.subscribe(
-      `auditor-${this.auditorCreatedAt}`,
-      ({ key }) => {
-        this.statesCreatedAt.set(key, performance.now() - this.auditorCreatedAt);
-      }
-    );
-    this.unsubscribeFromAtomDisposal = this.store.on.atomDisposal.subscribe(
-      `auditor-${this.auditorCreatedAt}`,
-      ({ key }) => {
-        this.statesCreatedAt.delete(key);
-      }
-    );
-    this.unsubscribeFromSelectorCreation = this.store.on.selectorCreation.subscribe(
-      `auditor-${this.auditorCreatedAt}`,
-      ({ key }) => {
-        this.statesCreatedAt.set(
-          key,
-          performance.now() - this.auditorCreatedAt
-        );
-      }
-    );
-    this.unsubscribeFromSelectorDisposal = this.store.on.selectorDisposal.subscribe(
-      `auditor-${this.auditorCreatedAt}`,
-      ({ key }) => {
-        this.statesCreatedAt.delete(key);
-      }
-    );
-  }
-  auditorCreatedAt = performance.now();
-  statesCreatedAt = /* @__PURE__ */ new Map();
-  atomIndex;
-  selectorIndex;
-  disposed = false;
-  unsubscribeFromAtomCreation;
-  unsubscribeFromAtomDisposal;
-  unsubscribeFromSelectorCreation;
-  unsubscribeFromSelectorDisposal;
-  static DEFAULT_LIST_RESOURCES_PARAM = {
-    atomFamilies: true,
-    selectorFamilies: true
-  };
-  /**
-   * Lists all resources in the store, along with their creation time.
-   *
-   * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
-   * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
-   */
-  listResources(param = _Auditor.DEFAULT_LIST_RESOURCES_PARAM) {
-    if (this.disposed) {
-      throw new Error(`This Auditor has been disposed`);
-    }
-    const atoms = getState(this.atomIndex);
-    const selectors = getState(this.selectorIndex);
-    const atomFamilyNodes = [...atoms.values()].filter(
-      (node) => `familyMembers` in node
-    );
-    const selectorFamilyNodes = [...selectors.values()].filter(
-      (node) => `familyMembers` in node
-    );
-    const currentTime = performance.now();
-    const resources = [];
-    if (param.atomFamilies) {
-      for (const familyNode of atomFamilyNodes) {
-        const tokens = familyNode.familyMembers.values();
-        for (const token of tokens) {
-          const storedTime = this.statesCreatedAt.get(token.key);
-          const creationTime = storedTime ?? this.auditorCreatedAt;
-          const age = currentTime - creationTime;
-          resources.push([token, age]);
-        }
-      }
-    }
-    if (param.selectorFamilies) {
-      for (const familyNode of selectorFamilyNodes) {
-        const tokens = familyNode.familyMembers.values();
-        for (const token of tokens) {
-          const storedTime = this.statesCreatedAt.get(token.key);
-          const creationTime = storedTime ?? this.auditorCreatedAt;
-          const age = currentTime - creationTime;
-          resources.push([token, age]);
-        }
-      }
-    }
-    return resources;
-  }
-  [Symbol.dispose]() {
-    this.unsubscribeFromAtomCreation();
-    this.unsubscribeFromAtomDisposal();
-    this.unsubscribeFromSelectorCreation();
-    this.unsubscribeFromSelectorDisposal();
-    this.disposed = true;
-  }
-};
-
-// ../anvl/src/array/index.ts
-var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
-var map = (f) => (a) => a.map(f);
-var every = (f = Boolean) => (a) => a.every(f);
-var allTrue = every((x) => x === true);
-
-// ../anvl/src/function/pipe.ts
-function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
-  switch (arguments.length) {
-    case 1:
-      return a;
-    case 2:
-      return ab(a);
-    case 3:
-      return bc(ab(a));
-    case 4:
-      return cd(bc(ab(a)));
-    case 5:
-      return de(cd(bc(ab(a))));
-    case 6:
-      return ef(de(cd(bc(ab(a)))));
-    case 7:
-      return fg(ef(de(cd(bc(ab(a))))));
-    case 8:
-      return gh(fg(ef(de(cd(bc(ab(a)))))));
-    case 9:
-      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
-    default: {
-      let ret = arguments[0];
-      for (let i = 1; i < arguments.length; i++) {
-        ret = arguments[i](ret);
-      }
-      return ret;
-    }
-  }
-}
-
-// ../anvl/src/function/index.ts
-var doNothing = () => void 0;
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
-var pass = (...params) => (fn) => fn(...params);
-
-// ../anvl/src/nullish/index.ts
-var isUndefined = (input) => input === void 0;
-var ifDefined = (validate) => (input) => isUndefined(input) || validate(input);
-var ifNullish = (alt) => (input) => input ?? alt;
-
-// ../anvl/src/object/access.ts
-var access = (k) => Object.assign((obj) => obj[k], {
-  in: (obj) => obj[k]
-});
-
-// ../anvl/src/object/entries.ts
-var recordToEntries = (obj) => Object.entries(obj);
-var entriesToRecord = (entries) => Object.fromEntries(entries);
-
-// ../anvl/src/object/mapObject.ts
-var mapObject = (obj, fn) => pipe(
-  obj,
-  recordToEntries,
-  map(([key, val]) => [key, fn(val, key)]),
-  entriesToRecord
-);
-var mob = (fn) => (obj) => mapObject(obj, fn);
-
-// ../anvl/src/object/refinement.ts
-var isNonNullObject = (input) => typeof input === `object` && input !== null;
-var isPlainObject = (input) => isNonNullObject(input) && Object.getPrototypeOf(input) === Object.prototype;
-var isRecord = (isKey, isValue) => (input) => isPlainObject(input) && Object.entries(input).every(([k, v]) => isKey(k) && isValue(v));
-var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
-  const name = `{${recordToEntries(
-    isValue
-  ).map(([k, v]) => String(k) + `:` + v.name).join(`,`)}}`;
-  const _ = {
-    [name]: (input) => isPlainObject(input) && pipe(
-      isValue,
-      Object.entries,
-      every(([key, val]) => key in input || val(void 0))
-    ) && pipe(
-      input,
-      mob(
-        (val, key) => pipe(
-          isValue,
-          access(key),
-          ifNullish(() => options.allowExtraProperties),
-          pass(val)
-        )
-      ),
-      Object.values,
-      allTrue
-    )
-  };
-  return _[name];
-};
-var ALLOW_EXTENSION = { allowExtraProperties: true };
-var doesExtend = (isValue) => hasProperties(isValue, ALLOW_EXTENSION);
-
-// ../anvl/src/object/sprawl.ts
-var sprawl = (tree, inspector) => {
-  const walk = (path, node) => {
-    const inspect = (p, n) => {
-      const result2 = inspector(p, n);
-      if (result2) return result2;
-      return null;
-    };
-    const result = inspect(path, node);
-    if (result?.jobComplete ?? result?.pathComplete) {
-      return result;
-    }
-    const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
-    for (const [k, v] of childEntries) {
-      const subResult = walk([...path, k], v);
-      if (subResult?.jobComplete) {
-        return subResult;
-      }
-    }
-    return {};
-  };
-  walk([], tree);
-};
-
-// ../anvl/src/object/index.ts
-var delve = (obj, path) => {
-  const found = path.reduce((acc, key) => acc?.[key], obj);
-  return found === void 0 ? new Error(`Not found`) : { found };
-};
-
-// introspection/src/differ.ts
-function diffNumber(a, b) {
-  const sign = a < b ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
-  };
-}
-function diffString(a, b) {
-  const sign = a.length < b.length ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
-  };
-}
-function diffBoolean(a, b) {
-  return {
-    summary: `${a} \u2192 ${b}`
-  };
-}
-function diffObject(a, b, recurse) {
-  let summary = ``;
-  const added = [];
-  const removed = [];
-  const changed = [];
-  sprawl(a, (path, nodeA) => {
-    let key;
-    for (key of path) {
-      const nodeB = b[key];
-      if (nodeB === void 0) {
-        removed.push([key, JSON.stringify(nodeA)]);
-      } else {
-        const delta = recurse(nodeA, nodeB);
-        if (delta.summary !== `No Change`) {
-          changed.push([key, delta]);
-        }
-      }
-    }
-  });
-  sprawl(b, (path, nodeB) => {
-    let key;
-    for (key of path) {
-      const nodeA = a[key];
-      if (nodeA === void 0) {
-        added.push([key, JSON.stringify(nodeB)]);
-      }
-    }
-  });
-  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
-  return {
-    summary,
-    added,
-    removed,
-    changed
-  };
-}
-function diffArray(a, b, recurse) {
-  return diffObject(a, b, recurse);
-}
-var Differ = class {
-  leafRefinery;
-  treeRefinery;
-  leafDiffers;
-  treeDiffers;
-  constructor(leafRefinery, treeRefinery, diffFunctions) {
-    this.leafRefinery = leafRefinery;
-    this.treeRefinery = treeRefinery;
-    this.leafDiffers = {};
-    this.treeDiffers = {};
-    for (const key of Object.keys(leafRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.leafDiffers[key] = diffFunction;
-    }
-    for (const key of Object.keys(treeRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.treeDiffers[key] = diffFunction;
-    }
-  }
-  diff(a, b) {
-    if (a === b) {
-      return { summary: `No Change` };
-    }
-    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
-    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
-    if (aRefined !== null && bRefined !== null) {
-      if (aRefined.type === bRefined.type) {
-        if (aRefined.type in this.leafDiffers) {
-          const delta = this.leafDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data
-          );
-          return delta;
-        }
-        if (aRefined.type in this.treeDiffers) {
-          const delta = this.treeDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data,
-            (x, y) => this.diff(x, y)
-          );
-          return delta;
-        }
-      }
-    }
-    const typeA = discoverType(a);
-    const typeB = discoverType(b);
-    if (typeA === typeB) {
-      return {
-        summary: `${typeA} \u2192 ${typeB}`
-      };
-    }
-    return {
-      summary: `Type change: ${typeA} \u2192 ${typeB}`
-    };
-  }
-};
-var prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
-  number: diffNumber,
-  string: diffString,
-  boolean: diffBoolean,
-  null: () => ({ summary: `No Change` }),
-  object: diffObject,
-  array: diffArray
-});
-
-export { Auditor, Differ, Refinery, attachIntrospectionStates, become, delve, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, doNothing, doesExtend, ifDefined, isArray, isPlainObject, isRecord, jsonRefinery, jsonTreeRefinery, mapObject, pipe, prettyJson, primitiveRefinery };