@lwrjs/everywhere 0.9.0-alpha.5 → 0.9.0-alpha.6

package/build/__generated_site_amd_modules__/1/module/amd/1/l/en-US/mi/@luvio/engine/v/0_47_5/s/36bfa830117d5ec91c746f01125fb4d5/@luvio_engine.js

@@ -0,0 +1,1766 @@
+LWR.define("@luvio/engine/v/0_47_5", ["exports"], function(exports) {
+  "use strict";
+  var DEFAULT_TOKEN = "0";
+  var END_TOKEN = "__END__";
+  function pagination(pd, save) {
+    const pd_ = pd || {[DEFAULT_TOKEN]: 0};
+    return {
+      defaultToken: () => DEFAULT_TOKEN,
+      endOffset: () => pd_[END_TOKEN],
+      isPastEnd: (offset) => {
+        return END_TOKEN in pd_ && offset >= pd_[END_TOKEN];
+      },
+      limitToEnd: (offset) => {
+        return END_TOKEN in pd_ && offset >= pd_[END_TOKEN] ? pd_[END_TOKEN] : offset;
+      },
+      offsetFor: (token) => {
+        return pd_[token || DEFAULT_TOKEN];
+      },
+      save: () => {
+        if (!save)
+          ;
+        else {
+          save(pd_);
+        }
+      },
+      setEnd: (offset) => {
+        if (offset === void 0) {
+          delete pd_[END_TOKEN];
+        } else {
+          pd_[END_TOKEN] = offset;
+        }
+      },
+      setToken: (token, offset) => {
+        if (offset === void 0) {
+          delete pd_[token];
+        } else {
+          pd_[token] = offset;
+        }
+      },
+      tokenFor: (offset) => {
+        const tokens = Object.keys(pd_);
+        for (let i = 0; i < tokens.length; ++i) {
+          if (pd_[tokens[i]] === offset) {
+            return tokens[i];
+          }
+        }
+      },
+      tokenForAtMost: (offset) => {
+        let result = [DEFAULT_TOKEN, 0];
+        const tokens = Object.keys(pd_);
+        for (let i = 0; i < tokens.length; ++i) {
+          let offsetI = pd_[tokens[i]];
+          if (offsetI <= offset && offsetI > result[1]) {
+            result = [tokens[i], offsetI];
+          }
+        }
+        return result;
+      }
+    };
+  }
+  function isUnionObjectSelection(sel) {
+    return sel.union === true && sel.kind === "Object";
+  }
+  function isReaderFragment(fragment) {
+    return fragment.reader === true;
+  }
+  function isFragmentUnionSelection(sel) {
+    return sel.union === true;
+  }
+  var {create, freeze, keys} = Object;
+  var {hasOwnProperty} = Object.prototype;
+  var {isArray} = Array;
+  var {push, indexOf, slice} = Array.prototype;
+  var {stringify} = JSON;
+  function deepFreeze(value) {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    if (isArray(value)) {
+      for (let i = 0, len = value.length; i < len; i += 1) {
+        deepFreeze(value[i]);
+      }
+    } else {
+      const keys$1 = keys(value);
+      for (let i = 0, len = keys$1.length; i < len; i += 1) {
+        deepFreeze(value[keys$1[i]]);
+      }
+    }
+    freeze(value);
+  }
+  var SnapshotState;
+  (function(SnapshotState2) {
+    SnapshotState2["Fulfilled"] = "Fulfilled";
+    SnapshotState2["Unfulfilled"] = "Unfulfilled";
+    SnapshotState2["Error"] = "Error";
+    SnapshotState2["Pending"] = "Pending";
+    SnapshotState2["Stale"] = "Stale";
+  })(SnapshotState || (SnapshotState = {}));
+  function isErrorSnapshot(snapshot) {
+    return snapshot.state === SnapshotState.Error;
+  }
+  function isFulfilledSnapshot(snapshot) {
+    return snapshot.state === SnapshotState.Fulfilled;
+  }
+  function isUnfulfilledSnapshot(snapshot) {
+    return snapshot.state === SnapshotState.Unfulfilled;
+  }
+  function isPendingSnapshot(snapshot) {
+    return snapshot.state === SnapshotState.Pending;
+  }
+  function createErrorSnapshot(error, refresh) {
+    deepFreeze(error);
+    const snap = {
+      error,
+      state: SnapshotState.Error,
+      data: void 0,
+      refresh
+    };
+    return snap;
+  }
+  function formatStorageKey(name, argValues) {
+    if (!argValues) {
+      return name;
+    }
+    var values = [];
+    for (var _argName in argValues) {
+      if (hasOwnProperty.call(argValues, _argName)) {
+        var value = argValues[_argName];
+        if (value !== null || value !== void 0) {
+          values.push(_argName + ":" + stringify(value));
+        }
+      }
+    }
+    return values.length === 0 ? name : name + "(".concat(values.join(","), ")");
+  }
+  function getArgumentValues(args, variables) {
+    const values = {};
+    args.forEach((arg) => {
+      if (arg.kind === "Variable") {
+        values[arg.name] = variables[arg.variableName];
+      } else {
+        values[arg.name] = arg.value;
+      }
+    });
+    return values;
+  }
+  function getStorageKey(field, variables) {
+    const {args, name} = field;
+    if (args && args.length !== 0) {
+      return formatStorageKey(name, getArgumentValues(args, variables));
+    }
+    return name;
+  }
+  function isDefined(value) {
+    return value !== void 0 && value !== null;
+  }
+  var StoreLinkStateValues;
+  (function(StoreLinkStateValues2) {
+    StoreLinkStateValues2[StoreLinkStateValues2["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues2[StoreLinkStateValues2["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues2[StoreLinkStateValues2["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues2[StoreLinkStateValues2["Null"] = 3] = "Null";
+    StoreLinkStateValues2[StoreLinkStateValues2["Missing"] = 4] = "Missing";
+    StoreLinkStateValues2[StoreLinkStateValues2["Pending"] = 5] = "Pending";
+  })(StoreLinkStateValues || (StoreLinkStateValues = {}));
+  function getLinkState(link) {
+    if (link === void 0) {
+      return {
+        state: StoreLinkStateValues.NotPresent
+      };
+    }
+    if (link === null) {
+      return {
+        state: StoreLinkStateValues.Null
+      };
+    }
+    const {__ref: key, pending, isMissing} = link;
+    if (pending === true) {
+      return {
+        state: StoreLinkStateValues.Pending
+      };
+    }
+    if (isMissing === true) {
+      return {
+        state: StoreLinkStateValues.Missing
+      };
+    }
+    if (key === void 0) {
+      return {
+        state: StoreLinkStateValues.RefNotPresent
+      };
+    }
+    return {
+      state: StoreLinkStateValues.RefPresent,
+      key
+    };
+  }
+  var StoreResolveResultState;
+  (function(StoreResolveResultState2) {
+    StoreResolveResultState2[StoreResolveResultState2["Found"] = 0] = "Found";
+    StoreResolveResultState2[StoreResolveResultState2["Error"] = 1] = "Error";
+    StoreResolveResultState2[StoreResolveResultState2["Locked"] = 2] = "Locked";
+    StoreResolveResultState2[StoreResolveResultState2["Null"] = 3] = "Null";
+    StoreResolveResultState2[StoreResolveResultState2["NotPresent"] = 4] = "NotPresent";
+    StoreResolveResultState2[StoreResolveResultState2["Stale"] = 5] = "Stale";
+  })(StoreResolveResultState || (StoreResolveResultState = {}));
+  function storeLookup(key, timestamp, records, redirects, expirationMap) {
+    let canonicalKey = key;
+    let value = records[canonicalKey];
+    const redirectKeys = [];
+    if (value === void 0) {
+      while (redirects[canonicalKey] !== void 0) {
+        push.call(redirectKeys, canonicalKey);
+        canonicalKey = redirects[canonicalKey];
+      }
+      value = records[canonicalKey];
+      if (value === void 0) {
+        return {
+          state: StoreResolveResultState.NotPresent,
+          redirects: redirectKeys,
+          resolvedKey: canonicalKey
+        };
+      }
+    }
+    const ttl = expirationMap[canonicalKey];
+    const valueIsError = value !== null && isStoreRecordError(value);
+    const valueIsLocked = value !== null && isStoreRecordLocked(value);
+    if (valueIsLocked === true) {
+      return {
+        state: StoreResolveResultState.Locked,
+        redirects: redirectKeys,
+        resolvedKey: canonicalKey
+      };
+    }
+    if (ttl !== void 0) {
+      const {fresh, stale} = ttl;
+      if (timestamp > fresh) {
+        if (timestamp <= stale && valueIsError !== true) {
+          return {
+            state: StoreResolveResultState.Stale,
+            value,
+            redirects: redirectKeys,
+            resolvedKey: canonicalKey
+          };
+        }
+        return {
+          state: StoreResolveResultState.NotPresent,
+          redirects: redirectKeys,
+          resolvedKey: canonicalKey
+        };
+      }
+    }
+    if (valueIsError === true) {
+      return {
+        state: StoreResolveResultState.Error,
+        value: value.error,
+        redirects: redirectKeys,
+        resolvedKey: canonicalKey
+      };
+    }
+    return {
+      state: StoreResolveResultState.Found,
+      value,
+      redirects: redirectKeys,
+      resolvedKey: canonicalKey
+    };
+  }
+  var READER_PATH_ROOT = "ROOT";
+  var EMPTY_STRING = "";
+  var FragmentReadResultState;
+  (function(FragmentReadResultState2) {
+    FragmentReadResultState2[FragmentReadResultState2["Missing"] = 0] = "Missing";
+    FragmentReadResultState2[FragmentReadResultState2["Success"] = 1] = "Success";
+    FragmentReadResultState2[FragmentReadResultState2["Error"] = 2] = "Error";
+    FragmentReadResultState2[FragmentReadResultState2["Locked"] = 3] = "Locked";
+  })(FragmentReadResultState || (FragmentReadResultState = {}));
+  var FRAGMENT_READ_RESULT_MISSING = {
+    state: FragmentReadResultState.Missing
+  };
+  var Reader = class {
+    constructor(records, expirationMap, redirects, variables, refresh, baseSnapshot) {
+      this.missingPaths = {};
+      this.missingLinks = {};
+      this.hasPendingData = false;
+      this.hasLockedData = false;
+      this.getLinkState = getLinkState;
+      this.StoreLinkStateValues = StoreLinkStateValues;
+      this.StoreResolveResultState = StoreResolveResultState;
+      this.variables = variables;
+      this.records = records;
+      this.seenIds = {};
+      this.isMissingData = false;
+      this.hasStaleData = false;
+      this.refresh = refresh;
+      let snapshotChanged = true;
+      let baseSnapshotValue = void 0;
+      if (baseSnapshot !== void 0 && (baseSnapshot.state === SnapshotState.Fulfilled || baseSnapshot.state === SnapshotState.Stale)) {
+        baseSnapshotValue = baseSnapshot.data;
+        snapshotChanged = false;
+      }
+      this.snapshotChanged = snapshotChanged;
+      this.currentPath = {
+        fullPath: EMPTY_STRING,
+        key: READER_PATH_ROOT,
+        parent: null,
+        baseSnapshotValue
+      };
+      this.baseSnapshot = baseSnapshot;
+      this.expirationMap = expirationMap;
+      this.redirects = redirects;
+      this.timestamp = Date.now();
+    }
+    pagination(key) {
+      const lookup = this.resolveKey(key);
+      return pagination(lookup.value);
+    }
+    readFragmentUnion(result, selection) {
+      const {value: record} = result;
+      const {discriminator} = selection;
+      const discriminatorValue = record[discriminator];
+      return this.readFragment(result, selection.unionSelections[discriminatorValue]);
+    }
+    read(selector) {
+      const {node: selectorNode} = selector;
+      const {recordId: key} = selector;
+      const result = this.storeLookup(key);
+      const fragmentResult = this.readFragment(result, selectorNode);
+      switch (fragmentResult.state) {
+        case FragmentReadResultState.Missing:
+          if (this.isMissingData === false) {
+            this.isMissingData = true;
+            this.snapshotChanged = true;
+          }
+          return this.createSnapshot(void 0, selector);
+        case FragmentReadResultState.Locked:
+          if (this.hasLockedData === false) {
+            this.hasLockedData = true;
+            this.snapshotChanged = true;
+          }
+          return this.createSnapshot(void 0, selector);
+        case FragmentReadResultState.Error:
+          return this.createErrorSnapshot(fragmentResult.value);
+        default:
+          return this.createSnapshot(fragmentResult.value, selector);
+      }
+    }
+    getSnapshotState() {
+      if (this.isMissingData === true) {
+        return SnapshotState.Unfulfilled;
+      }
+      if (this.hasPendingData === true || this.hasLockedData === true) {
+        return SnapshotState.Pending;
+      }
+      if (this.hasStaleData === true) {
+        return SnapshotState.Stale;
+      }
+      return SnapshotState.Fulfilled;
+    }
+    createErrorSnapshot(data) {
+      return {
+        data: void 0,
+        error: data,
+        state: SnapshotState.Error,
+        refresh: this.refresh
+      };
+    }
+    createSnapshot(data, selector) {
+      if (this.snapshotChanged === false && selector.recordId === this.baseSnapshot.recordId) {
+        return this.baseSnapshot;
+      }
+      return {
+        recordId: selector.recordId,
+        select: selector,
+        variables: this.variables,
+        seenRecords: this.seenIds,
+        data,
+        state: this.getSnapshotState(),
+        missingPaths: this.missingPaths,
+        missingLinks: this.missingLinks,
+        refresh: this.refresh
+      };
+    }
+    deepCopy(record, data, key, visitedKeys) {
+      const value = record[key];
+      this.enterPath(key);
+      if (isArray(value)) {
+        const items = [];
+        this.selectAll(value, items, visitedKeys);
+        data[key] = items;
+      } else if (typeof value === "object" && value !== null) {
+        if (value.__ref !== void 0) {
+          const nextRecordId = value.__ref;
+          if (isArray(nextRecordId)) {
+            const items = [];
+            this.selectAll(nextRecordId, items, visitedKeys);
+            data[key] = items;
+          } else {
+            if (hasOwnProperty.call(visitedKeys, nextRecordId) === true) {
+              throw new Error(`Invalid eager selection on records with circular references.`);
+            }
+            const lookupResult = this.resolveKey(nextRecordId);
+            switch (lookupResult.state) {
+              case StoreResolveResultState.NotPresent:
+                data[key] = void 0;
+                break;
+              case StoreResolveResultState.Found: {
+                const nested = {};
+                this.selectAll(lookupResult.value, nested, {
+                  ...visitedKeys,
+                  [nextRecordId]: true
+                });
+                data[key] = nested;
+                break;
+              }
+            }
+          }
+        } else {
+          const items = {};
+          this.selectAll(value, items, visitedKeys);
+          data[key] = items;
+        }
+      } else {
+        this.checkIfChanged(value);
+        data[key] = value;
+      }
+      this.exitPath();
+    }
+    selectAllArray(record, data, visitedKeys) {
+      const {length} = record;
+      for (let key = 0; key < length; key += 1) {
+        this.deepCopy(record, data, key, visitedKeys);
+      }
+    }
+    selectAllObject(record, data, visitedKeys) {
+      const recordKeys = keys(record);
+      const {length} = recordKeys;
+      for (let i = 0; i < length; i += 1) {
+        const key = recordKeys[i];
+        this.deepCopy(record, data, key, visitedKeys);
+      }
+    }
+    selectAll(record, data, visitedKeys = {}) {
+      const recordIsArray = isArray(record);
+      if (recordIsArray === true) {
+        this.selectAllArray(record, data, visitedKeys);
+      } else {
+        this.selectAllObject(record, data, visitedKeys);
+      }
+      freeze(data);
+    }
+    markPending() {
+      this.hasPendingData = true;
+    }
+    markStale() {
+      this.hasStaleData = true;
+    }
+    markMissing() {
+      this.isMissingData = true;
+      this.missingPaths[this.currentPath.fullPath] = true;
+      this.checkIfChanged(void 0);
+    }
+    markLocked() {
+      this.hasLockedData = true;
+      this.checkIfChanged(void 0);
+    }
+    markMissingLink(linkKey) {
+      this.missingLinks[linkKey] = true;
+      this.markMissing();
+    }
+    unMarkMissing() {
+      delete this.missingPaths[this.currentPath.fullPath];
+      if (keys(this.missingPaths).length === 0) {
+        this.isMissingData = false;
+      }
+    }
+    assignNonScalar(sink, key, value) {
+      sink[key] = value;
+      freeze(value);
+    }
+    enterPath(key) {
+      const parent = this.currentPath;
+      const {key: parentKey, fullPath: parentFullPath, baseSnapshotValue: parentBaseSnapshotValue} = parent;
+      let baseSnapshotValue = void 0;
+      if (parentBaseSnapshotValue !== void 0 && parentBaseSnapshotValue !== null) {
+        baseSnapshotValue = parentBaseSnapshotValue[key];
+      }
+      this.currentPath = {
+        parent,
+        key,
+        fullPath: parentKey === READER_PATH_ROOT ? key : parentFullPath + "." + key,
+        baseSnapshotValue
+      };
+    }
+    exitPath() {
+      this.currentPath = this.currentPath.parent;
+    }
+    readSingleLink(propertyName, selection, source, sink, assignmentProperty) {
+      const {required, nullable, fragment} = selection;
+      const link = source[propertyName];
+      const property = assignmentProperty === void 0 ? propertyName : assignmentProperty;
+      const linkState = getLinkState(link);
+      switch (linkState.state) {
+        case StoreLinkStateValues.RefNotPresent:
+        case StoreLinkStateValues.NotPresent:
+        case StoreLinkStateValues.Missing:
+          if (isReaderFragment(fragment) && fragment.synthetic === true) {
+            return this.assignNonScalar(sink, property, fragment.read(this));
+          }
+          if (linkState.state === StoreLinkStateValues.Missing && required === false) {
+            return;
+          }
+          this.markMissing();
+          return;
+        case StoreLinkStateValues.Null:
+          if (nullable === true) {
+            this.readScalar(propertyName, source, sink);
+            return;
+          }
+          throw new Error(`Invalid Link State. Link on "${this.currentPath.fullPath}" is null but selection is not nullable: 
+${stringify(selection, null, 2)}`);
+        case StoreLinkStateValues.Pending:
+          this.markPending();
+          return;
+        default:
+          this.readStoreLinkWithRef(linkState, fragment, sink, property, required);
+      }
+    }
+    markRedirectsSeen(state) {
+      const {redirects} = state;
+      const {length: len} = redirects;
+      if (len === 0) {
+        return;
+      }
+      for (let i = 0; i < len; i += 1) {
+        this.markSeenId(redirects[i]);
+      }
+    }
+    resolveKey(key, options = {}) {
+      const lookup = this.storeLookup(key);
+      const {required} = options;
+      switch (lookup.state) {
+        case StoreResolveResultState.Stale:
+          this.markStale();
+          break;
+        case StoreResolveResultState.NotPresent:
+          if (required !== false) {
+            this.markMissingLink(key);
+          }
+          break;
+      }
+      this.markRedirectsSeen(lookup);
+      this.markSeenId(lookup.resolvedKey);
+      return lookup;
+    }
+    readStoreLinkWithRef(linkState, fragment, sink, assignmentProperty, required) {
+      const fragmentResult = this.readFragment(this.resolveKey(linkState.key, {required}), fragment);
+      switch (fragmentResult.state) {
+        case FragmentReadResultState.Error:
+          this.markMissing();
+          return;
+        case FragmentReadResultState.Locked:
+          this.markLocked();
+          return;
+        case FragmentReadResultState.Success:
+          this.assignNonScalar(sink, assignmentProperty, fragmentResult.value);
+      }
+    }
+    readObject(key, selection, source, sink) {
+      const sourceValue = source[key];
+      if (selection.nullable === true && sourceValue === null) {
+        this.readScalar(key, source, sink);
+        return;
+      }
+      if (selection.opaque === true) {
+        this.readOpaque(sink, key, sourceValue, selection.required);
+        return;
+      }
+      if (sourceValue === void 0) {
+        if (selection.required === false) {
+          this.checkIfChanged(sourceValue);
+          return;
+        }
+        return this.markMissing();
+      }
+      const sinkValue = isArray(sourceValue) ? [] : {};
+      if (selection.selections === void 0) {
+        this.selectAll(sourceValue, sinkValue);
+      } else {
+        this.traverseSelections(selection, sourceValue, sinkValue);
+      }
+      this.assignNonScalar(sink, key, sinkValue);
+    }
+    checkIfArrayLengthChanged(value) {
+      if (this.snapshotChanged === true) {
+        return;
+      }
+      const {baseSnapshotValue} = this.currentPath;
+      if (isDefined(baseSnapshotValue)) {
+        this.snapshotChanged = baseSnapshotValue.length !== value.length;
+      }
+    }
+    checkIfObjectKeysLengthChanged(keys$1) {
+      if (this.snapshotChanged === true) {
+        return;
+      }
+      const {baseSnapshotValue} = this.currentPath;
+      if (isDefined(baseSnapshotValue)) {
+        this.snapshotChanged = keys$1.length !== keys(baseSnapshotValue).length;
+      }
+    }
+    checkIfChanged(value) {
+      if (this.snapshotChanged === true) {
+        return;
+      }
+      this.snapshotChanged = this.currentPath.baseSnapshotValue !== value;
+    }
+    computeCopyBounds(array, selection) {
+      if (selection.tokenDataKey !== void 0 && selection.pageSize !== void 0) {
+        const pagination2 = this.pagination(selection.tokenDataKey);
+        const startingOffset = pagination2.offsetFor(selection.pageToken);
+        if (startingOffset === void 0) {
+          return;
+        }
+        const endingOffset = pagination2.limitToEnd(startingOffset + selection.pageSize);
+        this.markSeenId(selection.tokenDataKey);
+        return [startingOffset, endingOffset];
+      } else {
+        return [0, array.length];
+      }
+    }
+    readPluralLink(propertyName, selection, record, data) {
+      if (selection.fragment === void 0) {
+        return;
+      }
+      const array = record[propertyName];
+      const [start, end] = this.computeCopyBounds(array, selection) || [-1, -1];
+      if (start < 0) {
+        return this.markMissing();
+      }
+      const sink = data[propertyName] = [];
+      for (let i = start; i < end; i += 1) {
+        this.enterPath(i);
+        this.readSingleLink(i, selection, array, sink, i - start);
+        this.exitPath();
+      }
+      this.checkIfArrayLengthChanged(sink);
+      freeze(sink);
+    }
+    readObjectMap(propertyName, selection, record, data) {
+      const obj = record[propertyName];
+      if (obj === void 0) {
+        if (selection.required === false) {
+          return;
+        }
+        return this.markMissing();
+      }
+      const sink = data[propertyName] = {};
+      const keys$1 = keys(obj);
+      this.checkIfObjectKeysLengthChanged(keys$1);
+      for (let i = 0, len = keys$1.length; i < len; i += 1) {
+        const key = keys$1[i];
+        this.enterPath(key);
+        this.readObject(key, selection, obj, sink);
+        this.exitPath();
+      }
+      freeze(sink);
+    }
+    readLinkMap(propertyName, selection, record, data) {
+      const map = record[propertyName];
+      const keys$1 = keys(map);
+      const sink = {};
+      this.checkIfObjectKeysLengthChanged(keys$1);
+      for (let i = 0, len = keys$1.length; i < len; i += 1) {
+        const key = keys$1[i];
+        this.enterPath(key);
+        this.readSingleLink(key, selection, map, sink);
+        this.exitPath();
+      }
+      this.assignNonScalar(data, propertyName, sink);
+    }
+    readSuccessResolveState(result, fragment) {
+      if (isReaderFragment(fragment)) {
+        const value = fragment.read(result.value, this);
+        freeze(value);
+        return {
+          state: FragmentReadResultState.Success,
+          value
+        };
+      }
+      if (fragment.opaque) {
+        this.checkIfChanged(result.value);
+        return {
+          state: FragmentReadResultState.Success,
+          value: result.value
+        };
+      }
+      if (isFragmentUnionSelection(fragment)) {
+        return this.readFragmentUnion(result, fragment);
+      }
+      const sink = {};
+      this.traverseSelections(fragment, result.value, sink);
+      freeze(sink);
+      return {
+        state: FragmentReadResultState.Success,
+        value: sink
+      };
+    }
+    readFragment(result, fragment) {
+      if (isReaderFragment(fragment) && fragment.synthetic === true) {
+        const value = fragment.read(this);
+        if (value.state === "Error") {
+          return {
+            state: FragmentReadResultState.Error,
+            value: value.value
+          };
+        }
+        freeze(value);
+        return {
+          state: FragmentReadResultState.Success,
+          value
+        };
+      }
+      switch (result.state) {
+        case StoreResolveResultState.NotPresent:
+          return FRAGMENT_READ_RESULT_MISSING;
+        case StoreResolveResultState.Error:
+          return {
+            state: FragmentReadResultState.Error,
+            value: result.value
+          };
+        case StoreResolveResultState.Locked:
+          return {
+            state: FragmentReadResultState.Locked
+          };
+        case StoreResolveResultState.Stale:
+          this.markStale();
+          return this.readSuccessResolveState(result, fragment);
+        case StoreResolveResultState.Found:
+          return this.readSuccessResolveState(result, fragment);
+      }
+    }
+    readPluralObject(propertyName, selection, record, data) {
+      if (selection.selections === void 0) {
+        return;
+      }
+      const array = record[propertyName];
+      const [start, end] = this.computeCopyBounds(array, selection) || [-1, -1];
+      if (start < 0) {
+        return this.markMissing();
+      }
+      const sink = data[propertyName] = [];
+      for (let i = start; i < end; i += 1) {
+        this.enterPath(i);
+        const nextRecord = array[i];
+        if (nextRecord === void 0) {
+          this.markMissing();
+          this.exitPath();
+          return;
+        }
+        const obj = {};
+        this.traverseSelections(selection, nextRecord, obj);
+        push.call(sink, obj);
+        freeze(obj);
+        this.exitPath();
+      }
+      this.checkIfArrayLengthChanged(sink);
+      freeze(sink);
+    }
+    readOpaque(sink, propertyName, value, required) {
+      this.checkIfChanged(value);
+      if (value === void 0 && required === false) {
+        return;
+      }
+      sink[propertyName] = value;
+    }
+    readScalarMap(propertyName, record, data, required) {
+      const obj = record[propertyName];
+      if (obj === void 0) {
+        if (required !== false) {
+          this.markMissing();
+          return;
+        }
+        this.checkIfChanged(void 0);
+        return;
+      }
+      const sink = data[propertyName] = {};
+      const keys$1 = keys(obj);
+      this.checkIfObjectKeysLengthChanged(keys$1);
+      for (let i = 0, len = keys$1.length; i < len; i += 1) {
+        const key = keys$1[i];
+        this.enterPath(key);
+        this.readScalar(key, obj, sink);
+        this.exitPath();
+      }
+      freeze(sink);
+    }
+    readScalarPlural(propertyName, record, data) {
+      const array = record[propertyName];
+      const sink = data[propertyName] = [];
+      if (this.snapshotChanged === true) {
+        push.apply(sink, array);
+        freeze(sink);
+        return;
+      }
+      this.checkIfArrayLengthChanged(array);
+      if (this.snapshotChanged === true) {
+        push.apply(sink, array);
+        freeze(sink);
+        return;
+      }
+      for (let i = 0, len = array.length; i < len; i += 1) {
+        this.enterPath(i);
+        const value = array[i];
+        push.call(sink, value);
+        this.checkIfChanged(value);
+        this.exitPath();
+        if (this.snapshotChanged === true) {
+          push.apply(sink, slice.call(array, i + 1));
+          break;
+        }
+      }
+      freeze(sink);
+    }
+    readScalar(propertyName, record, data, required) {
+      if (!hasOwnProperty.call(record, propertyName)) {
+        if (required !== false) {
+          this.markMissing();
+          return;
+        }
+        this.checkIfChanged(void 0);
+        return;
+      }
+      this.assignScalar(propertyName, data, record[propertyName]);
+    }
+    assignScalar(key, sink, value) {
+      sink[key] = value;
+      this.checkIfChanged(value);
+    }
+    storeLookup(key) {
+      return storeLookup(key, this.timestamp, this.records, this.redirects, this.expirationMap);
+    }
+    selectUnion(selection, storeEntry, discriminatedObject, sink) {
+      const {discriminator} = selection;
+      const discriminatorValue = discriminatedObject[discriminator];
+      const unionSelection = selection.unionSelections[discriminatorValue];
+      const childSelection = {
+        selections: unionSelection.selections,
+        private: unionSelection.private,
+        name: selection.name,
+        kind: selection.kind
+      };
+      this.traverseSelection(childSelection, storeEntry, sink);
+    }
+    selectObjectUnion(selection, source, sink) {
+      const {name: propertyName} = selection;
+      const object = source[propertyName];
+      if (object === void 0) {
+        this.markMissing();
+        return;
+      }
+      if (selection.nullable === true && object === null) {
+        this.readScalar(propertyName, source, sink);
+        return;
+      }
+      this.selectUnion(selection, source, object, sink);
+    }
+    traverseSelection(selection, record, data) {
+      const {variables} = this;
+      const key = getStorageKey(selection, variables);
+      if (isUnionObjectSelection(selection)) {
+        this.selectObjectUnion(selection, record, data);
+        return;
+      }
+      if (selection.kind === "Link") {
+        if (selection.plural === true) {
+          this.readPluralLink(key, selection, record, data);
+        } else if (selection.map === true) {
+          this.readLinkMap(key, selection, record, data);
+        } else {
+          this.readSingleLink(key, selection, record, data);
+        }
+      } else if (selection.kind === "Scalar") {
+        if (selection.map === true) {
+          this.readScalarMap(key, record, data, selection.required !== false);
+        } else if (selection.plural === true) {
+          this.readScalarPlural(key, record, data);
+        } else {
+          this.readScalar(key, record, data, selection.required);
+        }
+      } else if (selection.kind === "Object") {
+        if (selection.map === true) {
+          this.readObjectMap(key, selection, record, data);
+        } else if (selection.plural === true) {
+          this.readPluralObject(key, selection, record, data);
+        } else {
+          this.readObject(key, selection, record, data);
+        }
+      } else if (selection.kind === "Custom") {
+        selection.reader(key, selection, record, data, variables, this);
+      }
+    }
+    traverseSelections(node, record, data) {
+      const {selections} = node;
+      if (selections === void 0) {
+        this.selectAll(record, data);
+        return;
+      }
+      const {length: len} = selections;
+      for (let i = 0; i < len; i += 1) {
+        const selection = selections[i];
+        this.enterPath(selection.name);
+        this.traverseSelection(selection, record, data);
+        this.exitPath();
+      }
+    }
+    isRebuilding() {
+      return this.baseSnapshot !== void 0;
+    }
+    getIsDataMissing() {
+      return this.isMissingData;
+    }
+    getTimeStamp() {
+      return this.timestamp;
+    }
+    markSeenId(key) {
+      this.seenIds[key] = true;
+    }
+  };
+  var resolvedPromise = Promise.resolve();
+  function throwNext(error) {
+    setTimeout(() => {
+      throw error;
+    }, 0);
+  }
+  function resolveImmediate(callback) {
+    resolvedPromise.then(callback).catch(throwNext);
+  }
+  var StoreErrorStatus;
+  (function(StoreErrorStatus2) {
+    StoreErrorStatus2[StoreErrorStatus2["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
+  })(StoreErrorStatus || (StoreErrorStatus = {}));
+  var StoreRecordType;
+  (function(StoreRecordType2) {
+    StoreRecordType2["Error"] = "error";
+    StoreRecordType2["Locked"] = "locked";
+  })(StoreRecordType || (StoreRecordType = {}));
+  function isStoreRecordError(storeRecord) {
+    return storeRecord.__type === StoreRecordType.Error;
+  }
+  function isStoreRecordLocked(storeRecord) {
+    return storeRecord.__type === StoreRecordType.Locked;
+  }
+  function hasOverlappingIds(snapshot, visitedIds) {
+    const {length: len} = visitedIds;
+    const {seenRecords} = snapshot;
+    for (let i = 0; i < len; i += 1) {
+      const id = visitedIds[i];
+      if (seenRecords[id] || id === snapshot.recordId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function isNonPendingSnapshotWithNoOverlappingIds(snapshot, visitedIds) {
+    return isPendingSnapshot(snapshot) === false && hasOverlappingIds(snapshot, visitedIds) === false;
+  }
+  function isPendingSnapshotWithNoOverlappingIds(snapshot, visitedIds, refreshedIds) {
+    return isPendingSnapshot(snapshot) === true && hasOverlappingIds(snapshot, refreshedIds) === false && hasOverlappingIds(snapshot, visitedIds) === false;
+  }
+  function getMatchingIds(prefix, visitedIds) {
+    const matchingIds = [];
+    for (let i = 0, len = visitedIds.length; i < len; i++) {
+      const visitedId = visitedIds[i];
+      if (visitedId.indexOf(prefix) === 0) {
+        push.call(matchingIds, visitedId);
+      }
+    }
+    return matchingIds;
+  }
+  var OVERRIDE_TTL_KEY_SEPARATOR = "::";
+  var OVERRIDE_TTL_DEFAULT_NAMESPACE = "$$Luvio$$";
+  var OVERRIDE_TTL_DEFAULT_REPRESENTATION_NAME = "default";
+  function getTTLOverrideKey(namespace, representationName) {
+    return `${namespace}${OVERRIDE_TTL_KEY_SEPARATOR}${representationName}`;
+  }
+  var Store = class {
+    constructor(options = {}) {
+      this.recordExpirations = create(null);
+      this.records = create(null);
+      this.metadata = create(null);
+      this.snapshotSubscriptions = [];
+      this.watchSubscriptions = [];
+      this.visitedIds = create(null);
+      this.refreshedIds = create(null);
+      this.insertedIds = create(null);
+      this.redirectKeys = create(null);
+      this.reverseRedirectKeys = create(null);
+      this.retainedIds = create(null);
+      this.trimTask = null;
+      this.ttlOverrides = create(null);
+      this.scheduler = options.scheduler || resolveImmediate;
+    }
+    markVisited(canonicalKey) {
+      const {visitedIds, reverseRedirectKeys} = this;
+      visitedIds[canonicalKey] = true;
+      let redirectKey = reverseRedirectKeys[canonicalKey];
+      while (redirectKey !== void 0) {
+        visitedIds[redirectKey] = true;
+        redirectKey = reverseRedirectKeys[redirectKey];
+      }
+    }
+    markRefreshed(canonicalKey) {
+      const {refreshedIds, reverseRedirectKeys} = this;
+      refreshedIds[canonicalKey] = true;
+      let redirectKey = reverseRedirectKeys[canonicalKey];
+      while (redirectKey !== void 0) {
+        refreshedIds[redirectKey] = true;
+        redirectKey = reverseRedirectKeys[redirectKey];
+      }
+    }
+    reset() {
+      this.recordExpirations = create(null);
+      this.records = create(null);
+      this.snapshotSubscriptions = [];
+      this.watchSubscriptions = [];
+      this.visitedIds = create(null);
+      this.refreshedIds = create(null);
+      this.insertedIds = create(null);
+      this.redirectKeys = create(null);
+      this.reverseRedirectKeys = create(null);
+      this.retainedIds = create(null);
+      this.ttlOverrides = create(null);
+      this.trimTask = null;
+      this.metadata = create(null);
+    }
+    redirect(key, canonicalKey) {
+      const {redirectKeys, reverseRedirectKeys} = this;
+      if (key === canonicalKey) {
+        throw new Error("cannot redirect a key to itself");
+      }
+      if (reverseRedirectKeys[canonicalKey] !== void 0) {
+        throw new Error("cannot have multiple redirects keys point to the same canonical key");
+      }
+      if (redirectKeys[canonicalKey] !== void 0) {
+        throw new Error("the canonical key must be terminal and cannot already be part of a redirect chain");
+      }
+      redirectKeys[key] = canonicalKey;
+      reverseRedirectKeys[canonicalKey] = key;
+      delete this.records[key];
+      this.visitedIds[key] = true;
+    }
+    publish(recordId, record) {
+      const {records, insertedIds} = this;
+      const canonicalKey = this.getCanonicalRecordId(recordId);
+      if (hasOwnProperty.call(records, canonicalKey) === false) {
+        insertedIds[canonicalKey] = true;
+      }
+      records[canonicalKey] = record;
+      this.markVisited(canonicalKey);
+    }
+    getCanonicalRecordId(recordId) {
+      let canonicalKey = recordId;
+      const {redirectKeys} = this;
+      while (redirectKeys[canonicalKey]) {
+        canonicalKey = redirectKeys[canonicalKey];
+      }
+      return canonicalKey;
+    }
+    setExpiration(recordId, expiration, staleExpiration) {
+      const canonicalKey = this.getCanonicalRecordId(recordId);
+      this.recordExpirations[canonicalKey] = {
+        fresh: expiration,
+        stale: staleExpiration === void 0 ? expiration : staleExpiration
+      };
+      this.markRefreshed(canonicalKey);
+    }
+    updateSubscriptionSnapshot(subscription, newSnapshot) {
+      const {snapshot: oldSnapshot} = subscription;
+      if (oldSnapshot === newSnapshot) {
+        return;
+      }
+      subscription.snapshot = newSnapshot;
+      if (!isErrorSnapshot(newSnapshot)) {
+        this.retainSnapshotIds(newSnapshot);
+      }
+      if (!isErrorSnapshot(oldSnapshot)) {
+        this.releaseSnapshotIds(oldSnapshot);
+      }
+    }
+    emitOrRefreshRebuiltSnapshot(rebuiltSnapshot, subscription, snapshotAvailable) {
+      const {snapshot, callback} = subscription;
+      if (isPendingSnapshot(rebuiltSnapshot)) {
+        if (isPendingSnapshot(snapshot)) {
+          this.updateSubscriptionSnapshot(subscription, rebuiltSnapshot);
+        }
+        return;
+      }
+      this.updateSubscriptionSnapshot(subscription, rebuiltSnapshot);
+      if (snapshotAvailable(rebuiltSnapshot) && rebuiltSnapshot !== snapshot) {
+        callback(rebuiltSnapshot);
+      } else if (isUnfulfilledSnapshot(rebuiltSnapshot)) {
+        const {refresh} = rebuiltSnapshot;
+        if (refresh !== void 0) {
+          refresh.resolve(refresh.config);
+        }
+      }
+    }
+    broadcast(rebuildSnapshot, snapshotAvailable) {
+      const {snapshotSubscriptions, watchSubscriptions, visitedIds, refreshedIds, insertedIds, records, redirectKeys} = this;
+      const allVisitedIds = keys(visitedIds);
+      const allRefreshedIds = keys(refreshedIds);
+      if (allVisitedIds.length === 0 && allRefreshedIds.length === 0) {
+        return;
+      }
+      for (let i = 0, len = snapshotSubscriptions.length; i < len; i++) {
+        const subscription = snapshotSubscriptions[i];
+        const {snapshot} = subscription;
+        if (isErrorSnapshot(snapshot) || isNonPendingSnapshotWithNoOverlappingIds(snapshot, allVisitedIds) || isPendingSnapshotWithNoOverlappingIds(snapshot, allVisitedIds, allRefreshedIds)) {
+          continue;
+        }
+        const updatedSnapshot = rebuildSnapshot(snapshot, records, {}, redirectKeys, (asyncAvailableSnapshot) => {
+          this.emitOrRefreshRebuiltSnapshot(asyncAvailableSnapshot, subscription, snapshotAvailable);
+        });
+        this.emitOrRefreshRebuiltSnapshot(updatedSnapshot, subscription, snapshotAvailable);
+      }
+      for (let i = 0, len = watchSubscriptions.length; i < len; i++) {
+        const {prefix, callback} = watchSubscriptions[i];
+        const matchingIds = getMatchingIds(prefix, allVisitedIds);
+        if (matchingIds.length > 0) {
+          const watchCallbackEntries = [];
+          for (let i2 = 0, len2 = matchingIds.length; i2 < len2; i2++) {
+            const id = matchingIds[i2];
+            const inserted = insertedIds[id] || false;
+            push.call(watchCallbackEntries, {id, inserted});
+          }
+          callback(watchCallbackEntries);
+        }
+      }
+      this.visitedIds = create(null);
+      this.refreshedIds = create(null);
+      this.insertedIds = create(null);
+    }
+    broadcastNonCachedSnapshot(recordId, errorSnapshot) {
+      const {snapshotSubscriptions} = this;
+      for (let i = 0, len = snapshotSubscriptions.length; i < len; i++) {
+        const subscription = snapshotSubscriptions[i];
+        const {snapshot, callback} = subscription;
+        if (isPendingSnapshot(snapshot) && snapshot.recordId === recordId) {
+          subscription.snapshot = errorSnapshot;
+          callback(errorSnapshot);
+        }
+      }
+    }
+    lookup(selector, createSnapshot, refresh) {
+      const {records, recordExpirations, redirectKeys} = this;
+      return createSnapshot(records, recordExpirations, redirectKeys, selector, refresh);
+    }
+    subscribe(snapshot, callback) {
+      const subscription = {snapshot, callback};
+      this.snapshotSubscriptions = [...this.snapshotSubscriptions, subscription];
+      if (!isErrorSnapshot(snapshot)) {
+        this.retainSnapshotIds(snapshot);
+      }
+      return () => {
+        const {snapshotSubscriptions} = this;
+        const index = indexOf.call(snapshotSubscriptions, subscription);
+        if (index > -1) {
+          this.snapshotSubscriptions = [
+            ...slice.call(snapshotSubscriptions, 0, index),
+            ...slice.call(snapshotSubscriptions, index + 1)
+          ];
+          const {snapshot: snapshot2} = subscription;
+          if (!isErrorSnapshot(snapshot2)) {
+            this.releaseSnapshotIds(snapshot2);
+          }
+        }
+      };
+    }
+    increaseRetentionCount(key) {
+      const count = this.retainedIds[key];
+      this.retainedIds[key] = count === void 0 ? 1 : count + 1;
+    }
+    decreaseRetentionCount(key) {
+      const count = this.retainedIds[key];
+      if (count === 1) {
+        return delete this.retainedIds[key];
+      } else if (count === void 0) {
+        return false;
+      } else {
+        this.retainedIds[key] = count - 1;
+      }
+      return false;
+    }
+    release(keys2) {
+      const keysLength = keys2.length;
+      let shouldScheduleTrim = false;
+      for (let i = 0; i < keysLength; i++) {
+        const key = keys2[i];
+        const result = this.decreaseRetentionCount(key);
+        if (shouldScheduleTrim !== true) {
+          shouldScheduleTrim = result;
+        }
+      }
+      if (shouldScheduleTrim === true) {
+        this.scheduleTrim();
+      }
+    }
+    retain(keys2) {
+      const keysLength = keys2.length;
+      for (let i = 0; i < keysLength; i++) {
+        const key = keys2[i];
+        this.increaseRetentionCount(key);
+      }
+      return () => {
+        this.release(keys2);
+      };
+    }
+    retainSnapshotIds(snapshot) {
+      const {recordId, seenRecords} = snapshot;
+      const snapshotRetainedIds = seenRecords === void 0 ? [recordId] : [recordId, ...keys(seenRecords)];
+      this.retain(snapshotRetainedIds);
+    }
+    releaseSnapshotIds(snapshot) {
+      const {recordId, seenRecords} = snapshot;
+      const snapshotReleaseIds = seenRecords === void 0 ? [recordId] : [recordId, ...keys(seenRecords)];
+      this.release(snapshotReleaseIds);
+    }
+    scheduleTrim() {
+      if (this.trimTask === null) {
+        this.trimTask = () => {
+          const {records, retainedIds, recordExpirations} = this;
+          const recordKeys = keys(records);
+          const recordKeysLength = recordKeys.length;
+          const now = Date.now();
+          let deallocCount = 0;
+          for (let i = 0; i < recordKeysLength; i++) {
+            const recordKey = recordKeys[i];
+            const recordExpiration = recordExpirations[recordKey];
+            if (retainedIds[recordKey] !== void 0 || recordExpiration === void 0 || recordExpiration !== void 0 && recordExpiration.fresh >= now) {
+              continue;
+            }
+            this.dealloc(recordKey);
+            deallocCount += 1;
+          }
+          this.trimTask = null;
+          return deallocCount;
+        };
+        this.scheduler(this.trimTask);
+      }
+    }
+    watch(prefix, callback) {
+      const subscription = {prefix, callback};
+      this.watchSubscriptions = [...this.watchSubscriptions, subscription];
+      return () => {
+        const {watchSubscriptions} = this;
+        const index = indexOf.call(watchSubscriptions, subscription);
+        this.watchSubscriptions = [
+          ...slice.call(watchSubscriptions, 0, index),
+          ...slice.call(watchSubscriptions, index + 1)
+        ];
+      };
+    }
+    evict(key) {
+      const canonicalKey = this.getCanonicalRecordId(key);
+      delete this.records[canonicalKey];
+      this.visitedIds[canonicalKey] = true;
+      let redirectKey = this.reverseRedirectKeys[canonicalKey];
+      while (redirectKey !== void 0) {
+        this.visitedIds[redirectKey] = true;
+        redirectKey = this.reverseRedirectKeys[redirectKey];
+      }
+    }
+    dealloc(key) {
+      const canonicalKey = this.getCanonicalRecordId(key);
+      delete this.records[canonicalKey];
+    }
+    lock(recordId) {
+      const canonicalKey = this.getCanonicalRecordId(recordId);
+      this.records[canonicalKey] = {__type: "locked"};
+    }
+    unlock(recordId) {
+      const canonicalKey = this.getCanonicalRecordId(recordId);
+      const record = this.records[canonicalKey];
+      if (record !== void 0 && isStoreRecordLocked(record)) {
+        this.dealloc(canonicalKey);
+      }
+    }
+    createReader(records, recordExpirations, redirects, variables, refresh, baseSnapshot) {
+      return new Reader(records, recordExpirations, redirects, variables, refresh, baseSnapshot);
+    }
+    publishMetadata(key, storeMetadata) {
+      const {namespace, representationName, ingestionTimestamp} = storeMetadata;
+      const ttlOverrideKey = getTTLOverrideKey(namespace, representationName);
+      const ttlOverride = this.ttlOverrides[ttlOverrideKey];
+      if (ttlOverride !== void 0) {
+        const newExpiration = ingestionTimestamp + ttlOverride;
+        const metaDataOverride = {
+          expirationTimestamp: newExpiration,
+          ingestionTimestamp,
+          namespace,
+          representationName
+        };
+        this.metadata[key] = metaDataOverride;
+      } else {
+        this.metadata[key] = storeMetadata;
+      }
+    }
+    setTTLOverride(namespace, representationName, ttl) {
+      this.ttlOverrides[getTTLOverrideKey(namespace, representationName)] = ttl;
+    }
+    setDefaultTTLOverride(ttl) {
+      this.setTTLOverride(OVERRIDE_TTL_DEFAULT_NAMESPACE, OVERRIDE_TTL_DEFAULT_REPRESENTATION_NAME, ttl);
+    }
+  };
+  function isNodeLink(node) {
+    return typeof node === "object" && node !== null && hasOwnProperty.call(node, "__ref");
+  }
+  var GraphNodeType;
+  (function(GraphNodeType2) {
+    GraphNodeType2["Link"] = "Link";
+    GraphNodeType2["Node"] = "Node";
+    GraphNodeType2["Error"] = "Error";
+    GraphNodeType2["Locked"] = "Locked";
+  })(GraphNodeType || (GraphNodeType = {}));
+  var GraphNodeError = class {
+    constructor(store, data) {
+      this.type = GraphNodeType.Error;
+      this.store = store;
+      this.data = data;
+    }
+    retrieve() {
+      return this.data;
+    }
+  };
+  var GraphNodeLocked = class {
+    constructor(store, data) {
+      this.type = GraphNodeType.Locked;
+      this.store = store;
+      this.data = data;
+    }
+    retrieve() {
+      return this.data;
+    }
+  };
+  function followLink(store, key) {
+    const canonicalKey = store.getCanonicalRecordId(key);
+    return store.records[canonicalKey];
+  }
+  var GraphLink = class {
+    constructor(store, data) {
+      this.type = GraphNodeType.Link;
+      this.store = store;
+      this.data = data;
+    }
+    isPending() {
+      return this.data.pending === true;
+    }
+    isMissing() {
+      return this.data.isMissing === true;
+    }
+    follow() {
+      const {__ref} = this.data;
+      if (__ref === void 0) {
+        return null;
+      }
+      const linked = followLink(this.store, __ref);
+      if (linked === null || linked === void 0) {
+        return null;
+      }
+      if (isStoreRecordError(linked)) {
+        return new GraphNodeError(this.store, linked);
+      }
+      if (isStoreRecordLocked(linked)) {
+        return new GraphNodeLocked(this.store, linked);
+      }
+      return new GraphNode(this.store, linked);
+    }
+    linkData() {
+      return this.data.data;
+    }
+    writeLinkData(data) {
+      this.data.data = data;
+    }
+  };
+  var GraphNode = class {
+    constructor(store, data) {
+      this.type = GraphNodeType.Node;
+      this.store = store;
+      this.data = data;
+    }
+    object(propertyName) {
+      const value = this.data[propertyName];
+      if (isNodeLink(value)) {
+        throw new Error(`Cannot walk to path ${propertyName}. "${propertyName}" is a link: "${value}"`);
+      }
+      if (typeof value !== "object" || value === null) {
+        throw new Error(`Cannot walk to path ${propertyName}. "${propertyName}" is a scalar: "${value}"`);
+      }
+      return new GraphNode(this.store, value);
+    }
+    link(propertyName) {
+      const value = this.data[propertyName];
+      if (!isNodeLink(value)) {
+        throw new Error(`Cannot walk to link ${propertyName}. "${propertyName}" is not a link: "${value}"`);
+      }
+      return new GraphLink(this.store, value);
+    }
+    scalar(propertyName) {
+      const value = this.data[propertyName];
+      if (typeof value === "object" && value !== null) {
+        throw new Error(`Cannot return value at path ${propertyName}. ${propertyName} is not a scalar.`);
+      }
+      return value;
+    }
+    keys() {
+      return keys(this.data);
+    }
+    isScalar(propertyName) {
+      if (this.data === void 0) {
+        return true;
+      }
+      const value = this.data[propertyName];
+      return typeof value !== "object" || value === null;
+    }
+    write(propertyName, value) {
+      this.data[propertyName] = value;
+    }
+    isUndefined(propertyName) {
+      return this.data[propertyName] === void 0;
+    }
+    retrieve() {
+      return this.data;
+    }
+  };
+  exports.HttpStatusCode = void 0;
+  (function(HttpStatusCode2) {
+    HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+    HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+    HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+    HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+    HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+    HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode2[HttpStatusCode2["ServerError"] = 500] = "ServerError";
+  })(exports.HttpStatusCode || (exports.HttpStatusCode = {}));
+  var Environment = class {
+    constructor(store, networkAdapter) {
+      this.store = store;
+      this.networkAdapter = networkAdapter;
+      this.adapterContextMap = create(null);
+      this.createSnapshot = this.createSnapshot.bind(this);
+      this.rebuildSnapshot = this.rebuildSnapshot.bind(this);
+    }
+    dispatchResourceRequest(request) {
+      return this.networkAdapter(request);
+    }
+    isErrorCacheable(errorSnapshot) {
+      const {error} = errorSnapshot;
+      const {status} = error;
+      return status === exports.HttpStatusCode.NotFound;
+    }
+    resolvePendingSnapshot(snapshot) {
+      return new Promise((resolve) => {
+        let unsubscribe;
+        unsubscribe = this.storeSubscribe(snapshot, (resolvedSnapshot) => {
+          if (unsubscribe !== void 0) {
+            unsubscribe();
+          }
+          resolve(resolvedSnapshot);
+        });
+      });
+    }
+    resolveSnapshot(snapshot, refresh) {
+      if (snapshot.state === "Pending") {
+        return this.resolvePendingSnapshot(snapshot);
+      }
+      const {resolve, config} = refresh;
+      return resolve(config).then((refreshedSnapshot) => {
+        if (refreshedSnapshot.state === "Pending") {
+          const {records, redirectKeys} = this.store;
+          const rebuilt = this.rebuildSnapshot(refreshedSnapshot, records, {}, redirectKeys, () => {
+          });
+          if (rebuilt.state === "Pending") {
+            return this.resolvePendingSnapshot(refreshedSnapshot);
+          }
+          return rebuilt;
+        }
+        return refreshedSnapshot;
+      });
+    }
+    storeIngest(key, ingest, response, luvio) {
+      const state = {
+        result: {
+          type: "success"
+        }
+      };
+      if (ingest !== null) {
+        ingest(response, {
+          fullPath: key,
+          parent: null,
+          propertyName: null,
+          state
+        }, luvio, this.store, Date.now());
+      }
+      return state.result;
+    }
+    storeIngestError(key, errorSnapshot, ttl) {
+      const {error} = errorSnapshot;
+      if (this.isErrorCacheable(errorSnapshot)) {
+        const entry = {
+          __type: StoreRecordType.Error,
+          status: StoreErrorStatus.RESOURCE_NOT_FOUND,
+          error
+        };
+        freeze(entry);
+        this.storePublish(key, entry);
+        if (ttl !== void 0) {
+          this.storeSetExpiration(key, Date.now() + ttl);
+        }
+        return;
+      }
+      this.store.broadcastNonCachedSnapshot(key, errorSnapshot);
+    }
+    storePublish(key, data) {
+      this.store.publish(key, data);
+    }
+    storeRedirect(existingKey, redirectKey) {
+      this.store.redirect(existingKey, redirectKey);
+    }
+    storeGetCanonicalKey(key) {
+      return this.store.getCanonicalRecordId(key);
+    }
+    storeBroadcast(rebuildSnapshot, snapshotAvailable) {
+      this.store.broadcast(rebuildSnapshot, snapshotAvailable);
+    }
+    storeSubscribe(snapshot, callback) {
+      return this.store.subscribe(snapshot, callback);
+    }
+    storeWatch(prefix, callback) {
+      return this.store.watch(prefix, callback);
+    }
+    storeLookup(sel, createSnapshot, refresh) {
+      return this.store.lookup(sel, createSnapshot, refresh);
+    }
+    storeEvict(key) {
+      this.store.evict(key);
+    }
+    storeLock(key) {
+      this.store.lock(key);
+    }
+    storeUnlock(key) {
+      this.store.unlock(key);
+    }
+    storeDealloc(key) {
+      this.store.dealloc(key);
+    }
+    storeReset() {
+      this.store.reset();
+    }
+    storeRetain(keys2) {
+      return this.store.retain(keys2);
+    }
+    snapshotAvailable(snapshot) {
+      return isFulfilledSnapshot(snapshot) || isErrorSnapshot(snapshot);
+    }
+    storeSetExpiration(recordId, expiration, staleExpiration) {
+      this.store.setExpiration(recordId, expiration, staleExpiration);
+    }
+    storeCreateReader(records, recordExpirations, redirects, selector, refresh, baseSnapshot) {
+      return this.store.createReader(records, recordExpirations, redirects, selector.variables, refresh, baseSnapshot);
+    }
+    createSnapshot(records, recordExpirations, redirects, selector, refresh) {
+      return this.store.createReader(records, recordExpirations, redirects, selector.variables, refresh).read(selector);
+    }
+    rebuildSnapshot(snapshot, records, recordExpirations, redirects, _onAsyncRebuild) {
+      return this.store.createReader(records, recordExpirations, redirects, snapshot.variables, snapshot.refresh, snapshot).read(snapshot.select);
+    }
+    getStoreRecords() {
+      return this.store.records;
+    }
+    getStoreVisitedIds() {
+      return this.store.visitedIds;
+    }
+    getStoreRecordExpirations() {
+      return this.store.recordExpirations;
+    }
+    getStoreRedirectKeys() {
+      return this.store.redirectKeys;
+    }
+    getNode(key) {
+      const canonicalKey = this.store.getCanonicalRecordId(key);
+      const value = this.store.records[canonicalKey];
+      if (value === void 0) {
+        return null;
+      }
+      return this.wrapNormalizedGraphNode(value);
+    }
+    wrapNormalizedGraphNode(normalized) {
+      if (normalized === null) {
+        return null;
+      }
+      if (isStoreRecordError(normalized)) {
+        return new GraphNodeError(this.store, normalized);
+      }
+      if (isStoreRecordLocked(normalized)) {
+        return new GraphNodeLocked(this.store, normalized);
+      }
+      return new GraphNode(this.store, normalized);
+    }
+    withContext(adapter, options = {}) {
+      const {contextId, onContextLoaded} = options;
+      if (contextId !== void 0 && this.adapterContextMap[contextId] === void 0) {
+        this.adapterContextMap[contextId] = create(null);
+      }
+      const contextStore = contextId !== void 0 ? this.adapterContextMap[contextId] : create(null);
+      const context = {
+        set(key, value) {
+          contextStore[key] = value;
+        },
+        get(key) {
+          return contextStore[key];
+        }
+      };
+      if (onContextLoaded === void 0) {
+        return (config) => {
+          return adapter(config, context);
+        };
+      }
+      let firstRun = true;
+      const hookAsPromise = onContextLoaded(context);
+      return (config) => {
+        if (firstRun) {
+          return hookAsPromise.then(() => {
+            firstRun = false;
+            return adapter(config, context);
+          });
+        }
+        return adapter(config, context);
+      };
+    }
+    publishStoreMetadata(key, storeMetadata) {
+      this.store.publishMetadata(key, storeMetadata);
+    }
+    storeSetTTLOverride(namespace, representationName, ttl) {
+      this.store.setTTLOverride(namespace, representationName, ttl);
+    }
+    storeSetDefaultTTLOverride(ttl) {
+      this.store.setDefaultTTLOverride(ttl);
+    }
+  };
+  var Luvio = class {
+    constructor(environment, options = {}) {
+      this.environment = environment;
+      this.options = options;
+    }
+    pagination(key) {
+      const records = this.environment.getStoreRecords();
+      let data = records[key];
+      data = data && {...data};
+      return pagination(data, (pd) => {
+        this.storePublish(key, pd);
+      });
+    }
+    storePublish(key, data) {
+      this.environment.storePublish(key, data);
+    }
+    storeRedirect(existingKey, canonicalKey) {
+      this.environment.storeRedirect(existingKey, canonicalKey);
+    }
+    storeRetain(keys2) {
+      return this.environment.storeRetain(keys2);
+    }
+    storeGetCanonicalKey(key) {
+      return this.environment.storeGetCanonicalKey(key);
+    }
+    storeBroadcast() {
+      this.environment.storeBroadcast(this.environment.rebuildSnapshot, this.environment.snapshotAvailable);
+    }
+    storeIngest(key, ingest, response) {
+      return this.environment.storeIngest(key, ingest, response, this);
+    }
+    storeIngestError(key, errorSnapshot, ttl) {
+      return this.environment.storeIngestError(key, errorSnapshot, ttl);
+    }
+    storeSubscribe(snapshot, callback) {
+      return this.environment.storeSubscribe(snapshot, callback);
+    }
+    storeWatch(prefix, callback) {
+      return this.environment.storeWatch(prefix, callback);
+    }
+    storeLookup(sel, refresh) {
+      return this.environment.storeLookup(sel, this.environment.createSnapshot, refresh);
+    }
+    storeEvict(key) {
+      this.environment.storeEvict(key);
+    }
+    storeSetExpiration(recordId, expiration, staleExpiration) {
+      this.environment.storeSetExpiration(recordId, expiration, staleExpiration);
+    }
+    createSnapshot(records, recordExpirations, redirects, selector, refresh) {
+      return this.environment.createSnapshot(records, recordExpirations, redirects, selector, refresh);
+    }
+    errorSnapshot(error, refresh) {
+      return createErrorSnapshot(error, refresh);
+    }
+    dispatchResourceRequest(resourceRequest, overrides) {
+      let mergedResourceRequest = resourceRequest;
+      if (overrides !== void 0) {
+        mergedResourceRequest = {
+          ...resourceRequest,
+          headers: {
+            ...resourceRequest.headers,
+            ...overrides.headers
+          }
+        };
+      }
+      return this.environment.dispatchResourceRequest(mergedResourceRequest);
+    }
+    resolveSnapshot(snapshot, refresh) {
+      return this.environment.resolveSnapshot(snapshot, refresh);
+    }
+    refreshSnapshot(snapshot) {
+      const {refresh} = snapshot;
+      if (refresh !== void 0) {
+        const {config, resolve} = refresh;
+        return resolve(config);
+      }
+      throw new Error("Snapshot is not refreshable");
+    }
+    getNode(key) {
+      return this.environment.getNode(key);
+    }
+    wrapNormalizedGraphNode(normalized) {
+      return this.environment.wrapNormalizedGraphNode(normalized);
+    }
+    instrument(paramsBuilder) {
+      const {instrument} = this.options;
+      if (instrument) {
+        instrument(paramsBuilder());
+      }
+    }
+    snapshotAvailable(snapshot) {
+      return this.environment.snapshotAvailable(snapshot);
+    }
+    withContext(adapter, options = {}) {
+      return this.environment.withContext(adapter, options);
+    }
+    resolvePendingSnapshot(snapshot) {
+      return this.environment.resolvePendingSnapshot(snapshot);
+    }
+    publishStoreMetadata(key, storeMetadata) {
+      return this.environment.publishStoreMetadata(key, storeMetadata);
+    }
+    storeSetTTLOverride(namespace, representationName, ttl) {
+      this.environment.storeSetTTLOverride(namespace, representationName, ttl);
+    }
+    storeSetDefaultTTLOverride(ttl) {
+      this.environment.storeSetDefaultTTLOverride(ttl);
+    }
+  };
+  exports.Environment = Environment;
+  exports.GraphNode = GraphNode;
+  exports.Luvio = Luvio;
+  exports.Reader = Reader;
+  exports.Store = Store;
+  Object.defineProperty(exports, "__esModule", {value: true});
+});