@ailaw/venus 0.1.0

package/dist/venus.es.js

@@ -0,0 +1,4023 @@
+import Vue from "vue";
+import { Select, Modal, Form, Input, Checkbox, Divider, Button } from "ant-design-vue";
+import { useQuery, useResult, useMutation } from "@vue/apollo-composable";
+var index$1 = "";
+var toString = function(x) {
+  return Object.prototype.toString.call(x);
+};
+function isNative(Ctor) {
+  return typeof Ctor === "function" && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== "undefined" && isNative(Symbol) && typeof Reflect !== "undefined" && isNative(Reflect.ownKeys);
+var noopFn = function(_) {
+  return _;
+};
+function proxy(target, key, _a) {
+  var get2 = _a.get, set2 = _a.set;
+  Object.defineProperty(target, key, {
+    enumerable: true,
+    configurable: true,
+    get: get2 || noopFn,
+    set: set2 || noopFn
+  });
+}
+function def(obj, key, val, enumerable) {
+  Object.defineProperty(obj, key, {
+    value: val,
+    enumerable: !!enumerable,
+    writable: true,
+    configurable: true
+  });
+}
+function hasOwn(obj, key) {
+  return Object.hasOwnProperty.call(obj, key);
+}
+function assert(condition, msg) {
+  if (!condition) {
+    throw new Error("[vue-composition-api] " + msg);
+  }
+}
+function isArray(x) {
+  return Array.isArray(x);
+}
+var objectToString = Object.prototype.toString;
+var toTypeString = function(value) {
+  return objectToString.call(value);
+};
+var isMap = function(val) {
+  return toTypeString(val) === "[object Map]";
+};
+var isSet = function(val) {
+  return toTypeString(val) === "[object Set]";
+};
+var MAX_VALID_ARRAY_LENGTH = 4294967295;
+function isValidArrayIndex(val) {
+  var n = parseFloat(String(val));
+  return n >= 0 && Math.floor(n) === n && isFinite(val) && n <= MAX_VALID_ARRAY_LENGTH;
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject(x) {
+  return toString(x) === "[object Object]";
+}
+function isFunction(x) {
+  return typeof x === "function";
+}
+function logError(err, vm, info) {
+  if (typeof window !== "undefined" && typeof console !== "undefined") {
+    console.error(err);
+  } else {
+    throw err;
+  }
+}
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      if (Object.prototype.hasOwnProperty.call(b2, p))
+        d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m)
+    return m.call(o);
+  if (o && typeof o.length === "number")
+    return {
+      next: function() {
+        if (o && i >= o.length)
+          o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+}
+var activeEffectScope;
+var effectScopeStack = [];
+var EffectScopeImpl = function() {
+  function EffectScopeImpl2(vm) {
+    this.active = true;
+    this.effects = [];
+    this.cleanups = [];
+    this.vm = vm;
+  }
+  EffectScopeImpl2.prototype.run = function(fn) {
+    if (this.active) {
+      try {
+        this.on();
+        return fn();
+      } finally {
+        this.off();
+      }
+    }
+    return;
+  };
+  EffectScopeImpl2.prototype.on = function() {
+    if (this.active) {
+      effectScopeStack.push(this);
+      activeEffectScope = this;
+    }
+  };
+  EffectScopeImpl2.prototype.off = function() {
+    if (this.active) {
+      effectScopeStack.pop();
+      activeEffectScope = effectScopeStack[effectScopeStack.length - 1];
+    }
+  };
+  EffectScopeImpl2.prototype.stop = function() {
+    if (this.active) {
+      this.vm.$destroy();
+      this.effects.forEach(function(e) {
+        return e.stop();
+      });
+      this.cleanups.forEach(function(cleanup) {
+        return cleanup();
+      });
+      this.active = false;
+    }
+  };
+  return EffectScopeImpl2;
+}();
+(function(_super) {
+  __extends(EffectScope, _super);
+  function EffectScope(detached) {
+    if (detached === void 0) {
+      detached = false;
+    }
+    var _this = this;
+    var vm = void 0;
+    withCurrentInstanceTrackingDisabled(function() {
+      vm = defineComponentInstance(getVueConstructor());
+    });
+    _this = _super.call(this, vm) || this;
+    if (!detached) {
+      recordEffectScope(_this);
+    }
+    return _this;
+  }
+  return EffectScope;
+})(EffectScopeImpl);
+function recordEffectScope(effect, scope) {
+  var _a;
+  scope = scope || activeEffectScope;
+  if (scope && scope.active) {
+    scope.effects.push(effect);
+    return;
+  }
+  var vm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;
+  vm && vm.$on("hook:destroyed", function() {
+    return effect.stop();
+  });
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+function getCurrentScopeVM() {
+  var _a, _b;
+  return ((_a = getCurrentScope()) === null || _a === void 0 ? void 0 : _a.vm) || ((_b = getCurrentInstance()) === null || _b === void 0 ? void 0 : _b.proxy);
+}
+function bindCurrentScopeToVM(vm) {
+  if (!vm.scope) {
+    var scope_1 = new EffectScopeImpl(vm.proxy);
+    vm.scope = scope_1;
+    vm.proxy.$on("hook:destroyed", function() {
+      return scope_1.stop();
+    });
+  }
+  return vm.scope;
+}
+var vueDependency = void 0;
+try {
+  var requiredVue = require("vue");
+  if (requiredVue && isVue(requiredVue)) {
+    vueDependency = requiredVue;
+  } else if (requiredVue && "default" in requiredVue && isVue(requiredVue.default)) {
+    vueDependency = requiredVue.default;
+  }
+} catch (_a) {
+}
+var vueConstructor = null;
+var currentInstance = null;
+var currentInstanceTracking = true;
+var PluginInstalledFlag = "__composition_api_installed__";
+function isVue(obj) {
+  return obj && isFunction(obj) && obj.name === "Vue";
+}
+function isVueRegistered(Vue2) {
+  return vueConstructor && hasOwn(Vue2, PluginInstalledFlag);
+}
+function getVueConstructor() {
+  return vueConstructor;
+}
+function getRegisteredVueOrDefault() {
+  var constructor = vueConstructor || vueDependency;
+  return constructor;
+}
+function setVueConstructor(Vue2) {
+  vueConstructor = Vue2;
+  Object.defineProperty(Vue2, PluginInstalledFlag, {
+    configurable: true,
+    writable: true,
+    value: true
+  });
+}
+function withCurrentInstanceTrackingDisabled(fn) {
+  var prev = currentInstanceTracking;
+  currentInstanceTracking = false;
+  try {
+    fn();
+  } finally {
+    currentInstanceTracking = prev;
+  }
+}
+function setCurrentInstance(instance) {
+  if (!currentInstanceTracking)
+    return;
+  var prev = currentInstance;
+  prev === null || prev === void 0 ? void 0 : prev.scope.off();
+  currentInstance = instance;
+  currentInstance === null || currentInstance === void 0 ? void 0 : currentInstance.scope.on();
+}
+function getCurrentInstance() {
+  return currentInstance;
+}
+var instanceMapCache = new WeakMap();
+function toVue3ComponentInstance(vm) {
+  if (instanceMapCache.has(vm)) {
+    return instanceMapCache.get(vm);
+  }
+  var instance = {
+    proxy: vm,
+    update: vm.$forceUpdate,
+    type: vm.$options,
+    uid: vm._uid,
+    emit: vm.$emit.bind(vm),
+    parent: null,
+    root: null
+  };
+  bindCurrentScopeToVM(instance);
+  var instanceProps = [
+    "data",
+    "props",
+    "attrs",
+    "refs",
+    "vnode",
+    "slots"
+  ];
+  instanceProps.forEach(function(prop) {
+    proxy(instance, prop, {
+      get: function() {
+        return vm["$" + prop];
+      }
+    });
+  });
+  proxy(instance, "isMounted", {
+    get: function() {
+      return vm._isMounted;
+    }
+  });
+  proxy(instance, "isUnmounted", {
+    get: function() {
+      return vm._isDestroyed;
+    }
+  });
+  proxy(instance, "isDeactivated", {
+    get: function() {
+      return vm._inactive;
+    }
+  });
+  proxy(instance, "emitted", {
+    get: function() {
+      return vm._events;
+    }
+  });
+  instanceMapCache.set(vm, instance);
+  if (vm.$parent) {
+    instance.parent = toVue3ComponentInstance(vm.$parent);
+  }
+  if (vm.$root) {
+    instance.root = toVue3ComponentInstance(vm.$root);
+  }
+  return instance;
+}
+function defineComponentInstance(Ctor, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var silent = Ctor.config.silent;
+  Ctor.config.silent = true;
+  var vm = new Ctor(options);
+  Ctor.config.silent = silent;
+  return vm;
+}
+function isComponentInstance(obj) {
+  var Vue2 = getVueConstructor();
+  return Vue2 && obj instanceof Vue2;
+}
+function createSlotProxy(vm, slotName) {
+  return function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    if (!vm.$scopedSlots[slotName]) {
+      return;
+    }
+    return vm.$scopedSlots[slotName].apply(vm, args);
+  };
+}
+function resolveSlots(slots, normalSlots) {
+  var res;
+  if (!slots) {
+    res = {};
+  } else if (slots._normalized) {
+    return slots._normalized;
+  } else {
+    res = {};
+    for (var key in slots) {
+      if (slots[key] && key[0] !== "$") {
+        res[key] = true;
+      }
+    }
+  }
+  for (var key in normalSlots) {
+    if (!(key in res)) {
+      res[key] = true;
+    }
+  }
+  return res;
+}
+var vueInternalClasses;
+var getVueInternalClasses = function() {
+  if (!vueInternalClasses) {
+    var vm = defineComponentInstance(getVueConstructor(), {
+      computed: {
+        value: function() {
+          return 0;
+        }
+      }
+    });
+    var Watcher = vm._computedWatchers.value.constructor;
+    var Dep = vm._data.__ob__.dep.constructor;
+    vueInternalClasses = {
+      Watcher,
+      Dep
+    };
+    vm.$destroy();
+  }
+  return vueInternalClasses;
+};
+function createSymbol(name) {
+  return hasSymbol ? Symbol.for(name) : name;
+}
+var WatcherPreFlushQueueKey = createSymbol("composition-api.preFlushQueue");
+var WatcherPostFlushQueueKey = createSymbol("composition-api.postFlushQueue");
+var RefKey = "composition-api.refKey";
+var accessModifiedSet = new WeakMap();
+var readonlySet = new WeakMap();
+function set$1(target, key, val) {
+  var Vue2 = getVueConstructor();
+  var _a = Vue2.util;
+  _a.warn;
+  var defineReactive = _a.defineReactive;
+  var ob = target.__ob__;
+  function ssrMockReactivity() {
+    if (ob && isObject(val) && !hasOwn(val, "__ob__")) {
+      mockReactivityDeep(val);
+    }
+  }
+  if (isArray(target)) {
+    if (isValidArrayIndex(key)) {
+      target.length = Math.max(target.length, key);
+      target.splice(key, 1, val);
+      ssrMockReactivity();
+      return val;
+    } else if (key === "length" && val !== target.length) {
+      target.length = val;
+      ob === null || ob === void 0 ? void 0 : ob.dep.notify();
+      return val;
+    }
+  }
+  if (key in target && !(key in Object.prototype)) {
+    target[key] = val;
+    ssrMockReactivity();
+    return val;
+  }
+  if (target._isVue || ob && ob.vmCount) {
+    return val;
+  }
+  if (!ob) {
+    target[key] = val;
+    return val;
+  }
+  defineReactive(ob.value, key, val);
+  defineAccessControl(target, key, val);
+  ssrMockReactivity();
+  ob.dep.notify();
+  return val;
+}
+var RefImpl = function() {
+  function RefImpl2(_a) {
+    var get2 = _a.get, set2 = _a.set;
+    proxy(this, "value", {
+      get: get2,
+      set: set2
+    });
+  }
+  return RefImpl2;
+}();
+function createRef(options, isReadonly, isComputed) {
+  if (isReadonly === void 0) {
+    isReadonly = false;
+  }
+  if (isComputed === void 0) {
+    isComputed = false;
+  }
+  var r = new RefImpl(options);
+  if (isComputed)
+    r.effect = true;
+  var sealed = Object.seal(r);
+  if (isReadonly)
+    readonlySet.set(sealed, true);
+  return sealed;
+}
+function ref(raw) {
+  var _a;
+  if (isRef(raw)) {
+    return raw;
+  }
+  var value = reactive((_a = {}, _a[RefKey] = raw, _a));
+  return createRef({
+    get: function() {
+      return value[RefKey];
+    },
+    set: function(v) {
+      return value[RefKey] = v;
+    }
+  });
+}
+function isRef(value) {
+  return value instanceof RefImpl;
+}
+function toRefs(obj) {
+  if (!isPlainObject(obj))
+    return obj;
+  var ret = {};
+  for (var key in obj) {
+    ret[key] = toRef(obj, key);
+  }
+  return ret;
+}
+function toRef(object, key) {
+  if (!(key in object))
+    set$1(object, key, void 0);
+  var v = object[key];
+  if (isRef(v))
+    return v;
+  return createRef({
+    get: function() {
+      return object[key];
+    },
+    set: function(v2) {
+      return object[key] = v2;
+    }
+  });
+}
+function isRaw(obj) {
+  var _a;
+  return Boolean(obj && hasOwn(obj, "__ob__") && typeof obj.__ob__ === "object" && ((_a = obj.__ob__) === null || _a === void 0 ? void 0 : _a.__raw__));
+}
+function isReactive(obj) {
+  var _a;
+  return Boolean(obj && hasOwn(obj, "__ob__") && typeof obj.__ob__ === "object" && !((_a = obj.__ob__) === null || _a === void 0 ? void 0 : _a.__raw__));
+}
+function setupAccessControl(target) {
+  if (!isPlainObject(target) || isRaw(target) || isArray(target) || isRef(target) || isComponentInstance(target) || accessModifiedSet.has(target))
+    return;
+  accessModifiedSet.set(target, true);
+  var keys = Object.keys(target);
+  for (var i = 0; i < keys.length; i++) {
+    defineAccessControl(target, keys[i]);
+  }
+}
+function defineAccessControl(target, key, val) {
+  if (key === "__ob__")
+    return;
+  if (isRaw(target[key]))
+    return;
+  var getter;
+  var setter;
+  var property = Object.getOwnPropertyDescriptor(target, key);
+  if (property) {
+    if (property.configurable === false) {
+      return;
+    }
+    getter = property.get;
+    setter = property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+      val = target[key];
+    }
+  }
+  setupAccessControl(val);
+  proxy(target, key, {
+    get: function getterHandler() {
+      var value = getter ? getter.call(target) : val;
+      if (key !== RefKey && isRef(value)) {
+        return value.value;
+      } else {
+        return value;
+      }
+    },
+    set: function setterHandler(newVal) {
+      if (getter && !setter)
+        return;
+      if (key !== RefKey && isRef(val) && !isRef(newVal)) {
+        val.value = newVal;
+      } else if (setter) {
+        setter.call(target, newVal);
+        val = newVal;
+      } else {
+        val = newVal;
+      }
+      setupAccessControl(newVal);
+    }
+  });
+}
+function observe(obj) {
+  var Vue2 = getRegisteredVueOrDefault();
+  var observed;
+  if (Vue2.observable) {
+    observed = Vue2.observable(obj);
+  } else {
+    var vm = defineComponentInstance(Vue2, {
+      data: {
+        $$state: obj
+      }
+    });
+    observed = vm._data.$$state;
+  }
+  if (!hasOwn(observed, "__ob__")) {
+    mockReactivityDeep(observed);
+  }
+  return observed;
+}
+function mockReactivityDeep(obj, seen) {
+  var e_1, _a;
+  if (seen === void 0) {
+    seen = new Set();
+  }
+  if (seen.has(obj) || hasOwn(obj, "__ob__") || !Object.isExtensible(obj))
+    return;
+  def(obj, "__ob__", mockObserver(obj));
+  seen.add(obj);
+  try {
+    for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+      var key = _c.value;
+      var value = obj[key];
+      if (!(isPlainObject(value) || isArray(value)) || isRaw(value) || !Object.isExtensible(value)) {
+        continue;
+      }
+      mockReactivityDeep(value, seen);
+    }
+  } catch (e_1_1) {
+    e_1 = { error: e_1_1 };
+  } finally {
+    try {
+      if (_c && !_c.done && (_a = _b.return))
+        _a.call(_b);
+    } finally {
+      if (e_1)
+        throw e_1.error;
+    }
+  }
+}
+function mockObserver(value) {
+  if (value === void 0) {
+    value = {};
+  }
+  return {
+    value,
+    dep: {
+      notify: noopFn,
+      depend: noopFn,
+      addSub: noopFn,
+      removeSub: noopFn
+    }
+  };
+}
+function createObserver() {
+  return observe({}).__ob__;
+}
+function reactive(obj) {
+  if (!isObject(obj)) {
+    return obj;
+  }
+  if (!(isPlainObject(obj) || isArray(obj)) || isRaw(obj) || !Object.isExtensible(obj)) {
+    return obj;
+  }
+  var observed = observe(obj);
+  setupAccessControl(observed);
+  return observed;
+}
+var fallbackVM;
+function flushPreQueue() {
+  flushQueue(this, WatcherPreFlushQueueKey);
+}
+function flushPostQueue() {
+  flushQueue(this, WatcherPostFlushQueueKey);
+}
+function hasWatchEnv(vm) {
+  return vm[WatcherPreFlushQueueKey] !== void 0;
+}
+function installWatchEnv(vm) {
+  vm[WatcherPreFlushQueueKey] = [];
+  vm[WatcherPostFlushQueueKey] = [];
+  vm.$on("hook:beforeUpdate", flushPreQueue);
+  vm.$on("hook:updated", flushPostQueue);
+}
+function getWatcherOption(options) {
+  return __assign({
+    immediate: false,
+    deep: false,
+    flush: "pre"
+  }, options);
+}
+function getWatcherVM() {
+  var vm = getCurrentScopeVM();
+  if (!vm) {
+    if (!fallbackVM) {
+      fallbackVM = defineComponentInstance(getVueConstructor());
+    }
+    vm = fallbackVM;
+  } else if (!hasWatchEnv(vm)) {
+    installWatchEnv(vm);
+  }
+  return vm;
+}
+function flushQueue(vm, key) {
+  var queue = vm[key];
+  for (var index2 = 0; index2 < queue.length; index2++) {
+    queue[index2]();
+  }
+  queue.length = 0;
+}
+function queueFlushJob(vm, fn, mode) {
+  var fallbackFlush = function() {
+    vm.$nextTick(function() {
+      if (vm[WatcherPreFlushQueueKey].length) {
+        flushQueue(vm, WatcherPreFlushQueueKey);
+      }
+      if (vm[WatcherPostFlushQueueKey].length) {
+        flushQueue(vm, WatcherPostFlushQueueKey);
+      }
+    });
+  };
+  switch (mode) {
+    case "pre":
+      fallbackFlush();
+      vm[WatcherPreFlushQueueKey].push(fn);
+      break;
+    case "post":
+      fallbackFlush();
+      vm[WatcherPostFlushQueueKey].push(fn);
+      break;
+    default:
+      assert(false, 'flush must be one of ["post", "pre", "sync"], but got ' + mode);
+      break;
+  }
+}
+function createVueWatcher(vm, getter, callback, options) {
+  var index2 = vm._watchers.length;
+  vm.$watch(getter, callback, {
+    immediate: options.immediateInvokeCallback,
+    deep: options.deep,
+    lazy: options.noRun,
+    sync: options.sync,
+    before: options.before
+  });
+  return vm._watchers[index2];
+}
+function patchWatcherTeardown(watcher, runCleanup) {
+  var _teardown = watcher.teardown;
+  watcher.teardown = function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    _teardown.apply(watcher, args);
+    runCleanup();
+  };
+}
+function createWatcher(vm, source, cb, options) {
+  var _a;
+  var flushMode = options.flush;
+  var isSync = flushMode === "sync";
+  var cleanup;
+  var registerCleanup = function(fn) {
+    cleanup = function() {
+      try {
+        fn();
+      } catch (error) {
+        logError(error);
+      }
+    };
+  };
+  var runCleanup = function() {
+    if (cleanup) {
+      cleanup();
+      cleanup = null;
+    }
+  };
+  var createScheduler = function(fn) {
+    if (isSync || vm === fallbackVM) {
+      return fn;
+    }
+    return function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return queueFlushJob(vm, function() {
+        fn.apply(void 0, __spreadArray([], __read(args)));
+      }, flushMode);
+    };
+  };
+  if (cb === null) {
+    var running_1 = false;
+    var getter_1 = function() {
+      if (running_1) {
+        return;
+      }
+      try {
+        running_1 = true;
+        source(registerCleanup);
+      } finally {
+        running_1 = false;
+      }
+    };
+    var watcher_1 = createVueWatcher(vm, getter_1, noopFn, {
+      deep: options.deep || false,
+      sync: isSync,
+      before: runCleanup
+    });
+    patchWatcherTeardown(watcher_1, runCleanup);
+    watcher_1.lazy = false;
+    var originGet = watcher_1.get.bind(watcher_1);
+    watcher_1.get = createScheduler(originGet);
+    return function() {
+      watcher_1.teardown();
+    };
+  }
+  var deep = options.deep;
+  var isMultiSource = false;
+  var getter;
+  if (isRef(source)) {
+    getter = function() {
+      return source.value;
+    };
+  } else if (isReactive(source)) {
+    getter = function() {
+      return source;
+    };
+    deep = true;
+  } else if (isArray(source)) {
+    isMultiSource = true;
+    getter = function() {
+      return source.map(function(s) {
+        if (isRef(s)) {
+          return s.value;
+        } else if (isReactive(s)) {
+          return traverse(s);
+        } else if (isFunction(s)) {
+          return s();
+        } else {
+          return noopFn;
+        }
+      });
+    };
+  } else if (isFunction(source)) {
+    getter = source;
+  } else {
+    getter = noopFn;
+  }
+  if (deep) {
+    var baseGetter_1 = getter;
+    getter = function() {
+      return traverse(baseGetter_1());
+    };
+  }
+  var applyCb = function(n, o) {
+    if (!deep && isMultiSource && n.every(function(v, i) {
+      return Object.is(v, o[i]);
+    }))
+      return;
+    runCleanup();
+    return cb(n, o, registerCleanup);
+  };
+  var callback = createScheduler(applyCb);
+  if (options.immediate) {
+    var originalCallback_1 = callback;
+    var shiftCallback_1 = function(n, o) {
+      shiftCallback_1 = originalCallback_1;
+      return applyCb(n, isArray(n) ? [] : o);
+    };
+    callback = function(n, o) {
+      return shiftCallback_1(n, o);
+    };
+  }
+  var stop = vm.$watch(getter, callback, {
+    immediate: options.immediate,
+    deep,
+    sync: isSync
+  });
+  var watcher = vm._watchers[vm._watchers.length - 1];
+  if (isReactive(watcher.value) && ((_a = watcher.value.__ob__) === null || _a === void 0 ? void 0 : _a.dep) && deep) {
+    watcher.value.__ob__.dep.addSub({
+      update: function() {
+        watcher.run();
+      }
+    });
+  }
+  patchWatcherTeardown(watcher, runCleanup);
+  return function() {
+    stop();
+  };
+}
+function watch(source, cb, options) {
+  var callback = null;
+  if (isFunction(cb)) {
+    callback = cb;
+  } else {
+    options = cb;
+    callback = null;
+  }
+  var opts = getWatcherOption(options);
+  var vm = getWatcherVM();
+  return createWatcher(vm, source, callback, opts);
+}
+function traverse(value, seen) {
+  if (seen === void 0) {
+    seen = new Set();
+  }
+  if (!isObject(value) || seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  if (isRef(value)) {
+    traverse(value.value, seen);
+  } else if (isArray(value)) {
+    for (var i = 0; i < value.length; i++) {
+      traverse(value[i], seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach(function(v) {
+      traverse(v, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (var key in value) {
+      traverse(value[key], seen);
+    }
+  }
+  return value;
+}
+function computed(getterOrOptions) {
+  var vm = getCurrentScopeVM();
+  var getter;
+  var setter;
+  if (isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  var computedSetter;
+  var computedGetter;
+  if (vm && !vm.$isServer) {
+    var _a = getVueInternalClasses(), Watcher_1 = _a.Watcher, Dep_1 = _a.Dep;
+    var watcher_1;
+    computedGetter = function() {
+      if (!watcher_1) {
+        watcher_1 = new Watcher_1(vm, getter, noopFn, { lazy: true });
+      }
+      if (watcher_1.dirty) {
+        watcher_1.evaluate();
+      }
+      if (Dep_1.target) {
+        watcher_1.depend();
+      }
+      return watcher_1.value;
+    };
+    computedSetter = function(v) {
+      if (setter) {
+        setter(v);
+      }
+    };
+  } else {
+    var computedHost_1 = defineComponentInstance(getVueConstructor(), {
+      computed: {
+        $$state: {
+          get: getter,
+          set: setter
+        }
+      }
+    });
+    vm && vm.$on("hook:destroyed", function() {
+      return computedHost_1.$destroy();
+    });
+    computedGetter = function() {
+      return computedHost_1.$$state;
+    };
+    computedSetter = function(v) {
+      computedHost_1.$$state = v;
+    };
+  }
+  return createRef({
+    get: computedGetter,
+    set: computedSetter
+  }, !setter, true);
+}
+function set(vm, key, value) {
+  var state = vm.__composition_api_state__ = vm.__composition_api_state__ || {};
+  state[key] = value;
+}
+function get(vm, key) {
+  return (vm.__composition_api_state__ || {})[key];
+}
+var vmStateManager = {
+  set,
+  get
+};
+function asVmProperty(vm, propName, propValue) {
+  var props = vm.$options.props;
+  if (!(propName in vm) && !(props && hasOwn(props, propName))) {
+    if (isRef(propValue)) {
+      proxy(vm, propName, {
+        get: function() {
+          return propValue.value;
+        },
+        set: function(val) {
+          propValue.value = val;
+        }
+      });
+    } else {
+      proxy(vm, propName, {
+        get: function() {
+          if (isReactive(propValue)) {
+            propValue.__ob__.dep.depend();
+          }
+          return propValue;
+        },
+        set: function(val) {
+          propValue = val;
+        }
+      });
+    }
+  }
+}
+function updateTemplateRef(vm) {
+  var rawBindings = vmStateManager.get(vm, "rawBindings") || {};
+  if (!rawBindings || !Object.keys(rawBindings).length)
+    return;
+  var refs = vm.$refs;
+  var oldRefKeys = vmStateManager.get(vm, "refs") || [];
+  for (var index2 = 0; index2 < oldRefKeys.length; index2++) {
+    var key = oldRefKeys[index2];
+    var setupValue = rawBindings[key];
+    if (!refs[key] && setupValue && isRef(setupValue)) {
+      setupValue.value = null;
+    }
+  }
+  var newKeys = Object.keys(refs);
+  var validNewKeys = [];
+  for (var index2 = 0; index2 < newKeys.length; index2++) {
+    var key = newKeys[index2];
+    var setupValue = rawBindings[key];
+    if (refs[key] && setupValue && isRef(setupValue)) {
+      setupValue.value = refs[key];
+      validNewKeys.push(key);
+    }
+  }
+  vmStateManager.set(vm, "refs", validNewKeys);
+}
+function updateVmAttrs(vm, ctx) {
+  var e_1, _a;
+  if (!vm) {
+    return;
+  }
+  var attrBindings = vmStateManager.get(vm, "attrBindings");
+  if (!attrBindings && !ctx) {
+    return;
+  }
+  if (!attrBindings) {
+    var observedData = reactive({});
+    attrBindings = { ctx, data: observedData };
+    vmStateManager.set(vm, "attrBindings", attrBindings);
+    proxy(ctx, "attrs", {
+      get: function() {
+        return attrBindings === null || attrBindings === void 0 ? void 0 : attrBindings.data;
+      },
+      set: function() {
+      }
+    });
+  }
+  var source = vm.$attrs;
+  var _loop_1 = function(attr2) {
+    if (!hasOwn(attrBindings.data, attr2)) {
+      proxy(attrBindings.data, attr2, {
+        get: function() {
+          return vm.$attrs[attr2];
+        }
+      });
+    }
+  };
+  try {
+    for (var _b = __values(Object.keys(source)), _c = _b.next(); !_c.done; _c = _b.next()) {
+      var attr = _c.value;
+      _loop_1(attr);
+    }
+  } catch (e_1_1) {
+    e_1 = { error: e_1_1 };
+  } finally {
+    try {
+      if (_c && !_c.done && (_a = _b.return))
+        _a.call(_b);
+    } finally {
+      if (e_1)
+        throw e_1.error;
+    }
+  }
+}
+function resolveScopedSlots(vm, slotsProxy) {
+  var parentVNode = vm.$options._parentVnode;
+  if (!parentVNode)
+    return;
+  var prevSlots = vmStateManager.get(vm, "slots") || [];
+  var curSlots = resolveSlots(parentVNode.data.scopedSlots, vm.$slots);
+  for (var index2 = 0; index2 < prevSlots.length; index2++) {
+    var key = prevSlots[index2];
+    if (!curSlots[key]) {
+      delete slotsProxy[key];
+    }
+  }
+  var slotNames = Object.keys(curSlots);
+  for (var index2 = 0; index2 < slotNames.length; index2++) {
+    var key = slotNames[index2];
+    if (!slotsProxy[key]) {
+      slotsProxy[key] = createSlotProxy(vm, key);
+    }
+  }
+  vmStateManager.set(vm, "slots", slotNames);
+}
+function activateCurrentInstance(instance, fn, onError) {
+  var preVm = getCurrentInstance();
+  setCurrentInstance(instance);
+  try {
+    return fn(instance);
+  } catch (err) {
+    if (onError) {
+      onError(err);
+    } else {
+      throw err;
+    }
+  } finally {
+    setCurrentInstance(preVm);
+  }
+}
+function mixin(Vue2) {
+  Vue2.mixin({
+    beforeCreate: functionApiInit,
+    mounted: function() {
+      updateTemplateRef(this);
+    },
+    beforeUpdate: function() {
+      updateVmAttrs(this);
+    },
+    updated: function() {
+      var _a;
+      updateTemplateRef(this);
+      if ((_a = this.$vnode) === null || _a === void 0 ? void 0 : _a.context) {
+        updateTemplateRef(this.$vnode.context);
+      }
+    }
+  });
+  function functionApiInit() {
+    var vm = this;
+    var $options = vm.$options;
+    var setup = $options.setup, render2 = $options.render;
+    if (render2) {
+      $options.render = function() {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments[_i];
+        }
+        return activateCurrentInstance(toVue3ComponentInstance(vm), function() {
+          return render2.apply(_this, args);
+        });
+      };
+    }
+    if (!setup) {
+      return;
+    }
+    if (!isFunction(setup)) {
+      return;
+    }
+    var data = $options.data;
+    $options.data = function wrappedData() {
+      initSetup(vm, vm.$props);
+      return isFunction(data) ? data.call(vm, vm) : data || {};
+    };
+  }
+  function initSetup(vm, props) {
+    if (props === void 0) {
+      props = {};
+    }
+    var setup = vm.$options.setup;
+    var ctx = createSetupContext(vm);
+    var instance = toVue3ComponentInstance(vm);
+    instance.setupContext = ctx;
+    def(props, "__ob__", createObserver());
+    resolveScopedSlots(vm, ctx.slots);
+    var binding;
+    activateCurrentInstance(instance, function() {
+      binding = setup(props, ctx);
+    });
+    if (!binding)
+      return;
+    if (isFunction(binding)) {
+      var bindingFunc_1 = binding;
+      vm.$options.render = function() {
+        resolveScopedSlots(vm, ctx.slots);
+        return activateCurrentInstance(instance, function() {
+          return bindingFunc_1();
+        });
+      };
+      return;
+    } else if (isObject(binding)) {
+      if (isReactive(binding)) {
+        binding = toRefs(binding);
+      }
+      vmStateManager.set(vm, "rawBindings", binding);
+      var bindingObj_1 = binding;
+      Object.keys(bindingObj_1).forEach(function(name) {
+        var bindingValue = bindingObj_1[name];
+        if (!isRef(bindingValue)) {
+          if (!isReactive(bindingValue)) {
+            if (isFunction(bindingValue)) {
+              var copy_1 = bindingValue;
+              bindingValue = bindingValue.bind(vm);
+              Object.keys(copy_1).forEach(function(ele) {
+                bindingValue[ele] = copy_1[ele];
+              });
+            } else if (!isObject(bindingValue)) {
+              bindingValue = ref(bindingValue);
+            } else if (hasReactiveArrayChild(bindingValue)) {
+              customReactive(bindingValue);
+            }
+          } else if (isArray(bindingValue)) {
+            bindingValue = ref(bindingValue);
+          }
+        }
+        asVmProperty(vm, name, bindingValue);
+      });
+      return;
+    }
+  }
+  function customReactive(target, seen) {
+    if (seen === void 0) {
+      seen = new Set();
+    }
+    if (seen.has(target))
+      return;
+    if (!isPlainObject(target) || isRef(target) || isReactive(target) || isRaw(target))
+      return;
+    var Vue3 = getVueConstructor();
+    var defineReactive = Vue3.util.defineReactive;
+    Object.keys(target).forEach(function(k) {
+      var val = target[k];
+      defineReactive(target, k, val);
+      if (val) {
+        seen.add(val);
+        customReactive(val, seen);
+      }
+      return;
+    });
+  }
+  function hasReactiveArrayChild(target, visited) {
+    if (visited === void 0) {
+      visited = new Map();
+    }
+    if (visited.has(target)) {
+      return visited.get(target);
+    }
+    visited.set(target, false);
+    if (isArray(target) && isReactive(target)) {
+      visited.set(target, true);
+      return true;
+    }
+    if (!isPlainObject(target) || isRaw(target) || isRef(target)) {
+      return false;
+    }
+    return Object.keys(target).some(function(x) {
+      return hasReactiveArrayChild(target[x], visited);
+    });
+  }
+  function createSetupContext(vm) {
+    var ctx = { slots: {} };
+    var propsPlain = [
+      "root",
+      "parent",
+      "refs",
+      "listeners",
+      "isServer",
+      "ssrContext"
+    ];
+    var methodReturnVoid = ["emit"];
+    propsPlain.forEach(function(key) {
+      var srcKey = "$" + key;
+      proxy(ctx, key, {
+        get: function() {
+          return vm[srcKey];
+        },
+        set: function() {
+        }
+      });
+    });
+    updateVmAttrs(vm, ctx);
+    methodReturnVoid.forEach(function(key) {
+      var srcKey = "$" + key;
+      proxy(ctx, key, {
+        get: function() {
+          return function() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments[_i];
+            }
+            var fn = vm[srcKey];
+            fn.apply(vm, args);
+          };
+        }
+      });
+    });
+    return ctx;
+  }
+}
+function mergeData(from, to) {
+  if (!from)
+    return to;
+  if (!to)
+    return from;
+  var key;
+  var toVal;
+  var fromVal;
+  var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
+  for (var i = 0; i < keys.length; i++) {
+    key = keys[i];
+    if (key === "__ob__")
+      continue;
+    toVal = to[key];
+    fromVal = from[key];
+    if (!hasOwn(to, key)) {
+      to[key] = fromVal;
+    } else if (toVal !== fromVal && isPlainObject(toVal) && !isRef(toVal) && isPlainObject(fromVal) && !isRef(fromVal)) {
+      mergeData(fromVal, toVal);
+    }
+  }
+  return to;
+}
+function install$1(Vue2) {
+  if (isVueRegistered(Vue2)) {
+    return;
+  }
+  Vue2.config.optionMergeStrategies.setup = function(parent, child) {
+    return function mergedSetupFn(props, context) {
+      return mergeData(isFunction(parent) ? parent(props, context) || {} : void 0, isFunction(child) ? child(props, context) || {} : void 0);
+    };
+  };
+  setVueConstructor(Vue2);
+  mixin(Vue2);
+}
+var Plugin = {
+  install: function(Vue2) {
+    return install$1(Vue2);
+  }
+};
+function defineComponent(options) {
+  return options;
+}
+if (typeof window !== "undefined" && window.Vue) {
+  window.Vue.use(Plugin);
+}
+function install(_vue) {
+  _vue = _vue || Vue;
+  if (_vue && !_vue["__composition_api_installed__"])
+    Vue.use(Plugin);
+}
+install(Vue);
+Vue.version;
+function __variableDynamicImportRuntime0__(path3) {
+  switch (path3) {
+    case "./icons/attorney.svg":
+      return import("./attorney.js");
+    case "./icons/company.svg":
+      return import("./company.js");
+    case "./icons/individual.svg":
+      return import("./individual.js");
+    default:
+      return new Promise(function(resolve, reject) {
+        (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, new Error("Unknown variable dynamic import: " + path3)));
+      });
+  }
+}
+var __vue2_script$5 = defineComponent({
+  props: {
+    type: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props) {
+    const iconUrl = ref();
+    watch(() => props.type, (value) => {
+      let iconName = "";
+      switch (value) {
+        case "USERPROFILE":
+          iconName = "individual";
+          break;
+        case "CLIENTPROFILE":
+          iconName = "company";
+          break;
+        default:
+          iconName = "attorney";
+          break;
+      }
+      __variableDynamicImportRuntime0__(`./icons/${iconName}.svg`).then((result) => iconUrl.value = result.default);
+    }, { immediate: true });
+    return { iconUrl };
+  }
+});
+var render$5 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("img", { staticClass: "w-6 h-6", attrs: { "src": _vm.iconUrl, "alt": _vm.type } });
+};
+var staticRenderFns$5 = [];
+function normalizeComponent(scriptExports, render2, staticRenderFns2, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
+  var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
+  if (render2) {
+    options.render = render2;
+    options.staticRenderFns = staticRenderFns2;
+    options._compiled = true;
+  }
+  if (functionalTemplate) {
+    options.functional = true;
+  }
+  if (scopeId) {
+    options._scopeId = "data-v-" + scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function(context) {
+      context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (injectStyles) {
+        injectStyles.call(this, context);
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options._ssrRegister = hook;
+  } else if (injectStyles) {
+    hook = shadowMode ? function() {
+      injectStyles.call(this, (options.functional ? this.parent : this).$root.$options.shadowRoot);
+    } : injectStyles;
+  }
+  if (hook) {
+    if (options.functional) {
+      options._injectStyles = hook;
+      var originalRender = options.render;
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options.beforeCreate;
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return {
+    exports: scriptExports,
+    options
+  };
+}
+const __cssModules$5 = {};
+var __component__$5 = /* @__PURE__ */ normalizeComponent(__vue2_script$5, render$5, staticRenderFns$5, false, __vue2_injectStyles$5, null, null, null);
+function __vue2_injectStyles$5(context) {
+  for (let o in __cssModules$5) {
+    this[o] = __cssModules$5[o];
+  }
+}
+var ProfileTypeIcon = /* @__PURE__ */ function() {
+  return __component__$5.exports;
+}();
+var __vue2_script$4 = defineComponent({
+  props: {
+    source: {
+      type: Object,
+      required: true
+    }
+  },
+  components: { ProfileTypeIcon }
+});
+var render$4 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", { staticClass: "flex space-x-1 items-center" }, [_c("ProfileTypeIcon", { attrs: { "type": _vm.source.profileType } }), _c("div", { staticClass: "text-secondary" }, [_vm._v(_vm._s(_vm.source.profileName))])], 1);
+};
+var staticRenderFns$4 = [];
+const __cssModules$4 = {};
+var __component__$4 = /* @__PURE__ */ normalizeComponent(__vue2_script$4, render$4, staticRenderFns$4, false, __vue2_injectStyles$4, null, null, null);
+function __vue2_injectStyles$4(context) {
+  for (let o in __cssModules$4) {
+    this[o] = __cssModules$4[o];
+  }
+}
+var ProfileSelectItem = /* @__PURE__ */ function() {
+  return __component__$4.exports;
+}();
+function getAugmentedNamespace(n) {
+  if (n.__esModule)
+    return n;
+  var a = Object.defineProperty({}, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+function _typeof$2(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof$2 = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof$2 = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof$2(obj);
+}
+function isObjectLike(value) {
+  return _typeof$2(value) == "object" && value !== null;
+}
+var SYMBOL_TO_STRING_TAG = typeof Symbol === "function" && Symbol.toStringTag != null ? Symbol.toStringTag : "@@toStringTag";
+function getLocation(source, position) {
+  var lineRegexp = /\r\n|[\n\r]/g;
+  var line = 1;
+  var column = position + 1;
+  var match;
+  while ((match = lineRegexp.exec(source.body)) && match.index < position) {
+    line += 1;
+    column = position + 1 - (match.index + match[0].length);
+  }
+  return {
+    line,
+    column
+  };
+}
+function printLocation(location) {
+  return printSourceLocation(location.source, getLocation(location.source, location.start));
+}
+function printSourceLocation(source, sourceLocation) {
+  var firstLineColumnOffset = source.locationOffset.column - 1;
+  var body = whitespace(firstLineColumnOffset) + source.body;
+  var lineIndex = sourceLocation.line - 1;
+  var lineOffset = source.locationOffset.line - 1;
+  var lineNum = sourceLocation.line + lineOffset;
+  var columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
+  var columnNum = sourceLocation.column + columnOffset;
+  var locationStr = "".concat(source.name, ":").concat(lineNum, ":").concat(columnNum, "\n");
+  var lines = body.split(/\r\n|[\n\r]/g);
+  var locationLine = lines[lineIndex];
+  if (locationLine.length > 120) {
+    var subLineIndex = Math.floor(columnNum / 80);
+    var subLineColumnNum = columnNum % 80;
+    var subLines = [];
+    for (var i = 0; i < locationLine.length; i += 80) {
+      subLines.push(locationLine.slice(i, i + 80));
+    }
+    return locationStr + printPrefixedLines([["".concat(lineNum), subLines[0]]].concat(subLines.slice(1, subLineIndex + 1).map(function(subLine) {
+      return ["", subLine];
+    }), [[" ", whitespace(subLineColumnNum - 1) + "^"], ["", subLines[subLineIndex + 1]]]));
+  }
+  return locationStr + printPrefixedLines([
+    ["".concat(lineNum - 1), lines[lineIndex - 1]],
+    ["".concat(lineNum), locationLine],
+    ["", whitespace(columnNum - 1) + "^"],
+    ["".concat(lineNum + 1), lines[lineIndex + 1]]
+  ]);
+}
+function printPrefixedLines(lines) {
+  var existingLines = lines.filter(function(_ref) {
+    _ref[0];
+    var line = _ref[1];
+    return line !== void 0;
+  });
+  var padLen = Math.max.apply(Math, existingLines.map(function(_ref2) {
+    var prefix = _ref2[0];
+    return prefix.length;
+  }));
+  return existingLines.map(function(_ref3) {
+    var prefix = _ref3[0], line = _ref3[1];
+    return leftPad(padLen, prefix) + (line ? " | " + line : " |");
+  }).join("\n");
+}
+function whitespace(len) {
+  return Array(len + 1).join(" ");
+}
+function leftPad(len, str) {
+  return whitespace(len - str.length) + str;
+}
+function _typeof$1(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof$1 = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof$1 = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof$1(obj);
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly)
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties$1(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass$1(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties$1(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties$1(Constructor, staticProps);
+  return Constructor;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+  if (superClass)
+    _setPrototypeOf(subClass, superClass);
+}
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf(Derived), result;
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf(this).constructor;
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+    return _possibleConstructorReturn(this, result);
+  };
+}
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof$1(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+  return _assertThisInitialized(self);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : void 0;
+  _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+    if (Class2 === null || !_isNativeFunction(Class2))
+      return Class2;
+    if (typeof Class2 !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class2))
+        return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+    return _setPrototypeOf(Wrapper, Class2);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2)
+        _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  };
+  return _getPrototypeOf(o);
+}
+var GraphQLError = /* @__PURE__ */ function(_Error) {
+  _inherits(GraphQLError2, _Error);
+  var _super = _createSuper(GraphQLError2);
+  function GraphQLError2(message, nodes, source, positions, path3, originalError, extensions) {
+    var _nodeLocations, _nodeLocations2, _nodeLocations3;
+    var _this;
+    _classCallCheck(this, GraphQLError2);
+    _this = _super.call(this, message);
+    _this.name = "GraphQLError";
+    _this.originalError = originalError !== null && originalError !== void 0 ? originalError : void 0;
+    _this.nodes = undefinedIfEmpty(Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0);
+    var nodeLocations = [];
+    for (var _i2 = 0, _ref3 = (_this$nodes = _this.nodes) !== null && _this$nodes !== void 0 ? _this$nodes : []; _i2 < _ref3.length; _i2++) {
+      var _this$nodes;
+      var _ref4 = _ref3[_i2];
+      var loc = _ref4.loc;
+      if (loc != null) {
+        nodeLocations.push(loc);
+      }
+    }
+    nodeLocations = undefinedIfEmpty(nodeLocations);
+    _this.source = source !== null && source !== void 0 ? source : (_nodeLocations = nodeLocations) === null || _nodeLocations === void 0 ? void 0 : _nodeLocations[0].source;
+    _this.positions = positions !== null && positions !== void 0 ? positions : (_nodeLocations2 = nodeLocations) === null || _nodeLocations2 === void 0 ? void 0 : _nodeLocations2.map(function(loc2) {
+      return loc2.start;
+    });
+    _this.locations = positions && source ? positions.map(function(pos) {
+      return getLocation(source, pos);
+    }) : (_nodeLocations3 = nodeLocations) === null || _nodeLocations3 === void 0 ? void 0 : _nodeLocations3.map(function(loc2) {
+      return getLocation(loc2.source, loc2.start);
+    });
+    _this.path = path3 !== null && path3 !== void 0 ? path3 : void 0;
+    var originalExtensions = originalError === null || originalError === void 0 ? void 0 : originalError.extensions;
+    if (extensions == null && isObjectLike(originalExtensions)) {
+      _this.extensions = _objectSpread({}, originalExtensions);
+    } else {
+      _this.extensions = extensions !== null && extensions !== void 0 ? extensions : {};
+    }
+    Object.defineProperties(_assertThisInitialized(_this), {
+      message: {
+        enumerable: true
+      },
+      locations: {
+        enumerable: _this.locations != null
+      },
+      path: {
+        enumerable: _this.path != null
+      },
+      extensions: {
+        enumerable: _this.extensions != null && Object.keys(_this.extensions).length > 0
+      },
+      name: {
+        enumerable: false
+      },
+      nodes: {
+        enumerable: false
+      },
+      source: {
+        enumerable: false
+      },
+      positions: {
+        enumerable: false
+      },
+      originalError: {
+        enumerable: false
+      }
+    });
+    if (originalError !== null && originalError !== void 0 && originalError.stack) {
+      Object.defineProperty(_assertThisInitialized(_this), "stack", {
+        value: originalError.stack,
+        writable: true,
+        configurable: true
+      });
+      return _possibleConstructorReturn(_this);
+    }
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(_assertThisInitialized(_this), GraphQLError2);
+    } else {
+      Object.defineProperty(_assertThisInitialized(_this), "stack", {
+        value: Error().stack,
+        writable: true,
+        configurable: true
+      });
+    }
+    return _this;
+  }
+  _createClass$1(GraphQLError2, [{
+    key: "toString",
+    value: function toString2() {
+      return printError(this);
+    }
+  }, {
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get2() {
+      return "Object";
+    }
+  }]);
+  return GraphQLError2;
+}(/* @__PURE__ */ _wrapNativeSuper(Error));
+function undefinedIfEmpty(array) {
+  return array === void 0 || array.length === 0 ? void 0 : array;
+}
+function printError(error) {
+  var output = error.message;
+  if (error.nodes) {
+    for (var _i4 = 0, _error$nodes2 = error.nodes; _i4 < _error$nodes2.length; _i4++) {
+      var node = _error$nodes2[_i4];
+      if (node.loc) {
+        output += "\n\n" + printLocation(node.loc);
+      }
+    }
+  } else if (error.source && error.locations) {
+    for (var _i6 = 0, _error$locations2 = error.locations; _i6 < _error$locations2.length; _i6++) {
+      var location = _error$locations2[_i6];
+      output += "\n\n" + printSourceLocation(error.source, location);
+    }
+  }
+  return output;
+}
+function syntaxError(source, position, description) {
+  return new GraphQLError("Syntax Error: ".concat(description), void 0, source, [position]);
+}
+var Kind = Object.freeze({
+  NAME: "Name",
+  DOCUMENT: "Document",
+  OPERATION_DEFINITION: "OperationDefinition",
+  VARIABLE_DEFINITION: "VariableDefinition",
+  SELECTION_SET: "SelectionSet",
+  FIELD: "Field",
+  ARGUMENT: "Argument",
+  FRAGMENT_SPREAD: "FragmentSpread",
+  INLINE_FRAGMENT: "InlineFragment",
+  FRAGMENT_DEFINITION: "FragmentDefinition",
+  VARIABLE: "Variable",
+  INT: "IntValue",
+  FLOAT: "FloatValue",
+  STRING: "StringValue",
+  BOOLEAN: "BooleanValue",
+  NULL: "NullValue",
+  ENUM: "EnumValue",
+  LIST: "ListValue",
+  OBJECT: "ObjectValue",
+  OBJECT_FIELD: "ObjectField",
+  DIRECTIVE: "Directive",
+  NAMED_TYPE: "NamedType",
+  LIST_TYPE: "ListType",
+  NON_NULL_TYPE: "NonNullType",
+  SCHEMA_DEFINITION: "SchemaDefinition",
+  OPERATION_TYPE_DEFINITION: "OperationTypeDefinition",
+  SCALAR_TYPE_DEFINITION: "ScalarTypeDefinition",
+  OBJECT_TYPE_DEFINITION: "ObjectTypeDefinition",
+  FIELD_DEFINITION: "FieldDefinition",
+  INPUT_VALUE_DEFINITION: "InputValueDefinition",
+  INTERFACE_TYPE_DEFINITION: "InterfaceTypeDefinition",
+  UNION_TYPE_DEFINITION: "UnionTypeDefinition",
+  ENUM_TYPE_DEFINITION: "EnumTypeDefinition",
+  ENUM_VALUE_DEFINITION: "EnumValueDefinition",
+  INPUT_OBJECT_TYPE_DEFINITION: "InputObjectTypeDefinition",
+  DIRECTIVE_DEFINITION: "DirectiveDefinition",
+  SCHEMA_EXTENSION: "SchemaExtension",
+  SCALAR_TYPE_EXTENSION: "ScalarTypeExtension",
+  OBJECT_TYPE_EXTENSION: "ObjectTypeExtension",
+  INTERFACE_TYPE_EXTENSION: "InterfaceTypeExtension",
+  UNION_TYPE_EXTENSION: "UnionTypeExtension",
+  ENUM_TYPE_EXTENSION: "EnumTypeExtension",
+  INPUT_OBJECT_TYPE_EXTENSION: "InputObjectTypeExtension"
+});
+function invariant(condition, message) {
+  var booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : "Unexpected invariant triggered.");
+  }
+}
+var nodejsCustomInspectSymbol = typeof Symbol === "function" && typeof Symbol.for === "function" ? Symbol.for("nodejs.util.inspect.custom") : void 0;
+var nodejsCustomInspectSymbol$1 = nodejsCustomInspectSymbol;
+function defineInspect(classObject) {
+  var fn = classObject.prototype.toJSON;
+  typeof fn === "function" || invariant(0);
+  classObject.prototype.inspect = fn;
+  if (nodejsCustomInspectSymbol$1) {
+    classObject.prototype[nodejsCustomInspectSymbol$1] = fn;
+  }
+}
+var Location = /* @__PURE__ */ function() {
+  function Location2(startToken, endToken, source) {
+    this.start = startToken.start;
+    this.end = endToken.end;
+    this.startToken = startToken;
+    this.endToken = endToken;
+    this.source = source;
+  }
+  var _proto = Location2.prototype;
+  _proto.toJSON = function toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  };
+  return Location2;
+}();
+defineInspect(Location);
+var Token = /* @__PURE__ */ function() {
+  function Token2(kind, start, end, line, column, prev, value) {
+    this.kind = kind;
+    this.start = start;
+    this.end = end;
+    this.line = line;
+    this.column = column;
+    this.value = value;
+    this.prev = prev;
+    this.next = null;
+  }
+  var _proto2 = Token2.prototype;
+  _proto2.toJSON = function toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  };
+  return Token2;
+}();
+defineInspect(Token);
+var TokenKind = Object.freeze({
+  SOF: "<SOF>",
+  EOF: "<EOF>",
+  BANG: "!",
+  DOLLAR: "$",
+  AMP: "&",
+  PAREN_L: "(",
+  PAREN_R: ")",
+  SPREAD: "...",
+  COLON: ":",
+  EQUALS: "=",
+  AT: "@",
+  BRACKET_L: "[",
+  BRACKET_R: "]",
+  BRACE_L: "{",
+  PIPE: "|",
+  BRACE_R: "}",
+  NAME: "Name",
+  INT: "Int",
+  FLOAT: "Float",
+  STRING: "String",
+  BLOCK_STRING: "BlockString",
+  COMMENT: "Comment"
+});
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof2(obj2) {
+      return typeof obj2;
+    };
+  } else {
+    _typeof = function _typeof2(obj2) {
+      return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    };
+  }
+  return _typeof(obj);
+}
+var MAX_ARRAY_LENGTH = 10;
+var 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 ".concat(value.name, "]") : "[function]";
+    case "object":
+      if (value === null) {
+        return "null";
+      }
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (previouslySeenValues.indexOf(value) !== -1) {
+    return "[Circular]";
+  }
+  var seenValues = [].concat(previouslySeenValues, [value]);
+  var customInspectFn = getCustomFn(value);
+  if (customInspectFn !== void 0) {
+    var customValue = customInspectFn.call(value);
+    if (customValue !== value) {
+      return typeof customValue === "string" ? customValue : formatValue(customValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function formatObject(object, seenValues) {
+  var keys = Object.keys(object);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  var properties = keys.map(function(key) {
+    var value = formatValue(object[key], seenValues);
+    return key + ": " + value;
+  });
+  return "{ " + properties.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  var len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  var remaining = array.length - len;
+  var items = [];
+  for (var 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("... ".concat(remaining, " more items"));
+  }
+  return "[" + items.join(", ") + "]";
+}
+function getCustomFn(object) {
+  var customInspectFn = object[String(nodejsCustomInspectSymbol$1)];
+  if (typeof customInspectFn === "function") {
+    return customInspectFn;
+  }
+  if (typeof object.inspect === "function") {
+    return object.inspect;
+  }
+}
+function getObjectTag(object) {
+  var tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    var name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+function devAssert(condition, message) {
+  var booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+var instanceOf = function instanceOf2(value, constructor) {
+  return value instanceof constructor;
+};
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+var Source = /* @__PURE__ */ function() {
+  function Source2(body) {
+    var name = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "GraphQL request";
+    var locationOffset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+      line: 1,
+      column: 1
+    };
+    typeof body === "string" || devAssert(0, "Body must be a string. Received: ".concat(inspect(body), "."));
+    this.body = body;
+    this.name = name;
+    this.locationOffset = locationOffset;
+    this.locationOffset.line > 0 || devAssert(0, "line in locationOffset is 1-indexed and must be positive.");
+    this.locationOffset.column > 0 || devAssert(0, "column in locationOffset is 1-indexed and must be positive.");
+  }
+  _createClass(Source2, [{
+    key: SYMBOL_TO_STRING_TAG,
+    get: function get2() {
+      return "Source";
+    }
+  }]);
+  return Source2;
+}();
+function isSource(source) {
+  return instanceOf(source, Source);
+}
+var DirectiveLocation = Object.freeze({
+  QUERY: "QUERY",
+  MUTATION: "MUTATION",
+  SUBSCRIPTION: "SUBSCRIPTION",
+  FIELD: "FIELD",
+  FRAGMENT_DEFINITION: "FRAGMENT_DEFINITION",
+  FRAGMENT_SPREAD: "FRAGMENT_SPREAD",
+  INLINE_FRAGMENT: "INLINE_FRAGMENT",
+  VARIABLE_DEFINITION: "VARIABLE_DEFINITION",
+  SCHEMA: "SCHEMA",
+  SCALAR: "SCALAR",
+  OBJECT: "OBJECT",
+  FIELD_DEFINITION: "FIELD_DEFINITION",
+  ARGUMENT_DEFINITION: "ARGUMENT_DEFINITION",
+  INTERFACE: "INTERFACE",
+  UNION: "UNION",
+  ENUM: "ENUM",
+  ENUM_VALUE: "ENUM_VALUE",
+  INPUT_OBJECT: "INPUT_OBJECT",
+  INPUT_FIELD_DEFINITION: "INPUT_FIELD_DEFINITION"
+});
+function dedentBlockStringValue(rawString) {
+  var lines = rawString.split(/\r\n|[\n\r]/g);
+  var commonIndent = getBlockStringIndentation(rawString);
+  if (commonIndent !== 0) {
+    for (var i = 1; i < lines.length; i++) {
+      lines[i] = lines[i].slice(commonIndent);
+    }
+  }
+  var startLine = 0;
+  while (startLine < lines.length && isBlank(lines[startLine])) {
+    ++startLine;
+  }
+  var endLine = lines.length;
+  while (endLine > startLine && isBlank(lines[endLine - 1])) {
+    --endLine;
+  }
+  return lines.slice(startLine, endLine).join("\n");
+}
+function isBlank(str) {
+  for (var i = 0; i < str.length; ++i) {
+    if (str[i] !== " " && str[i] !== "	") {
+      return false;
+    }
+  }
+  return true;
+}
+function getBlockStringIndentation(value) {
+  var _commonIndent;
+  var isFirstLine = true;
+  var isEmptyLine = true;
+  var indent = 0;
+  var commonIndent = null;
+  for (var i = 0; i < value.length; ++i) {
+    switch (value.charCodeAt(i)) {
+      case 13:
+        if (value.charCodeAt(i + 1) === 10) {
+          ++i;
+        }
+      case 10:
+        isFirstLine = false;
+        isEmptyLine = true;
+        indent = 0;
+        break;
+      case 9:
+      case 32:
+        ++indent;
+        break;
+      default:
+        if (isEmptyLine && !isFirstLine && (commonIndent === null || indent < commonIndent)) {
+          commonIndent = indent;
+        }
+        isEmptyLine = false;
+    }
+  }
+  return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0;
+}
+var Lexer = /* @__PURE__ */ function() {
+  function Lexer2(source) {
+    var startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0, null);
+    this.source = source;
+    this.lastToken = startOfFileToken;
+    this.token = startOfFileToken;
+    this.line = 1;
+    this.lineStart = 0;
+  }
+  var _proto = Lexer2.prototype;
+  _proto.advance = function advance() {
+    this.lastToken = this.token;
+    var token = this.token = this.lookahead();
+    return token;
+  };
+  _proto.lookahead = function lookahead() {
+    var token = this.token;
+    if (token.kind !== TokenKind.EOF) {
+      do {
+        var _token$next;
+        token = (_token$next = token.next) !== null && _token$next !== void 0 ? _token$next : token.next = readToken(this, token);
+      } while (token.kind === TokenKind.COMMENT);
+    }
+    return token;
+  };
+  return Lexer2;
+}();
+function isPunctuatorTokenKind(kind) {
+  return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R;
+}
+function printCharCode(code) {
+  return isNaN(code) ? TokenKind.EOF : code < 127 ? JSON.stringify(String.fromCharCode(code)) : '"\\u'.concat(("00" + code.toString(16).toUpperCase()).slice(-4), '"');
+}
+function readToken(lexer, prev) {
+  var source = lexer.source;
+  var body = source.body;
+  var bodyLength = body.length;
+  var pos = prev.end;
+  while (pos < bodyLength) {
+    var code = body.charCodeAt(pos);
+    var _line = lexer.line;
+    var _col = 1 + pos - lexer.lineStart;
+    switch (code) {
+      case 65279:
+      case 9:
+      case 32:
+      case 44:
+        ++pos;
+        continue;
+      case 10:
+        ++pos;
+        ++lexer.line;
+        lexer.lineStart = pos;
+        continue;
+      case 13:
+        if (body.charCodeAt(pos + 1) === 10) {
+          pos += 2;
+        } else {
+          ++pos;
+        }
+        ++lexer.line;
+        lexer.lineStart = pos;
+        continue;
+      case 33:
+        return new Token(TokenKind.BANG, pos, pos + 1, _line, _col, prev);
+      case 35:
+        return readComment(source, pos, _line, _col, prev);
+      case 36:
+        return new Token(TokenKind.DOLLAR, pos, pos + 1, _line, _col, prev);
+      case 38:
+        return new Token(TokenKind.AMP, pos, pos + 1, _line, _col, prev);
+      case 40:
+        return new Token(TokenKind.PAREN_L, pos, pos + 1, _line, _col, prev);
+      case 41:
+        return new Token(TokenKind.PAREN_R, pos, pos + 1, _line, _col, prev);
+      case 46:
+        if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {
+          return new Token(TokenKind.SPREAD, pos, pos + 3, _line, _col, prev);
+        }
+        break;
+      case 58:
+        return new Token(TokenKind.COLON, pos, pos + 1, _line, _col, prev);
+      case 61:
+        return new Token(TokenKind.EQUALS, pos, pos + 1, _line, _col, prev);
+      case 64:
+        return new Token(TokenKind.AT, pos, pos + 1, _line, _col, prev);
+      case 91:
+        return new Token(TokenKind.BRACKET_L, pos, pos + 1, _line, _col, prev);
+      case 93:
+        return new Token(TokenKind.BRACKET_R, pos, pos + 1, _line, _col, prev);
+      case 123:
+        return new Token(TokenKind.BRACE_L, pos, pos + 1, _line, _col, prev);
+      case 124:
+        return new Token(TokenKind.PIPE, pos, pos + 1, _line, _col, prev);
+      case 125:
+        return new Token(TokenKind.BRACE_R, pos, pos + 1, _line, _col, prev);
+      case 34:
+        if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) {
+          return readBlockString(source, pos, _line, _col, prev, lexer);
+        }
+        return readString(source, pos, _line, _col, prev);
+      case 45:
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        return readNumber(source, pos, code, _line, _col, prev);
+      case 65:
+      case 66:
+      case 67:
+      case 68:
+      case 69:
+      case 70:
+      case 71:
+      case 72:
+      case 73:
+      case 74:
+      case 75:
+      case 76:
+      case 77:
+      case 78:
+      case 79:
+      case 80:
+      case 81:
+      case 82:
+      case 83:
+      case 84:
+      case 85:
+      case 86:
+      case 87:
+      case 88:
+      case 89:
+      case 90:
+      case 95:
+      case 97:
+      case 98:
+      case 99:
+      case 100:
+      case 101:
+      case 102:
+      case 103:
+      case 104:
+      case 105:
+      case 106:
+      case 107:
+      case 108:
+      case 109:
+      case 110:
+      case 111:
+      case 112:
+      case 113:
+      case 114:
+      case 115:
+      case 116:
+      case 117:
+      case 118:
+      case 119:
+      case 120:
+      case 121:
+      case 122:
+        return readName(source, pos, _line, _col, prev);
+    }
+    throw syntaxError(source, pos, unexpectedCharacterMessage(code));
+  }
+  var line = lexer.line;
+  var col = 1 + pos - lexer.lineStart;
+  return new Token(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);
+}
+function unexpectedCharacterMessage(code) {
+  if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+    return "Cannot contain the invalid character ".concat(printCharCode(code), ".");
+  }
+  if (code === 39) {
+    return `Unexpected single quote character ('), did you mean to use a double quote (")?`;
+  }
+  return "Cannot parse the unexpected character ".concat(printCharCode(code), ".");
+}
+function readComment(source, start, line, col, prev) {
+  var body = source.body;
+  var code;
+  var position = start;
+  do {
+    code = body.charCodeAt(++position);
+  } while (!isNaN(code) && (code > 31 || code === 9));
+  return new Token(TokenKind.COMMENT, start, position, line, col, prev, body.slice(start + 1, position));
+}
+function readNumber(source, start, firstCode, line, col, prev) {
+  var body = source.body;
+  var code = firstCode;
+  var position = start;
+  var isFloat = false;
+  if (code === 45) {
+    code = body.charCodeAt(++position);
+  }
+  if (code === 48) {
+    code = body.charCodeAt(++position);
+    if (code >= 48 && code <= 57) {
+      throw syntaxError(source, position, "Invalid number, unexpected digit after 0: ".concat(printCharCode(code), "."));
+    }
+  } else {
+    position = readDigits(source, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 46) {
+    isFloat = true;
+    code = body.charCodeAt(++position);
+    position = readDigits(source, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 69 || code === 101) {
+    isFloat = true;
+    code = body.charCodeAt(++position);
+    if (code === 43 || code === 45) {
+      code = body.charCodeAt(++position);
+    }
+    position = readDigits(source, position, code);
+    code = body.charCodeAt(position);
+  }
+  if (code === 46 || isNameStart(code)) {
+    throw syntaxError(source, position, "Invalid number, expected digit but got: ".concat(printCharCode(code), "."));
+  }
+  return new Token(isFloat ? TokenKind.FLOAT : TokenKind.INT, start, position, line, col, prev, body.slice(start, position));
+}
+function readDigits(source, start, firstCode) {
+  var body = source.body;
+  var position = start;
+  var code = firstCode;
+  if (code >= 48 && code <= 57) {
+    do {
+      code = body.charCodeAt(++position);
+    } while (code >= 48 && code <= 57);
+    return position;
+  }
+  throw syntaxError(source, position, "Invalid number, expected digit but got: ".concat(printCharCode(code), "."));
+}
+function readString(source, start, line, col, prev) {
+  var body = source.body;
+  var position = start + 1;
+  var chunkStart = position;
+  var code = 0;
+  var value = "";
+  while (position < body.length && !isNaN(code = body.charCodeAt(position)) && code !== 10 && code !== 13) {
+    if (code === 34) {
+      value += body.slice(chunkStart, position);
+      return new Token(TokenKind.STRING, start, position + 1, line, col, prev, value);
+    }
+    if (code < 32 && code !== 9) {
+      throw syntaxError(source, position, "Invalid character within String: ".concat(printCharCode(code), "."));
+    }
+    ++position;
+    if (code === 92) {
+      value += body.slice(chunkStart, position - 1);
+      code = body.charCodeAt(position);
+      switch (code) {
+        case 34:
+          value += '"';
+          break;
+        case 47:
+          value += "/";
+          break;
+        case 92:
+          value += "\\";
+          break;
+        case 98:
+          value += "\b";
+          break;
+        case 102:
+          value += "\f";
+          break;
+        case 110:
+          value += "\n";
+          break;
+        case 114:
+          value += "\r";
+          break;
+        case 116:
+          value += "	";
+          break;
+        case 117: {
+          var charCode = uniCharCode(body.charCodeAt(position + 1), body.charCodeAt(position + 2), body.charCodeAt(position + 3), body.charCodeAt(position + 4));
+          if (charCode < 0) {
+            var invalidSequence = body.slice(position + 1, position + 5);
+            throw syntaxError(source, position, "Invalid character escape sequence: \\u".concat(invalidSequence, "."));
+          }
+          value += String.fromCharCode(charCode);
+          position += 4;
+          break;
+        }
+        default:
+          throw syntaxError(source, position, "Invalid character escape sequence: \\".concat(String.fromCharCode(code), "."));
+      }
+      ++position;
+      chunkStart = position;
+    }
+  }
+  throw syntaxError(source, position, "Unterminated string.");
+}
+function readBlockString(source, start, line, col, prev, lexer) {
+  var body = source.body;
+  var position = start + 3;
+  var chunkStart = position;
+  var code = 0;
+  var rawValue = "";
+  while (position < body.length && !isNaN(code = body.charCodeAt(position))) {
+    if (code === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {
+      rawValue += body.slice(chunkStart, position);
+      return new Token(TokenKind.BLOCK_STRING, start, position + 3, line, col, prev, dedentBlockStringValue(rawValue));
+    }
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+      throw syntaxError(source, position, "Invalid character within String: ".concat(printCharCode(code), "."));
+    }
+    if (code === 10) {
+      ++position;
+      ++lexer.line;
+      lexer.lineStart = position;
+    } else if (code === 13) {
+      if (body.charCodeAt(position + 1) === 10) {
+        position += 2;
+      } else {
+        ++position;
+      }
+      ++lexer.line;
+      lexer.lineStart = position;
+    } else if (code === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) {
+      rawValue += body.slice(chunkStart, position) + '"""';
+      position += 4;
+      chunkStart = position;
+    } else {
+      ++position;
+    }
+  }
+  throw syntaxError(source, position, "Unterminated string.");
+}
+function uniCharCode(a, b, c, d) {
+  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);
+}
+function char2hex(a) {
+  return a >= 48 && a <= 57 ? a - 48 : a >= 65 && a <= 70 ? a - 55 : a >= 97 && a <= 102 ? a - 87 : -1;
+}
+function readName(source, start, line, col, prev) {
+  var body = source.body;
+  var bodyLength = body.length;
+  var position = start + 1;
+  var code = 0;
+  while (position !== bodyLength && !isNaN(code = body.charCodeAt(position)) && (code === 95 || code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122)) {
+    ++position;
+  }
+  return new Token(TokenKind.NAME, start, position, line, col, prev, body.slice(start, position));
+}
+function isNameStart(code) {
+  return code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function parse$1(source, options) {
+  var parser2 = new Parser(source, options);
+  return parser2.parseDocument();
+}
+function parseValue(source, options) {
+  var parser2 = new Parser(source, options);
+  parser2.expectToken(TokenKind.SOF);
+  var value = parser2.parseValueLiteral(false);
+  parser2.expectToken(TokenKind.EOF);
+  return value;
+}
+function parseType(source, options) {
+  var parser2 = new Parser(source, options);
+  parser2.expectToken(TokenKind.SOF);
+  var type = parser2.parseTypeReference();
+  parser2.expectToken(TokenKind.EOF);
+  return type;
+}
+var Parser = /* @__PURE__ */ function() {
+  function Parser2(source, options) {
+    var sourceObj = isSource(source) ? source : new Source(source);
+    this._lexer = new Lexer(sourceObj);
+    this._options = options;
+  }
+  var _proto = Parser2.prototype;
+  _proto.parseName = function parseName() {
+    var token = this.expectToken(TokenKind.NAME);
+    return {
+      kind: Kind.NAME,
+      value: token.value,
+      loc: this.loc(token)
+    };
+  };
+  _proto.parseDocument = function parseDocument2() {
+    var start = this._lexer.token;
+    return {
+      kind: Kind.DOCUMENT,
+      definitions: this.many(TokenKind.SOF, this.parseDefinition, TokenKind.EOF),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseDefinition = function parseDefinition() {
+    if (this.peek(TokenKind.NAME)) {
+      switch (this._lexer.token.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+        case "schema":
+        case "scalar":
+        case "type":
+        case "interface":
+        case "union":
+        case "enum":
+        case "input":
+        case "directive":
+          return this.parseTypeSystemDefinition();
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    } else if (this.peek(TokenKind.BRACE_L)) {
+      return this.parseOperationDefinition();
+    } else if (this.peekDescription()) {
+      return this.parseTypeSystemDefinition();
+    }
+    throw this.unexpected();
+  };
+  _proto.parseOperationDefinition = function parseOperationDefinition() {
+    var start = this._lexer.token;
+    if (this.peek(TokenKind.BRACE_L)) {
+      return {
+        kind: Kind.OPERATION_DEFINITION,
+        operation: "query",
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet(),
+        loc: this.loc(start)
+      };
+    }
+    var operation = this.parseOperationType();
+    var name;
+    if (this.peek(TokenKind.NAME)) {
+      name = this.parseName();
+    }
+    return {
+      kind: Kind.OPERATION_DEFINITION,
+      operation,
+      name,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet(),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseOperationType = function parseOperationType() {
+    var operationToken = this.expectToken(TokenKind.NAME);
+    switch (operationToken.value) {
+      case "query":
+        return "query";
+      case "mutation":
+        return "mutation";
+      case "subscription":
+        return "subscription";
+    }
+    throw this.unexpected(operationToken);
+  };
+  _proto.parseVariableDefinitions = function parseVariableDefinitions() {
+    return this.optionalMany(TokenKind.PAREN_L, this.parseVariableDefinition, TokenKind.PAREN_R);
+  };
+  _proto.parseVariableDefinition = function parseVariableDefinition() {
+    var start = this._lexer.token;
+    return {
+      kind: Kind.VARIABLE_DEFINITION,
+      variable: this.parseVariable(),
+      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseValueLiteral(true) : void 0,
+      directives: this.parseDirectives(true),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseVariable = function parseVariable() {
+    var start = this._lexer.token;
+    this.expectToken(TokenKind.DOLLAR);
+    return {
+      kind: Kind.VARIABLE,
+      name: this.parseName(),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseSelectionSet = function parseSelectionSet() {
+    var start = this._lexer.token;
+    return {
+      kind: Kind.SELECTION_SET,
+      selections: this.many(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseSelection = function parseSelection() {
+    return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField();
+  };
+  _proto.parseField = function parseField() {
+    var start = this._lexer.token;
+    var nameOrAlias = this.parseName();
+    var alias;
+    var name;
+    if (this.expectOptionalToken(TokenKind.COLON)) {
+      alias = nameOrAlias;
+      name = this.parseName();
+    } else {
+      name = nameOrAlias;
+    }
+    return {
+      kind: Kind.FIELD,
+      alias,
+      name,
+      arguments: this.parseArguments(false),
+      directives: this.parseDirectives(false),
+      selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : void 0,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseArguments = function parseArguments(isConst) {
+    var item = isConst ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);
+  };
+  _proto.parseArgument = function parseArgument() {
+    var start = this._lexer.token;
+    var name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return {
+      kind: Kind.ARGUMENT,
+      name,
+      value: this.parseValueLiteral(false),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseConstArgument = function parseConstArgument() {
+    var start = this._lexer.token;
+    return {
+      kind: Kind.ARGUMENT,
+      name: this.parseName(),
+      value: (this.expectToken(TokenKind.COLON), this.parseValueLiteral(true)),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseFragment = function parseFragment() {
+    var start = this._lexer.token;
+    this.expectToken(TokenKind.SPREAD);
+    var hasTypeCondition = this.expectOptionalKeyword("on");
+    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {
+      return {
+        kind: Kind.FRAGMENT_SPREAD,
+        name: this.parseFragmentName(),
+        directives: this.parseDirectives(false),
+        loc: this.loc(start)
+      };
+    }
+    return {
+      kind: Kind.INLINE_FRAGMENT,
+      typeCondition: hasTypeCondition ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet(),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseFragmentDefinition = function parseFragmentDefinition() {
+    var _this$_options;
+    var start = this._lexer.token;
+    this.expectKeyword("fragment");
+    if (((_this$_options = this._options) === null || _this$_options === void 0 ? void 0 : _this$_options.experimentalFragmentVariables) === true) {
+      return {
+        kind: Kind.FRAGMENT_DEFINITION,
+        name: this.parseFragmentName(),
+        variableDefinitions: this.parseVariableDefinitions(),
+        typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+        directives: this.parseDirectives(false),
+        selectionSet: this.parseSelectionSet(),
+        loc: this.loc(start)
+      };
+    }
+    return {
+      kind: Kind.FRAGMENT_DEFINITION,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(false),
+      selectionSet: this.parseSelectionSet(),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseFragmentName = function parseFragmentName() {
+    if (this._lexer.token.value === "on") {
+      throw this.unexpected();
+    }
+    return this.parseName();
+  };
+  _proto.parseValueLiteral = function parseValueLiteral(isConst) {
+    var token = this._lexer.token;
+    switch (token.kind) {
+      case TokenKind.BRACKET_L:
+        return this.parseList(isConst);
+      case TokenKind.BRACE_L:
+        return this.parseObject(isConst);
+      case TokenKind.INT:
+        this._lexer.advance();
+        return {
+          kind: Kind.INT,
+          value: token.value,
+          loc: this.loc(token)
+        };
+      case TokenKind.FLOAT:
+        this._lexer.advance();
+        return {
+          kind: Kind.FLOAT,
+          value: token.value,
+          loc: this.loc(token)
+        };
+      case TokenKind.STRING:
+      case TokenKind.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case TokenKind.NAME:
+        this._lexer.advance();
+        switch (token.value) {
+          case "true":
+            return {
+              kind: Kind.BOOLEAN,
+              value: true,
+              loc: this.loc(token)
+            };
+          case "false":
+            return {
+              kind: Kind.BOOLEAN,
+              value: false,
+              loc: this.loc(token)
+            };
+          case "null":
+            return {
+              kind: Kind.NULL,
+              loc: this.loc(token)
+            };
+          default:
+            return {
+              kind: Kind.ENUM,
+              value: token.value,
+              loc: this.loc(token)
+            };
+        }
+      case TokenKind.DOLLAR:
+        if (!isConst) {
+          return this.parseVariable();
+        }
+        break;
+    }
+    throw this.unexpected();
+  };
+  _proto.parseStringLiteral = function parseStringLiteral() {
+    var token = this._lexer.token;
+    this._lexer.advance();
+    return {
+      kind: Kind.STRING,
+      value: token.value,
+      block: token.kind === TokenKind.BLOCK_STRING,
+      loc: this.loc(token)
+    };
+  };
+  _proto.parseList = function parseList(isConst) {
+    var _this = this;
+    var start = this._lexer.token;
+    var item = function item2() {
+      return _this.parseValueLiteral(isConst);
+    };
+    return {
+      kind: Kind.LIST,
+      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseObject = function parseObject(isConst) {
+    var _this2 = this;
+    var start = this._lexer.token;
+    var item = function item2() {
+      return _this2.parseObjectField(isConst);
+    };
+    return {
+      kind: Kind.OBJECT,
+      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseObjectField = function parseObjectField(isConst) {
+    var start = this._lexer.token;
+    var name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    return {
+      kind: Kind.OBJECT_FIELD,
+      name,
+      value: this.parseValueLiteral(isConst),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseDirectives = function parseDirectives(isConst) {
+    var directives = [];
+    while (this.peek(TokenKind.AT)) {
+      directives.push(this.parseDirective(isConst));
+    }
+    return directives;
+  };
+  _proto.parseDirective = function parseDirective(isConst) {
+    var start = this._lexer.token;
+    this.expectToken(TokenKind.AT);
+    return {
+      kind: Kind.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(isConst),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseTypeReference = function parseTypeReference() {
+    var start = this._lexer.token;
+    var type;
+    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
+      type = this.parseTypeReference();
+      this.expectToken(TokenKind.BRACKET_R);
+      type = {
+        kind: Kind.LIST_TYPE,
+        type,
+        loc: this.loc(start)
+      };
+    } else {
+      type = this.parseNamedType();
+    }
+    if (this.expectOptionalToken(TokenKind.BANG)) {
+      return {
+        kind: Kind.NON_NULL_TYPE,
+        type,
+        loc: this.loc(start)
+      };
+    }
+    return type;
+  };
+  _proto.parseNamedType = function parseNamedType() {
+    var start = this._lexer.token;
+    return {
+      kind: Kind.NAMED_TYPE,
+      name: this.parseName(),
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseTypeSystemDefinition = function parseTypeSystemDefinition() {
+    var keywordToken = this.peekDescription() ? this._lexer.lookahead() : this._lexer.token;
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+    }
+    throw this.unexpected(keywordToken);
+  };
+  _proto.peekDescription = function peekDescription() {
+    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);
+  };
+  _proto.parseDescription = function parseDescription() {
+    if (this.peekDescription()) {
+      return this.parseStringLiteral();
+    }
+  };
+  _proto.parseSchemaDefinition = function parseSchemaDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("schema");
+    var directives = this.parseDirectives(true);
+    var operationTypes = this.many(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);
+    return {
+      kind: Kind.SCHEMA_DEFINITION,
+      description,
+      directives,
+      operationTypes,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseOperationTypeDefinition = function parseOperationTypeDefinition() {
+    var start = this._lexer.token;
+    var operation = this.parseOperationType();
+    this.expectToken(TokenKind.COLON);
+    var type = this.parseNamedType();
+    return {
+      kind: Kind.OPERATION_TYPE_DEFINITION,
+      operation,
+      type,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseScalarTypeDefinition = function parseScalarTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("scalar");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    return {
+      kind: Kind.SCALAR_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseObjectTypeDefinition = function parseObjectTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("type");
+    var name = this.parseName();
+    var interfaces = this.parseImplementsInterfaces();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseFieldsDefinition();
+    return {
+      kind: Kind.OBJECT_TYPE_DEFINITION,
+      description,
+      name,
+      interfaces,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseImplementsInterfaces = function parseImplementsInterfaces() {
+    var _this$_options2;
+    if (!this.expectOptionalKeyword("implements")) {
+      return [];
+    }
+    if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true) {
+      var types = [];
+      this.expectOptionalToken(TokenKind.AMP);
+      do {
+        types.push(this.parseNamedType());
+      } while (this.expectOptionalToken(TokenKind.AMP) || this.peek(TokenKind.NAME));
+      return types;
+    }
+    return this.delimitedMany(TokenKind.AMP, this.parseNamedType);
+  };
+  _proto.parseFieldsDefinition = function parseFieldsDefinition() {
+    var _this$_options3;
+    if (((_this$_options3 = this._options) === null || _this$_options3 === void 0 ? void 0 : _this$_options3.allowLegacySDLEmptyFields) === true && this.peek(TokenKind.BRACE_L) && this._lexer.lookahead().kind === TokenKind.BRACE_R) {
+      this._lexer.advance();
+      this._lexer.advance();
+      return [];
+    }
+    return this.optionalMany(TokenKind.BRACE_L, this.parseFieldDefinition, TokenKind.BRACE_R);
+  };
+  _proto.parseFieldDefinition = function parseFieldDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    var name = this.parseName();
+    var args = this.parseArgumentDefs();
+    this.expectToken(TokenKind.COLON);
+    var type = this.parseTypeReference();
+    var directives = this.parseDirectives(true);
+    return {
+      kind: Kind.FIELD_DEFINITION,
+      description,
+      name,
+      arguments: args,
+      type,
+      directives,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseArgumentDefs = function parseArgumentDefs() {
+    return this.optionalMany(TokenKind.PAREN_L, this.parseInputValueDef, TokenKind.PAREN_R);
+  };
+  _proto.parseInputValueDef = function parseInputValueDef() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    var name = this.parseName();
+    this.expectToken(TokenKind.COLON);
+    var type = this.parseTypeReference();
+    var defaultValue;
+    if (this.expectOptionalToken(TokenKind.EQUALS)) {
+      defaultValue = this.parseValueLiteral(true);
+    }
+    var directives = this.parseDirectives(true);
+    return {
+      kind: Kind.INPUT_VALUE_DEFINITION,
+      description,
+      name,
+      type,
+      defaultValue,
+      directives,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseInterfaceTypeDefinition = function parseInterfaceTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("interface");
+    var name = this.parseName();
+    var interfaces = this.parseImplementsInterfaces();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseFieldsDefinition();
+    return {
+      kind: Kind.INTERFACE_TYPE_DEFINITION,
+      description,
+      name,
+      interfaces,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseUnionTypeDefinition = function parseUnionTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("union");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var types = this.parseUnionMemberTypes();
+    return {
+      kind: Kind.UNION_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      types,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseUnionMemberTypes = function parseUnionMemberTypes() {
+    return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : [];
+  };
+  _proto.parseEnumTypeDefinition = function parseEnumTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("enum");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var values = this.parseEnumValuesDefinition();
+    return {
+      kind: Kind.ENUM_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      values,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseEnumValuesDefinition = function parseEnumValuesDefinition() {
+    return this.optionalMany(TokenKind.BRACE_L, this.parseEnumValueDefinition, TokenKind.BRACE_R);
+  };
+  _proto.parseEnumValueDefinition = function parseEnumValueDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    return {
+      kind: Kind.ENUM_VALUE_DEFINITION,
+      description,
+      name,
+      directives,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseInputObjectTypeDefinition = function parseInputObjectTypeDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("input");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseInputFieldsDefinition();
+    return {
+      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+      description,
+      name,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseInputFieldsDefinition = function parseInputFieldsDefinition() {
+    return this.optionalMany(TokenKind.BRACE_L, this.parseInputValueDef, TokenKind.BRACE_R);
+  };
+  _proto.parseTypeSystemExtension = function parseTypeSystemExtension() {
+    var keywordToken = this._lexer.lookahead();
+    if (keywordToken.kind === TokenKind.NAME) {
+      switch (keywordToken.value) {
+        case "schema":
+          return this.parseSchemaExtension();
+        case "scalar":
+          return this.parseScalarTypeExtension();
+        case "type":
+          return this.parseObjectTypeExtension();
+        case "interface":
+          return this.parseInterfaceTypeExtension();
+        case "union":
+          return this.parseUnionTypeExtension();
+        case "enum":
+          return this.parseEnumTypeExtension();
+        case "input":
+          return this.parseInputObjectTypeExtension();
+      }
+    }
+    throw this.unexpected(keywordToken);
+  };
+  _proto.parseSchemaExtension = function parseSchemaExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("schema");
+    var directives = this.parseDirectives(true);
+    var operationTypes = this.optionalMany(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);
+    if (directives.length === 0 && operationTypes.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.SCHEMA_EXTENSION,
+      directives,
+      operationTypes,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseScalarTypeExtension = function parseScalarTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("scalar");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    if (directives.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.SCALAR_TYPE_EXTENSION,
+      name,
+      directives,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseObjectTypeExtension = function parseObjectTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("type");
+    var name = this.parseName();
+    var interfaces = this.parseImplementsInterfaces();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.OBJECT_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseInterfaceTypeExtension = function parseInterfaceTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("interface");
+    var name = this.parseName();
+    var interfaces = this.parseImplementsInterfaces();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseFieldsDefinition();
+    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.INTERFACE_TYPE_EXTENSION,
+      name,
+      interfaces,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseUnionTypeExtension = function parseUnionTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("union");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var types = this.parseUnionMemberTypes();
+    if (directives.length === 0 && types.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.UNION_TYPE_EXTENSION,
+      name,
+      directives,
+      types,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseEnumTypeExtension = function parseEnumTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("enum");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var values = this.parseEnumValuesDefinition();
+    if (directives.length === 0 && values.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.ENUM_TYPE_EXTENSION,
+      name,
+      directives,
+      values,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseInputObjectTypeExtension = function parseInputObjectTypeExtension() {
+    var start = this._lexer.token;
+    this.expectKeyword("extend");
+    this.expectKeyword("input");
+    var name = this.parseName();
+    var directives = this.parseDirectives(true);
+    var fields = this.parseInputFieldsDefinition();
+    if (directives.length === 0 && fields.length === 0) {
+      throw this.unexpected();
+    }
+    return {
+      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
+      name,
+      directives,
+      fields,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseDirectiveDefinition = function parseDirectiveDefinition() {
+    var start = this._lexer.token;
+    var description = this.parseDescription();
+    this.expectKeyword("directive");
+    this.expectToken(TokenKind.AT);
+    var name = this.parseName();
+    var args = this.parseArgumentDefs();
+    var repeatable = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    var locations = this.parseDirectiveLocations();
+    return {
+      kind: Kind.DIRECTIVE_DEFINITION,
+      description,
+      name,
+      arguments: args,
+      repeatable,
+      locations,
+      loc: this.loc(start)
+    };
+  };
+  _proto.parseDirectiveLocations = function parseDirectiveLocations() {
+    return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);
+  };
+  _proto.parseDirectiveLocation = function parseDirectiveLocation() {
+    var start = this._lexer.token;
+    var name = this.parseName();
+    if (DirectiveLocation[name.value] !== void 0) {
+      return name;
+    }
+    throw this.unexpected(start);
+  };
+  _proto.loc = function loc(startToken) {
+    var _this$_options4;
+    if (((_this$_options4 = this._options) === null || _this$_options4 === void 0 ? void 0 : _this$_options4.noLocation) !== true) {
+      return new Location(startToken, this._lexer.lastToken, this._lexer.source);
+    }
+  };
+  _proto.peek = function peek(kind) {
+    return this._lexer.token.kind === kind;
+  };
+  _proto.expectToken = function expectToken(kind) {
+    var token = this._lexer.token;
+    if (token.kind === kind) {
+      this._lexer.advance();
+      return token;
+    }
+    throw syntaxError(this._lexer.source, token.start, "Expected ".concat(getTokenKindDesc(kind), ", found ").concat(getTokenDesc(token), "."));
+  };
+  _proto.expectOptionalToken = function expectOptionalToken(kind) {
+    var token = this._lexer.token;
+    if (token.kind === kind) {
+      this._lexer.advance();
+      return token;
+    }
+    return void 0;
+  };
+  _proto.expectKeyword = function expectKeyword(value) {
+    var token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this._lexer.advance();
+    } else {
+      throw syntaxError(this._lexer.source, token.start, 'Expected "'.concat(value, '", found ').concat(getTokenDesc(token), "."));
+    }
+  };
+  _proto.expectOptionalKeyword = function expectOptionalKeyword(value) {
+    var token = this._lexer.token;
+    if (token.kind === TokenKind.NAME && token.value === value) {
+      this._lexer.advance();
+      return true;
+    }
+    return false;
+  };
+  _proto.unexpected = function unexpected(atToken) {
+    var token = atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;
+    return syntaxError(this._lexer.source, token.start, "Unexpected ".concat(getTokenDesc(token), "."));
+  };
+  _proto.any = function any(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    var nodes = [];
+    while (!this.expectOptionalToken(closeKind)) {
+      nodes.push(parseFn.call(this));
+    }
+    return nodes;
+  };
+  _proto.optionalMany = function optionalMany(openKind, parseFn, closeKind) {
+    if (this.expectOptionalToken(openKind)) {
+      var nodes = [];
+      do {
+        nodes.push(parseFn.call(this));
+      } while (!this.expectOptionalToken(closeKind));
+      return nodes;
+    }
+    return [];
+  };
+  _proto.many = function many(openKind, parseFn, closeKind) {
+    this.expectToken(openKind);
+    var nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (!this.expectOptionalToken(closeKind));
+    return nodes;
+  };
+  _proto.delimitedMany = function delimitedMany(delimiterKind, parseFn) {
+    this.expectOptionalToken(delimiterKind);
+    var nodes = [];
+    do {
+      nodes.push(parseFn.call(this));
+    } while (this.expectOptionalToken(delimiterKind));
+    return nodes;
+  };
+  return Parser2;
+}();
+function getTokenDesc(token) {
+  var value = token.value;
+  return getTokenKindDesc(token.kind) + (value != null ? ' "'.concat(value, '"') : "");
+}
+function getTokenKindDesc(kind) {
+  return isPunctuatorTokenKind(kind) ? '"'.concat(kind, '"') : kind;
+}
+var parser$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  [Symbol.toStringTag]: "Module",
+  parse: parse$1,
+  parseValue,
+  parseType,
+  Parser
+});
+var require$$0 = /* @__PURE__ */ getAugmentedNamespace(parser$1);
+var parser = require$$0;
+var parse = parser.parse;
+function normalize(string) {
+  return string.replace(/[\s,]+/g, " ").trim();
+}
+var docCache = {};
+var fragmentSourceMap = {};
+function cacheKeyFromLoc(loc) {
+  return normalize(loc.source.body.substring(loc.start, loc.end));
+}
+function resetCaches() {
+  docCache = {};
+  fragmentSourceMap = {};
+}
+var printFragmentWarnings = true;
+function processFragments(ast) {
+  var astFragmentMap = {};
+  var definitions = [];
+  for (var i = 0; i < ast.definitions.length; i++) {
+    var fragmentDefinition = ast.definitions[i];
+    if (fragmentDefinition.kind === "FragmentDefinition") {
+      var fragmentName = fragmentDefinition.name.value;
+      var sourceKey = cacheKeyFromLoc(fragmentDefinition.loc);
+      if (fragmentSourceMap.hasOwnProperty(fragmentName) && !fragmentSourceMap[fragmentName][sourceKey]) {
+        if (printFragmentWarnings) {
+          console.warn("Warning: fragment with name " + fragmentName + " already exists.\ngraphql-tag enforces all fragment names across your application to be unique; read more about\nthis in the docs: http://dev.apollodata.com/core/fragments.html#unique-names");
+        }
+        fragmentSourceMap[fragmentName][sourceKey] = true;
+      } else if (!fragmentSourceMap.hasOwnProperty(fragmentName)) {
+        fragmentSourceMap[fragmentName] = {};
+        fragmentSourceMap[fragmentName][sourceKey] = true;
+      }
+      if (!astFragmentMap[sourceKey]) {
+        astFragmentMap[sourceKey] = true;
+        definitions.push(fragmentDefinition);
+      }
+    } else {
+      definitions.push(fragmentDefinition);
+    }
+  }
+  ast.definitions = definitions;
+  return ast;
+}
+function disableFragmentWarnings() {
+  printFragmentWarnings = false;
+}
+function stripLoc(doc, removeLocAtThisLevel) {
+  var docType = Object.prototype.toString.call(doc);
+  if (docType === "[object Array]") {
+    return doc.map(function(d) {
+      return stripLoc(d, removeLocAtThisLevel);
+    });
+  }
+  if (docType !== "[object Object]") {
+    throw new Error("Unexpected input.");
+  }
+  if (removeLocAtThisLevel && doc.loc) {
+    delete doc.loc;
+  }
+  if (doc.loc) {
+    delete doc.loc.startToken;
+    delete doc.loc.endToken;
+  }
+  var keys = Object.keys(doc);
+  var key;
+  var value;
+  var valueType;
+  for (key in keys) {
+    if (keys.hasOwnProperty(key)) {
+      value = doc[keys[key]];
+      valueType = Object.prototype.toString.call(value);
+      if (valueType === "[object Object]" || valueType === "[object Array]") {
+        doc[keys[key]] = stripLoc(value, true);
+      }
+    }
+  }
+  return doc;
+}
+var experimentalFragmentVariables = false;
+function parseDocument(doc) {
+  var cacheKey = normalize(doc);
+  if (docCache[cacheKey]) {
+    return docCache[cacheKey];
+  }
+  var parsed = parse(doc, { experimentalFragmentVariables });
+  if (!parsed || parsed.kind !== "Document") {
+    throw new Error("Not a valid GraphQL document.");
+  }
+  parsed = processFragments(parsed);
+  parsed = stripLoc(parsed, false);
+  docCache[cacheKey] = parsed;
+  return parsed;
+}
+function enableExperimentalFragmentVariables() {
+  experimentalFragmentVariables = true;
+}
+function disableExperimentalFragmentVariables() {
+  experimentalFragmentVariables = false;
+}
+function gql() {
+  var args = Array.prototype.slice.call(arguments);
+  var literals = args[0];
+  var result = typeof literals === "string" ? literals : literals[0];
+  for (var i = 1; i < args.length; i++) {
+    if (args[i] && args[i].kind && args[i].kind === "Document") {
+      result += args[i].loc.source.body;
+    } else {
+      result += args[i];
+    }
+    result += literals[i];
+  }
+  return parseDocument(result);
+}
+gql.default = gql;
+gql.resetCaches = resetCaches;
+gql.disableFragmentWarnings = disableFragmentWarnings;
+gql.enableExperimentalFragmentVariables = enableExperimentalFragmentVariables;
+gql.disableExperimentalFragmentVariables = disableExperimentalFragmentVariables;
+var src = gql;
+const meQuery = src`
+  query Me {
+    me {
+      id
+      lawFirmId
+    }
+  }
+`;
+function useMe() {
+  const { result } = useQuery(meQuery);
+  return useResult(result);
+}
+function _isPlaceholder(a) {
+  return a != null && typeof a === "object" && a["@@functional/placeholder"] === true;
+}
+function _curry1(fn) {
+  return function f1(a) {
+    if (arguments.length === 0 || _isPlaceholder(a)) {
+      return f1;
+    } else {
+      return fn.apply(this, arguments);
+    }
+  };
+}
+function _curry2(fn) {
+  return function f2(a, b) {
+    switch (arguments.length) {
+      case 0:
+        return f2;
+      case 1:
+        return _isPlaceholder(a) ? f2 : _curry1(function(_b) {
+          return fn(a, _b);
+        });
+      default:
+        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function(_a) {
+          return fn(_a, b);
+        }) : _isPlaceholder(b) ? _curry1(function(_b) {
+          return fn(a, _b);
+        }) : fn(a, b);
+    }
+  };
+}
+function _isString(x) {
+  return Object.prototype.toString.call(x) === "[object String]";
+}
+var _isInteger = Number.isInteger || function _isInteger2(n) {
+  return n << 0 === n;
+};
+var nth = /* @__PURE__ */ _curry2(function nth2(offset, list) {
+  var idx = offset < 0 ? list.length + offset : offset;
+  return _isString(list) ? list.charAt(idx) : list[idx];
+});
+var nth$1 = nth;
+var paths = /* @__PURE__ */ _curry2(function paths2(pathsArray, obj) {
+  return pathsArray.map(function(paths3) {
+    var val = obj;
+    var idx = 0;
+    var p;
+    while (idx < paths3.length) {
+      if (val == null) {
+        return;
+      }
+      p = paths3[idx];
+      val = _isInteger(p) ? nth$1(p, val) : val[p];
+      idx += 1;
+    }
+    return val;
+  });
+});
+var paths$1 = paths;
+var path = /* @__PURE__ */ _curry2(function path2(pathAr, obj) {
+  return paths$1([pathAr], obj)[0];
+});
+var path$1 = path;
+const profilesQuery = src`
+  query ProfileSearch(
+    $lawFirmId: Int!
+    $keywords: String
+    $profileType: String
+  ) {
+    profileSearch(
+      query: {
+        lawFirmId: $lawFirmId
+        keywords: $keywords
+        profileType: $profileType
+      }
+    ) {
+      numResult
+      profileList(startIndex: 0, endIndex: 99) {
+        id
+        profileType
+        profileName
+      }
+    }
+  }
+`;
+const addProfileUserMutation = src`
+  mutation addProfileUser(
+    $email: String
+    $name: String
+    $petitionerProfileName: String
+    $lawFirmId: Int!
+  ) {
+    addProfileUserNoNotify(
+      email: $email
+      name: $name
+      petitionerProfileName: $petitionerProfileName
+      selfLawFirmId: $lawFirmId
+    ) {
+      profile {
+        id
+        profileName
+        profileType
+      }
+    }
+  }
+`;
+function useCreateProfile() {
+  const me = useMe();
+  const { mutate, loading } = useMutation(addProfileUserMutation);
+  const createProfile = async (profile) => {
+    var _a;
+    const variables = {
+      email: profile.email,
+      lawFirmId: (_a = me.value) == null ? void 0 : _a.lawFirmId
+    };
+    if (profile.profileType === "USERPROFILE") {
+      variables.name = profile.profileName;
+    } else {
+      variables.petitionerProfileName = profile.profileName;
+    }
+    const result = await mutate(variables);
+    return path$1(["data", "addProfileUserNoNotify", "profile"], result);
+  };
+  return { createProfile, loading };
+}
+const profileTypes = {
+  USERPROFILE: "Individual",
+  CLIENTPROFILE: "Company",
+  PREPARERPROFILE: "Attorney"
+};
+var __vue2_script$3 = defineComponent({
+  props: {
+    value: {
+      type: String
+    },
+    enabledTypes: {
+      type: Array,
+      default: ["USERPROFILE", "CLIENTPROFILE", "PREPARERPROFILE"]
+    }
+  },
+  components: {
+    Select,
+    Option: Select.Option,
+    ProfileTypeIcon
+  },
+  setup(_, { emit }) {
+    const handleChange = (value) => emit("input", value);
+    return { profileTypes, handleChange };
+  }
+});
+var render$3 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("Select", { attrs: { "value": _vm.value }, on: { "change": _vm.handleChange } }, _vm._l(_vm.enabledTypes, function(key) {
+    return _c("Option", { key, attrs: { "value": key } }, [_c("div", { staticClass: "flex items-center space-x-1" }, [_c("ProfileTypeIcon", { attrs: { "type": key } }), _c("div", { staticClass: "text-secondary" }, [_vm._v(_vm._s(_vm.profileTypes[key]))])], 1)]);
+  }), 1);
+};
+var staticRenderFns$3 = [];
+const __cssModules$3 = {};
+var __component__$3 = /* @__PURE__ */ normalizeComponent(__vue2_script$3, render$3, staticRenderFns$3, false, __vue2_injectStyles$3, null, null, null);
+function __vue2_injectStyles$3(context) {
+  for (let o in __cssModules$3) {
+    this[o] = __cssModules$3[o];
+  }
+}
+var ProfileTypeSelect = /* @__PURE__ */ function() {
+  return __component__$3.exports;
+}();
+var __vue2_script$2 = defineComponent({
+  components: {
+    Modal,
+    Form,
+    FormItem: Form.Item,
+    ProfileTypeSelect,
+    Input,
+    Checkbox
+  },
+  setup(_, { emit }) {
+    const value = ref({});
+    const shouldSendPassword = ref(false);
+    const canSubmit = computed(() => value.value.profileName && value.value.profileType);
+    const rules = {
+      profileType: { required: true },
+      profileName: { required: true },
+      email: { type: "email" }
+    };
+    const clearValue = () => value.value = {};
+    const { createProfile, loading } = useCreateProfile();
+    const hide = () => emit("cancel");
+    const handleSubmit = async () => {
+      const profile = await createProfile(value.value);
+      hide();
+      emit("profile-created", profile);
+    };
+    return {
+      value,
+      rules,
+      shouldSendPassword,
+      clearValue,
+      loading,
+      canSubmit,
+      handleSubmit
+    };
+  }
+});
+var render$2 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("modal", _vm._g(_vm._b({ attrs: { "closable": false, "ok-text": "Create", "width": 320, "okButtonProps": { props: { disabled: !_vm.canSubmit, loading: _vm.loading } } }, on: { "cancel": _vm.clearValue, "ok": _vm.handleSubmit } }, "modal", _vm.$attrs, false), _vm.$listeners), [_c("Form", { attrs: { "layout": "vertical", "validate-trigger": "blur", "model": _vm.value, "rules": _vm.rules } }, [_c("form-item", { attrs: { "label": "Profile type", "name": "profileType" } }, [_c("profile-type-select", { attrs: { "enabledTypes": ["USERPROFILE", "CLIENTPROFILE"] }, model: { value: _vm.value.profileType, callback: function($$v) {
+    _vm.$set(_vm.value, "profileType", $$v);
+  }, expression: "value.profileType" } })], 1), _c("form-item", { attrs: { "label": "Name", "name": "profileName" } }, [_c("Input", { model: { value: _vm.value.profileName, callback: function($$v) {
+    _vm.$set(_vm.value, "profileName", $$v);
+  }, expression: "value.profileName" } })], 1), _c("form-item", { attrs: { "label": "Email" } }, [_c("Input", { model: { value: _vm.value.email, callback: function($$v) {
+    _vm.$set(_vm.value, "email", $$v);
+  }, expression: "value.email" } })], 1), _c("form-item", [_c("checkbox", { model: { value: _vm.shouldSendPassword, callback: function($$v) {
+    _vm.shouldSendPassword = $$v;
+  }, expression: "shouldSendPassword" } }, [_vm._v("Send client portal login password (System will email client a login password)")])], 1)], 1)], 1);
+};
+var staticRenderFns$2 = [];
+const __cssModules$2 = {};
+var __component__$2 = /* @__PURE__ */ normalizeComponent(__vue2_script$2, render$2, staticRenderFns$2, false, __vue2_injectStyles$2, null, null, null);
+function __vue2_injectStyles$2(context) {
+  for (let o in __cssModules$2) {
+    this[o] = __cssModules$2[o];
+  }
+}
+var ProfileCreateModal = /* @__PURE__ */ function() {
+  return __component__$2.exports;
+}();
+var __vue2_script$1 = defineComponent({
+  props: {
+    value: {
+      type: Object
+    },
+    keywords: {
+      type: String,
+      required: true
+    },
+    source: {
+      type: Array,
+      required: true
+    }
+  },
+  components: {
+    Select,
+    Option: Select.Option,
+    Divider,
+    Button,
+    ProfileSelectItem,
+    ProfileCreateModal,
+    VNodes: {
+      functional: true,
+      render: (_, ctx) => ctx.props.vnodes
+    }
+  },
+  setup(props, { emit }) {
+    const selectedId = computed(() => {
+      var _a;
+      return (_a = props.value) == null ? void 0 : _a.id;
+    });
+    const handleSelect = (value) => emit("input", props.source.find((v) => String(v.id) == value));
+    const handleProfileCreate = () => emit("create-profile");
+    return {
+      selectedId,
+      handleSelect,
+      handleProfileCreate,
+      menu: {}
+    };
+  }
+});
+var render$1 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("Select", _vm._g(_vm._b({ staticClass: "w-72", attrs: { "allowClear": "", "showSearch": "", "optionFilterProp": "name", "value": _vm.selectedId }, on: { "select": _vm.handleSelect }, scopedSlots: _vm._u([{ key: "dropdownRender", fn: function(menu) {
+    return _c("div", {}, [_c("v-nodes", { attrs: { "vnodes": menu } }), _c("Divider", { staticClass: "my-1" }), _c("div", { staticClass: "flex justify-end px-3 py-1" }, [_c("Button", { attrs: { "size": "small" }, on: { "click": _vm.handleProfileCreate } }, [_vm._v("Create new profile")])], 1)], 1);
+  } }]) }, "Select", _vm.$attrs, false), _vm.$listeners), _vm._l(_vm.source, function(v) {
+    return _c("Option", { key: v.id, attrs: { "value": v.id } }, [_c("ProfileSelectItem", { attrs: { "source": v } })], 1);
+  }), 1);
+};
+var staticRenderFns$1 = [];
+const __cssModules$1 = {};
+var __component__$1 = /* @__PURE__ */ normalizeComponent(__vue2_script$1, render$1, staticRenderFns$1, false, __vue2_injectStyles$1, null, null, null);
+function __vue2_injectStyles$1(context) {
+  for (let o in __cssModules$1) {
+    this[o] = __cssModules$1[o];
+  }
+}
+var ProfileSelector = /* @__PURE__ */ function() {
+  return __component__$1.exports;
+}();
+function useProfiles(keywords) {
+  const me = useMe();
+  const { result, loading } = useQuery(profilesQuery, () => {
+    var _a;
+    return {
+      lawFirmId: (_a = me.value) == null ? void 0 : _a.lawFirmId,
+      keywords: keywords.value
+    };
+  }, () => ({
+    enabled: me.value != null
+  }));
+  const profiles = useResult(result, [], (data) => data.profileSearch.profileList);
+  return { profiles, loading };
+}
+var __vue2_script = defineComponent({
+  components: { ProfileSelector, ProfileCreateModal },
+  props: {
+    value: {
+      type: Object
+    }
+  },
+  setup(_, { emit }) {
+    const keywords = ref("");
+    const handleSearch = (value) => keywords.value = value;
+    const { profiles: rawProfiles } = useProfiles(keywords);
+    const createdProfile = ref();
+    const profiles = computed(() => createdProfile.value ? [createdProfile.value, ...rawProfiles.value] : rawProfiles.value);
+    const isModalVisible = ref(false);
+    const toggleModal = (value) => isModalVisible.value = value;
+    const updateValue = (value) => emit("input", value);
+    const handleProfileCreated = (profile) => {
+      createdProfile.value = profile;
+      updateValue(profile);
+    };
+    return {
+      profiles,
+      isModalVisible,
+      toggleModal,
+      updateValue,
+      handleProfileCreated,
+      keywords,
+      handleSearch
+    };
+  }
+});
+var render = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", [_c("profile-selector", _vm._g(_vm._b({ attrs: { "source": _vm.profiles, "value": _vm.value, "keywords": _vm.keywords }, on: { "search": _vm.handleSearch, "create-profile": function($event) {
+    return _vm.toggleModal(true);
+  }, "input": _vm.updateValue } }, "profile-selector", _vm.$attrs, false), _vm.$listeners)), _c("profile-create-modal", { attrs: { "visible": _vm.isModalVisible }, on: { "cancel": function($event) {
+    return _vm.toggleModal(false);
+  }, "profile-created": _vm.handleProfileCreated } })], 1);
+};
+var staticRenderFns = [];
+const __cssModules = {};
+var __component__ = /* @__PURE__ */ normalizeComponent(__vue2_script, render, staticRenderFns, false, __vue2_injectStyles, null, null, null);
+function __vue2_injectStyles(context) {
+  for (let o in __cssModules) {
+    this[o] = __cssModules[o];
+  }
+}
+var index = /* @__PURE__ */ function() {
+  return __component__.exports;
+}();
+export { index as ProfileSelect };