@effect/language-service 0.13.0 → 0.14.0

package/transform.js

@@ -0,0 +1,1894 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transform.ts
+var transform_exports = {};
+__export(transform_exports, {
+  default: () => transform_default
+});
+module.exports = __toCommonJS(transform_exports);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Function.js
+var isFunction = (input) => typeof input === "function";
+var dual = function(arity, body) {
+  if (typeof arity === "function") {
+    return function() {
+      if (arity(arguments)) {
+        return body.apply(this, arguments);
+      }
+      return (self) => body(self, ...arguments);
+    };
+  }
+  switch (arity) {
+    case 0:
+    case 1:
+      throw new RangeError(`Invalid arity ${arity}`);
+    case 2:
+      return function(a, b) {
+        if (arguments.length >= 2) {
+          return body(a, b);
+        }
+        return function(self) {
+          return body(self, a);
+        };
+      };
+    case 3:
+      return function(a, b, c) {
+        if (arguments.length >= 3) {
+          return body(a, b, c);
+        }
+        return function(self) {
+          return body(self, a, b);
+        };
+      };
+    case 4:
+      return function(a, b, c, d) {
+        if (arguments.length >= 4) {
+          return body(a, b, c, d);
+        }
+        return function(self) {
+          return body(self, a, b, c);
+        };
+      };
+    case 5:
+      return function(a, b, c, d, e) {
+        if (arguments.length >= 5) {
+          return body(a, b, c, d, e);
+        }
+        return function(self) {
+          return body(self, a, b, c, d);
+        };
+      };
+    default:
+      return function() {
+        if (arguments.length >= arity) {
+          return body.apply(this, arguments);
+        }
+        const args = arguments;
+        return function(self) {
+          return body(self, ...args);
+        };
+      };
+  }
+};
+var identity = (a) => a;
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default: {
+      let ret = arguments[0];
+      for (let i = 1; i < arguments.length; i++) {
+        ret = arguments[i](ret);
+      }
+      return ret;
+    }
+  }
+}
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.12.5";
+var getCurrentVersion = () => moduleVersion;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
+var globalStore;
+var globalValue = (id, compute) => {
+  if (!globalStore) {
+    globalThis[globalStoreId] ??= /* @__PURE__ */ new Map();
+    globalStore = globalThis[globalStoreId];
+  }
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id);
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Predicate.js
+var isFunction2 = isFunction;
+var isRecordOrArray = (input) => typeof input === "object" && input !== null;
+var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
+var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/errors.js
+var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Utils.js
+var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
+var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
+var GenKindImpl = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _F() {
+    return identity;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _R() {
+    return (_) => _;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _O() {
+    return (_) => _;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _E() {
+    return (_) => _;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [GenKindTypeId] = GenKindTypeId;
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+};
+var SingleShotGen = class _SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  /**
+   * @since 2.0.0
+   */
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  /**
+   * @since 2.0.0
+   */
+  return(a) {
+    return {
+      value: a,
+      done: true
+    };
+  }
+  /**
+   * @since 2.0.0
+   */
+  throw(e) {
+    throw e;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+var MUL_HI = 1481765933 >>> 0;
+var MUL_LO = 1284865837 >>> 0;
+var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
+var YieldWrap = class {
+  /**
+   * @since 3.0.6
+   */
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  /**
+   * @since 3.0.6
+   */
+  [YieldWrapTypeId]() {
+    return this.#value;
+  }
+};
+function yieldWrapGet(self) {
+  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
+    return self[YieldWrapTypeId]();
+  }
+  throw new Error(getBugErrorMessage("yieldWrapGet"));
+}
+var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
+  enabled: false,
+  tester: void 0
+}));
+var genConstructor = function* () {
+}.constructor;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Hash.js
+var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
+var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
+var hash = (self) => {
+  if (structuralRegionState.enabled === true) {
+    return 0;
+  }
+  switch (typeof self) {
+    case "number":
+      return number(self);
+    case "bigint":
+      return string(self.toString(10));
+    case "boolean":
+      return string(String(self));
+    case "symbol":
+      return string(String(self));
+    case "string":
+      return string(self);
+    case "undefined":
+      return string("undefined");
+    case "function":
+    case "object": {
+      if (self === null) {
+        return string("null");
+      } else if (self instanceof Date) {
+        return hash(self.toISOString());
+      } else if (isHash(self)) {
+        return self[symbol]();
+      } else {
+        return random(self);
+      }
+    }
+    default:
+      throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
+  }
+};
+var random = (self) => {
+  if (!randomHashCache.has(self)) {
+    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
+  }
+  return randomHashCache.get(self);
+};
+var combine = (b) => (self) => self * 53 ^ b;
+var optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
+var isHash = (u) => hasProperty(u, symbol);
+var number = (n) => {
+  if (n !== n || n === Infinity) {
+    return 0;
+  }
+  let h = n | 0;
+  if (h !== n) {
+    h ^= n * 4294967295;
+  }
+  while (n > 4294967295) {
+    h ^= n /= 4294967295;
+  }
+  return optimize(h);
+};
+var string = (str) => {
+  let h = 5381, i = str.length;
+  while (i) {
+    h = h * 33 ^ str.charCodeAt(--i);
+  }
+  return optimize(h);
+};
+var structureKeys = (o, keys) => {
+  let h = 12289;
+  for (let i = 0; i < keys.length; i++) {
+    h ^= pipe(string(keys[i]), combine(hash(o[keys[i]])));
+  }
+  return optimize(h);
+};
+var structure = (o) => structureKeys(o, Object.keys(o));
+var cached = function() {
+  if (arguments.length === 1) {
+    const self2 = arguments[0];
+    return function(hash3) {
+      Object.defineProperty(self2, symbol, {
+        value() {
+          return hash3;
+        },
+        enumerable: false
+      });
+      return hash3;
+    };
+  }
+  const self = arguments[0];
+  const hash2 = arguments[1];
+  Object.defineProperty(self, symbol, {
+    value() {
+      return hash2;
+    },
+    enumerable: false
+  });
+  return hash2;
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Equal.js
+var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
+function equals() {
+  if (arguments.length === 1) {
+    return (self) => compareBoth(self, arguments[0]);
+  }
+  return compareBoth(arguments[0], arguments[1]);
+}
+function compareBoth(self, that) {
+  if (self === that) {
+    return true;
+  }
+  const selfType = typeof self;
+  if (selfType !== typeof that) {
+    return false;
+  }
+  if (selfType === "object" || selfType === "function") {
+    if (self !== null && that !== null) {
+      if (isEqual(self) && isEqual(that)) {
+        if (hash(self) === hash(that) && self[symbol2](that)) {
+          return true;
+        } else {
+          return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+        }
+      } else if (self instanceof Date && that instanceof Date) {
+        return self.toISOString() === that.toISOString();
+      }
+    }
+    if (structuralRegionState.enabled) {
+      if (Array.isArray(self) && Array.isArray(that)) {
+        return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
+      }
+      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
+        const keysSelf = Object.keys(self);
+        const keysThat = Object.keys(that);
+        if (keysSelf.length === keysThat.length) {
+          for (const key of keysSelf) {
+            if (!(key in that && compareBoth(self[key], that[key]))) {
+              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+            }
+          }
+          return true;
+        }
+      }
+      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+    }
+  }
+  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+}
+var isEqual = (u) => hasProperty(u, symbol2);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Inspectable.js
+var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var toJSON = (x) => {
+  try {
+    if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
+      return x.toJSON();
+    } else if (Array.isArray(x)) {
+      return x.map(toJSON);
+    }
+  } catch (_) {
+    return {};
+  }
+  return redact(x);
+};
+var format = (x) => JSON.stringify(x, null, 2);
+var BaseProto = {
+  toJSON() {
+    return toJSON(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var Class = class {
+  /**
+   * @since 2.0.0
+   */
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  /**
+   * @since 2.0.0
+   */
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var symbolRedactable = /* @__PURE__ */ Symbol.for("effect/Inspectable/Redactable");
+var isRedactable = (u) => typeof u === "object" && u !== null && symbolRedactable in u;
+var redactableState = /* @__PURE__ */ globalValue("effect/Inspectable/redactableState", () => ({
+  fiberRefs: void 0
+}));
+var redact = (u) => {
+  if (isRedactable(u) && redactableState.fiberRefs !== void 0) {
+    return u[symbolRedactable](redactableState.fiberRefs);
+  }
+  return u;
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Pipeable.js
+var pipeArguments = (self, args) => {
+  switch (args.length) {
+    case 0:
+      return self;
+    case 1:
+      return args[0](self);
+    case 2:
+      return args[1](args[0](self));
+    case 3:
+      return args[2](args[1](args[0](self)));
+    case 4:
+      return args[3](args[2](args[1](args[0](self))));
+    case 5:
+      return args[4](args[3](args[2](args[1](args[0](self)))));
+    case 6:
+      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+    case 7:
+      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+    case 8:
+      return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+    case 9:
+      return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+    default: {
+      let ret = self;
+      for (let i = 0, len = args.length; i < len; i++) {
+        ret = args[i](ret);
+      }
+      return ret;
+    }
+  }
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/opCodes/effect.js
+var OP_COMMIT = "Commit";
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/effectable.js
+var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
+var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
+var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
+var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
+var effectVariance = {
+  /* c8 ignore next */
+  _R: (_) => _,
+  /* c8 ignore next */
+  _E: (_) => _,
+  /* c8 ignore next */
+  _A: (_) => _,
+  _V: /* @__PURE__ */ getCurrentVersion()
+};
+var sinkVariance = {
+  /* c8 ignore next */
+  _A: (_) => _,
+  /* c8 ignore next */
+  _In: (_) => _,
+  /* c8 ignore next */
+  _L: (_) => _,
+  /* c8 ignore next */
+  _E: (_) => _,
+  /* c8 ignore next */
+  _R: (_) => _
+};
+var channelVariance = {
+  /* c8 ignore next */
+  _Env: (_) => _,
+  /* c8 ignore next */
+  _InErr: (_) => _,
+  /* c8 ignore next */
+  _InElem: (_) => _,
+  /* c8 ignore next */
+  _InDone: (_) => _,
+  /* c8 ignore next */
+  _OutErr: (_) => _,
+  /* c8 ignore next */
+  _OutElem: (_) => _,
+  /* c8 ignore next */
+  _OutDone: (_) => _
+};
+var EffectPrototype = {
+  [EffectTypeId]: effectVariance,
+  [StreamTypeId]: effectVariance,
+  [SinkTypeId]: sinkVariance,
+  [ChannelTypeId]: channelVariance,
+  [symbol2](that) {
+    return this === that;
+  },
+  [symbol]() {
+    return cached(this, random(this));
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var StructuralPrototype = {
+  [symbol]() {
+    return cached(this, structure(this));
+  },
+  [symbol2](that) {
+    const selfKeys = Object.keys(this);
+    const thatKeys = Object.keys(that);
+    if (selfKeys.length !== thatKeys.length) {
+      return false;
+    }
+    for (const key of selfKeys) {
+      if (!(key in that && equals(this[key], that[key]))) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var CommitPrototype = {
+  ...EffectPrototype,
+  _op: OP_COMMIT
+};
+var StructuralCommitPrototype = {
+  ...CommitPrototype,
+  ...StructuralPrototype
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/option.js
+var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
+var CommonProto = {
+  ...EffectPrototype,
+  [TypeId]: {
+    _A: (_) => _
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
+  _tag: "Some",
+  _op: "Some",
+  [symbol2](that) {
+    return isOption(that) && isSome(that) && equals(this.value, that.value);
+  },
+  [symbol]() {
+    return cached(this, combine(hash(this._tag))(hash(this.value)));
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag,
+      value: toJSON(this.value)
+    };
+  }
+});
+var NoneHash = /* @__PURE__ */ hash("None");
+var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
+  _tag: "None",
+  _op: "None",
+  [symbol2](that) {
+    return isOption(that) && isNone(that);
+  },
+  [symbol]() {
+    return NoneHash;
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag
+    };
+  }
+});
+var isOption = (input) => hasProperty(input, TypeId);
+var isNone = (fa) => fa._tag === "None";
+var isSome = (fa) => fa._tag === "Some";
+var none = /* @__PURE__ */ Object.create(NoneProto);
+var some = (value) => {
+  const a = Object.create(SomeProto);
+  a.value = value;
+  return a;
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/either.js
+var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
+var CommonProto2 = {
+  ...EffectPrototype,
+  [TypeId2]: {
+    _R: (_) => _
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Right",
+  _op: "Right",
+  [symbol2](that) {
+    return isEither(that) && isRight(that) && equals(this.right, that.right);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.right));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    };
+  }
+});
+var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Left",
+  _op: "Left",
+  [symbol2](that) {
+    return isEither(that) && isLeft(that) && equals(this.left, that.left);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.left));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    };
+  }
+});
+var isEither = (input) => hasProperty(input, TypeId2);
+var isLeft = (ma) => ma._tag === "Left";
+var isRight = (ma) => ma._tag === "Right";
+var left = (left3) => {
+  const a = Object.create(LeftProto);
+  a.left = left3;
+  return a;
+};
+var right = (right3) => {
+  const a = Object.create(RightProto);
+  a.right = right3;
+  return a;
+};
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Either.js
+var right2 = right;
+var left2 = left;
+var isLeft2 = isLeft;
+var isRight2 = isRight;
+var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
+var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Order.js
+var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Option.js
+var none2 = () => none;
+var some2 = some;
+var isNone2 = isNone;
+var isSome2 = isSome;
+var match = /* @__PURE__ */ dual(2, (self, {
+  onNone,
+  onSome
+}) => isNone2(self) ? onNone() : onSome(self.value));
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
+var isArray = Array.isArray;
+var isEmptyArray = (self) => self.length === 0;
+var isEmptyReadonlyArray = isEmptyArray;
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
+var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
+  if (isEmptyReadonlyArray(self)) {
+    return [];
+  }
+  const out = [];
+  for (let i = 0; i < self.length; i++) {
+    const inner = f(self[i], i);
+    for (let j = 0; j < inner.length; j++) {
+      out.push(inner[j]);
+    }
+  }
+  return out;
+});
+var flatten = /* @__PURE__ */ flatMap(identity);
+
+// src/core/Nano.ts
+var NanoDefectException = class {
+  constructor(message) {
+    this.message = message;
+  }
+  _tag = "@effect/language-service/NanoDefectException";
+};
+var NanoTag = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+var Tag = (identifier) => new NanoTag(identifier);
+var contextEmpty = { value: {} };
+var contextAdd = (context, tag, value) => ({
+  ...context,
+  value: {
+    ...context.value,
+    [tag.key]: value
+  }
+});
+var contextGet = (context, tag) => {
+  if (tag.key in context.value) {
+    return some2(context.value[tag.key]);
+  }
+  return none2();
+};
+var Nano = class {
+  constructor(run2) {
+    this.run = run2;
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  }
+};
+var unsafeRun = (fa) => {
+  const result = fa.run(contextEmpty);
+  switch (result._tag) {
+    case "Left":
+      return left2(result.left);
+    case "Defect":
+      return left2(new NanoDefectException(result.defect));
+    case "Right":
+      return right2(result.right);
+  }
+};
+var run = (fa) => {
+  try {
+    return unsafeRun(fa);
+  } catch (e) {
+    return left2(new NanoDefectException(e));
+  }
+};
+var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
+var fail = (value) => new Nano(() => ({ _tag: "Left", left: value }));
+var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
+var flatMap2 = dual(2, (fa, f) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (result._tag !== "Right") return result;
+  return f(result.right).run(ctx);
+}));
+var map3 = dual(2, (fa, f) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (result._tag !== "Right") return result;
+  return { _tag: "Right", right: f(result.right) };
+}));
+var orElse = (f) => (fa) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  if (result._tag === "Left") return f().run(ctx);
+  return result;
+});
+var service = (tag) => new Nano(
+  (ctx) => contextGet(ctx, tag).pipe(match({
+    onNone: () => ({ _tag: "Defect", defect: `Cannot find service ${tag.key}` }),
+    onSome: (value) => ({ _tag: "Right", right: value })
+  }))
+);
+var provideService = (tag, value) => (fa) => new Nano((ctx) => {
+  return fa.run(contextAdd(ctx, tag, value));
+});
+var gen = (...args) => new Nano((ctx) => {
+  const iterator = args[0]();
+  let state = iterator.next();
+  while (!state.done) {
+    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
+    const result = current.run(ctx);
+    if (result._tag !== "Right") {
+      return result;
+    }
+    state = iterator.next(result.right);
+  }
+  return { _tag: "Right", right: state.value };
+});
+var fn = (_) => (body) => (...args) => new Nano((ctx) => {
+  const iterator = body(...args);
+  let state = iterator.next();
+  while (!state.done) {
+    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
+    const result = current.run(ctx);
+    if (result._tag !== "Right") {
+      return result;
+    }
+    state = iterator.next(result.right);
+  }
+  return { _tag: "Right", right: state.value };
+});
+var option = (fa) => new Nano((ctx) => {
+  const result = fa.run(ctx);
+  switch (result._tag) {
+    case "Right":
+      return { _tag: "Right", right: some2(result.right) };
+    case "Left":
+      return { _tag: "Right", right: none2() };
+    case "Defect":
+      return result;
+  }
+});
+
+// src/core/TypeScriptApi.ts
+var TypeScriptApi = Tag("TypeScriptApi");
+var TypeScriptProgram = Tag("TypeScriptProgram");
+var ChangeTracker = Tag("ChangeTracker");
+
+// src/core/LSP.ts
+var RefactorNotApplicableError = class {
+  _tag = "@effect/language-service/RefactorNotApplicableError";
+};
+function createDiagnostic(definition) {
+  return definition;
+}
+function parsePluginOptions(config) {
+  return {
+    diagnostics: config && "diagnostics" in config && typeof config.diagnostics === "boolean" ? config.diagnostics : true,
+    quickinfo: config && "quickinfo" in config && typeof config.quickinfo === "boolean" ? config.quickinfo : true,
+    completions: config && "completions" in config && typeof config.completions === "boolean" ? config.completions : true,
+    multipleEffectCheck: config && "multipleEffectCheck" in config && typeof config.multipleEffectCheck === "boolean" ? config.multipleEffectCheck : true
+  };
+}
+var PluginOptions = Tag("PluginOptions");
+var getSemanticDiagnosticsWithCodeFixes = fn("LSP.getSemanticDiagnostics")(function* (rules, sourceFile) {
+  const effectDiagnostics = [];
+  const effectCodeFixes = [];
+  const executor = yield* createDiagnosticExecutor(sourceFile);
+  for (const rule of rules) {
+    const result = yield* option(executor.execute(rule));
+    if (isSome2(result)) {
+      effectDiagnostics.push(
+        ...pipe(
+          result.value,
+          map2((_) => ({
+            file: sourceFile,
+            start: _.node.getStart(sourceFile),
+            length: _.node.getEnd() - _.node.getStart(sourceFile),
+            messageText: _.messageText,
+            category: _.category,
+            code: rule.code,
+            source: "effect"
+          }))
+        )
+      );
+      effectCodeFixes.push(
+        ...pipe(
+          result.value,
+          map2(
+            (_) => map2(
+              _.fixes,
+              (fix) => ({
+                ...fix,
+                code: rule.code,
+                start: _.node.getStart(sourceFile),
+                end: _.node.getEnd()
+              })
+            )
+          ),
+          flatten
+        )
+      );
+    }
+  }
+  return {
+    diagnostics: effectDiagnostics,
+    codeFixes: effectCodeFixes
+  };
+});
+var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refactors, sourceFile, positionOrRange) {
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  const effectRefactors = [];
+  for (const refactor of refactors) {
+    const result = yield* option(refactor.apply(sourceFile, textRange));
+    if (isSome2(result)) {
+      effectRefactors.push({
+        name: refactor.name,
+        description: refactor.description,
+        actions: [{
+          name: refactor.name,
+          description: result.value.description,
+          kind: result.value.kind
+        }]
+      });
+    }
+  }
+  return effectRefactors;
+});
+var getEditsForRefactor = fn("LSP.getEditsForRefactor")(function* (refactors, sourceFile, positionOrRange, refactorName) {
+  const refactor = refactors.find((refactor2) => refactor2.name === refactorName);
+  if (!refactor) {
+    return yield* fail(new RefactorNotApplicableError());
+  }
+  const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
+  return yield* refactor.apply(sourceFile, textRange);
+});
+var getCompletionsAtPosition = fn("LSP.getCompletionsAtPosition")(function* (completions, sourceFile, position, options, formatCodeSettings) {
+  const effectCompletions = [];
+  for (const completion of completions) {
+    const result = yield* completion.apply(sourceFile, position, options, formatCodeSettings);
+    effectCompletions.push(
+      ...result.map((_) => ({ sortText: "11", ..._ }))
+    );
+  }
+  return effectCompletions;
+});
+var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
+  function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const ruleOverrides = {};
+    const skippedRules = [];
+    const regex = /@effect-diagnostics((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
+    let match2;
+    while ((match2 = regex.exec(sourceFile.text)) !== null) {
+      const rulesCaptureGroup = match2[1];
+      if (rulesCaptureGroup) {
+        const trimmedRuleString = rulesCaptureGroup.trim();
+        if (trimmedRuleString) {
+          const individualRules = trimmedRuleString.split(/\s+/);
+          for (const rulePair of individualRules) {
+            const [ruleName, ruleLevel] = rulePair.toLowerCase().split(":");
+            if (ruleName && ruleLevel) {
+              if (ruleLevel === "skip-file") skippedRules.push(ruleName);
+              ruleOverrides[ruleName] = ruleOverrides[ruleName] || [];
+              const newLength = ruleOverrides[ruleName].push({
+                start: match2.index,
+                end: Number.MAX_SAFE_INTEGER,
+                level: ruleLevel
+              });
+              if (newLength > 1) ruleOverrides[ruleName][newLength - 2].end = match2.index;
+            }
+          }
+        }
+      }
+    }
+    const levelToDiagnosticCategory = {
+      error: ts.DiagnosticCategory.Error,
+      warning: ts.DiagnosticCategory.Warning,
+      message: ts.DiagnosticCategory.Message,
+      suggestion: ts.DiagnosticCategory.Suggestion
+    };
+    const execute = fn("LSP.ruleExecutor")(function* (rule) {
+      const ruleNameLowered = rule.name.toLowerCase();
+      if (skippedRules.indexOf(ruleNameLowered) > -1) return [];
+      let modifiedDiagnostics = yield* rule.apply(sourceFile);
+      for (const override of ruleOverrides[ruleNameLowered] || []) {
+        if (override.level === "off") {
+          modifiedDiagnostics = modifiedDiagnostics.filter(
+            (_) => !(_.node.getStart(sourceFile) >= override.start && _.node.getEnd() <= override.end)
+          );
+        } else {
+          for (const message of modifiedDiagnostics.filter(
+            (_) => _.node.getStart(sourceFile) >= override.start && _.node.getEnd() <= override.end
+          )) {
+            message.category = override.level in levelToDiagnosticCategory ? levelToDiagnosticCategory[override.level] : message.category;
+          }
+        }
+      }
+      const fixByDisableEntireFile = {
+        fixName: rule.name + "_skipFile",
+        description: "Disable " + rule.name + " for this file",
+        apply: flatMap2(
+          service(ChangeTracker),
+          (changeTracker) => sync(
+            () => changeTracker.insertText(
+              sourceFile,
+              0,
+              `/** @effect-diagnostics ${rule.name}:skip-file */
+`
+            )
+          )
+        )
+      };
+      const rulesWithDisableFix = modifiedDiagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        fixes: diagnostic.fixes.concat([fixByDisableEntireFile])
+      }));
+      return rulesWithDisableFix;
+    });
+    return { execute };
+  }
+);
+
+// src/core/TypeCheckerApi.ts
+var TypeCheckerApi = Tag("TypeChecker");
+var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
+function makeTypeCheckerApiCache() {
+  return {
+    expectedAndRealType: /* @__PURE__ */ new WeakMap()
+  };
+}
+var deterministicTypeOrder = gen(function* () {
+  const typeChecker = yield* service(TypeCheckerApi);
+  return make((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+});
+var getMissingTypeEntriesInTargetType = fn(
+  "TypeCheckerApi.getMissingTypeEntriesInTargetType"
+)(
+  function* (realType, expectedType) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const result = [];
+    const toTest = [realType];
+    while (toTest.length > 0) {
+      const type = toTest.pop();
+      if (!type) return result;
+      if (type.isUnion()) {
+        toTest.push(...type.types);
+      } else {
+        const assignable = typeChecker.isTypeAssignableTo(type, expectedType);
+        if (!assignable) {
+          result.push(type);
+        }
+      }
+    }
+    return result;
+  }
+);
+var CannotFindAncestorConvertibleDeclarationError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
+};
+var getAncestorConvertibleDeclaration = fn(
+  "TypeCheckerApi.getAncestorConvertibleDeclaration"
+)(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  let current = node;
+  while (current) {
+    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
+});
+var CannotInferReturnTypeFromEmptyBody = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
+};
+var CannotInferReturnType = class {
+  constructor(declaration) {
+    this.declaration = declaration;
+  }
+  _tag = "@effect/language-service/CannotInferReturnType";
+};
+var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  if (!declaration.body) {
+    return yield* fail(
+      new CannotInferReturnTypeFromEmptyBody(declaration)
+    );
+  }
+  let returnType;
+  if (typeChecker.isImplementationOfOverload(declaration)) {
+    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+    if (signatures.length > 1) {
+      returnType = typeChecker.getUnionType(
+        signatures.map((s) => s.getReturnType()).filter((_) => !!_)
+      );
+    }
+  }
+  if (!returnType) {
+    const signature = typeChecker.getSignatureFromDeclaration(declaration);
+    if (signature) {
+      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+      if (typePredicate && typePredicate.type) {
+        return typePredicate.type;
+      } else {
+        returnType = typeChecker.getReturnTypeOfSignature(signature);
+      }
+    }
+  }
+  if (!returnType) {
+    return yield* fail(
+      new CannotInferReturnType(declaration)
+    );
+  }
+  return returnType;
+});
+var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
+  const cache = yield* service(TypeCheckerApiCache);
+  const resultCached = cache.expectedAndRealType.get(sourceFile);
+  if (resultCached) return resultCached;
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
+  const result = [];
+  const nodeToVisit = [sourceFile];
+  const appendNodeToVisit = (node) => {
+    nodeToVisit.push(node);
+    return void 0;
+  };
+  while (nodeToVisit.length > 0) {
+    const node = nodeToVisit.shift();
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      result.push([node.name, expectedType, node.initializer, realType]);
+      appendNodeToVisit(node.initializer);
+      continue;
+    } else if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          result.push([
+            node.arguments[index],
+            expectedType,
+            node.arguments[index],
+            realType
+          ]);
+        });
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      }
+    } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      const parent = node.parent;
+      if (ts.isObjectLiteralElement(parent)) {
+        if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+          const type = typeChecker.getContextualType(parent.parent);
+          if (type) {
+            const symbol3 = typeChecker.getPropertyOfType(type, node.text);
+            if (symbol3) {
+              const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+              const realType = typeChecker.getTypeAtLocation(node);
+              result.push([node, expectedType, node, realType]);
+              ts.forEachChild(node, appendNodeToVisit);
+              continue;
+            }
+          }
+        }
+      }
+    } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      result.push([node.left, expectedType, node.right, realType]);
+      appendNodeToVisit(node.right);
+      continue;
+    } else if (ts.isReturnStatement(node) && node.expression) {
+      const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
+      if (isSome2(parentDeclaration)) {
+        const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        if (isSome2(expectedType)) {
+          result.push([node, expectedType.value, node, realType]);
+          ts.forEachChild(node, appendNodeToVisit);
+          continue;
+        }
+      }
+    } else if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) {
+        result.push([body, expectedType, body, realType]);
+        appendNodeToVisit(body);
+        continue;
+      }
+    } else if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      result.push([node.expression, expectedType, node.expression, realType]);
+      appendNodeToVisit(node.expression);
+      continue;
+    }
+    ts.forEachChild(node, appendNodeToVisit);
+  }
+  cache.expectedAndRealType.set(sourceFile, result);
+  return result;
+});
+
+// src/utils/TypeParser.ts
+var TypeParserIssue = class {
+  constructor(type, node, message) {
+    this.type = type;
+    this.node = node;
+    this.message = message;
+  }
+  _tag = "@effect/language-service/TypeParserIssue";
+};
+function typeParserIssue(message, type, node) {
+  return fail(new TypeParserIssue(type, node, message));
+}
+function covariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Covariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getReturnType());
+}
+function invariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Invariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getReturnType());
+}
+var pipeableType = fn("TypeParser.pipeableType")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+  if (!pipeSymbol) {
+    return yield* typeParserIssue("Type has no 'pipe' property", type, atLocation);
+  }
+  const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+  const signatures = pipeType.getCallSignatures();
+  if (signatures.length === 0) {
+    return yield* typeParserIssue("'pipe' property is not callable", type, atLocation);
+  }
+  return type;
+});
+var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
+  function* (type, atLocation, propertyName) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* covariantTypeArgument(propertyType);
+  }
+);
+var varianceStructInvariantType = fn("TypeParser.varianceStructInvariantType")(
+  function* (type, atLocation, propertyName) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* invariantTypeArgument(propertyType);
+  }
+);
+var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type, atLocation) {
+  return {
+    A: yield* varianceStructCovariantType(type, atLocation, "_A"),
+    E: yield* varianceStructCovariantType(type, atLocation, "_E"),
+    R: yield* varianceStructCovariantType(type, atLocation, "_R")
+  };
+});
+var effectType = fn("TypeParser.effectType")(function* (type, atLocation) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  yield* pipeableType(type, atLocation);
+  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  );
+  propertiesSymbols.sort((a, b) => b.name.indexOf("EffectTypeId") - a.name.indexOf("EffectTypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(effectVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
+    }
+  }
+  return yield* typeParserIssue("Type has no effect variance struct", type, atLocation);
+});
+var fiberType = fn("TypeParser.fiberType")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const awaitSymbol = typeChecker.getPropertyOfType(type, "await");
+  const pollSymbol = typeChecker.getPropertyOfType(type, "poll");
+  if (!awaitSymbol || !pollSymbol) {
+    return yield* typeParserIssue(
+      "Type is not a fiber because it does not have 'await' or 'poll' property",
+      type,
+      atLocation
+    );
+  }
+  return yield* effectType(type, atLocation);
+});
+var effectSubtype = fn("TypeParser.effectSubtype")(function* (type, atLocation) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const tagSymbol = typeChecker.getPropertyOfType(type, "_tag");
+  if (!tagSymbol) {
+    return yield* typeParserIssue(
+      "Type is not a subtype of effect because it does not have '_tag' property",
+      type,
+      atLocation
+    );
+  }
+  return yield* effectType(type, atLocation);
+});
+var importedEffectModule = fn("TypeParser.importedEffectModule")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const type = typeChecker.getTypeAtLocation(node);
+  const propertySymbol = typeChecker.getPropertyOfType(type, "never");
+  if (!propertySymbol) {
+    return yield* typeParserIssue("Type has no 'never' property", type, node);
+  }
+  if (!ts.isExpression(node)) {
+    return yield* typeParserIssue("Node is not an expression", type, node);
+  }
+  const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+  yield* effectType(propertyType, node);
+  return node;
+});
+var effectGen = fn("TypeParser.effectGen")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  if (!ts.isCallExpression(node)) {
+    return yield* typeParserIssue("Node is not a call expression", void 0, node);
+  }
+  if (node.arguments.length === 0) {
+    return yield* typeParserIssue("Node has no arguments", void 0, node);
+  }
+  const generatorFunction = node.arguments[0];
+  if (!ts.isFunctionExpression(generatorFunction)) {
+    return yield* typeParserIssue("Node is not a function expression", void 0, node);
+  }
+  if (generatorFunction.asteriskToken === void 0) {
+    return yield* typeParserIssue("Node is not a generator function", void 0, node);
+  }
+  if (!ts.isPropertyAccessExpression(node.expression)) {
+    return yield* typeParserIssue("Node is not a property access expression", void 0, node);
+  }
+  const propertyAccess = node.expression;
+  if (propertyAccess.name.text !== "gen") {
+    return yield* typeParserIssue("Call expression name is not 'gen'", void 0, node);
+  }
+  const effectModule = yield* importedEffectModule(propertyAccess.expression);
+  return {
+    node,
+    effectModule,
+    generatorFunction,
+    body: generatorFunction.body,
+    functionStar: generatorFunction.getFirstToken()
+  };
+});
+var effectFnUntracedGen = fn("TypeParser.effectFnUntracedGen")(
+  function* (node) {
+    const ts = yield* service(TypeScriptApi);
+    if (!ts.isCallExpression(node)) {
+      return yield* typeParserIssue("Node is not a call expression", void 0, node);
+    }
+    if (node.arguments.length === 0) {
+      return yield* typeParserIssue("Node has no arguments", void 0, node);
+    }
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) {
+      return yield* typeParserIssue("Node is not a function expression", void 0, node);
+    }
+    if (generatorFunction.asteriskToken === void 0) {
+      return yield* typeParserIssue(
+        "Node is not a generator function",
+        void 0,
+        node
+      );
+    }
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+      return yield* typeParserIssue(
+        "Node is not a property access expression",
+        void 0,
+        node
+      );
+    }
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "fnUntraced") {
+      return yield* typeParserIssue(
+        "Call expression name is not 'fnUntraced'",
+        void 0,
+        node
+      );
+    }
+    const effectModule = yield* importedEffectModule(propertyAccess.expression);
+    return {
+      node,
+      effectModule,
+      generatorFunction,
+      body: generatorFunction.body,
+      functionStar: generatorFunction.getFirstToken()
+    };
+  }
+);
+var effectFnGen = fn("TypeParser.effectFnGen")(function* (node) {
+  const ts = yield* service(TypeScriptApi);
+  if (!ts.isCallExpression(node)) {
+    return yield* typeParserIssue("Node is not a call expression", void 0, node);
+  }
+  if (node.arguments.length === 0) {
+    return yield* typeParserIssue("Node has no arguments", void 0, node);
+  }
+  const generatorFunction = node.arguments[0];
+  if (!ts.isFunctionExpression(generatorFunction)) {
+    return yield* typeParserIssue(
+      "Node is not a function expression",
+      void 0,
+      node
+    );
+  }
+  if (generatorFunction.asteriskToken === void 0) {
+    return yield* typeParserIssue(
+      "Node is not a generator function",
+      void 0,
+      node
+    );
+  }
+  const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+  if (!ts.isPropertyAccessExpression(expressionToTest)) {
+    return yield* typeParserIssue(
+      "Node is not a property access expression",
+      void 0,
+      node
+    );
+  }
+  const propertyAccess = expressionToTest;
+  if (propertyAccess.name.text !== "fn") {
+    return yield* typeParserIssue(
+      "Call expression name is not 'fn'",
+      void 0,
+      node
+    );
+  }
+  const effectModule = yield* importedEffectModule(propertyAccess.expression);
+  return {
+    node,
+    generatorFunction,
+    effectModule,
+    body: generatorFunction.body,
+    functionStar: generatorFunction.getFirstToken()
+  };
+});
+var returnYieldEffectBlock = fn("TypeParser.returnYieldEffectBlock")(function* (body) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  if (ts.isBlock(body) && body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
+    const nodeToCheck = body.statements[0].expression.expression;
+    const type = typeChecker.getTypeAtLocation(nodeToCheck);
+    yield* effectType(type, nodeToCheck);
+    return nodeToCheck;
+  }
+  return yield* typeParserIssue(
+    "Node is not a return statement with a yield expression",
+    void 0,
+    body
+  );
+});
+var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
+  function* (type, atLocation) {
+    return {
+      A: yield* varianceStructInvariantType(type, atLocation, "_A"),
+      I: yield* varianceStructInvariantType(type, atLocation, "_I"),
+      R: yield* varianceStructCovariantType(type, atLocation, "_R")
+    };
+  }
+);
+var effectSchemaType = fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  yield* pipeableType(type, atLocation);
+  const ast = typeChecker.getPropertyOfType(type, "ast");
+  if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
+  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  );
+  propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(effectSchemaVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
+    }
+  }
+  return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+});
+
+// src/diagnostics/floatingEffect.ts
+var floatingEffect = createDiagnostic({
+  name: "effect/floatingEffect",
+  code: 3,
+  apply: fn("floatingEffect.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    function isFloatingExpression(node) {
+      if (!ts.isExpressionStatement(node)) return false;
+      if (!(ts.isBlock(node.parent) || ts.isSourceFile(node.parent))) return false;
+      const expression = node.expression;
+      if (ts.isBinaryExpression(expression) && expression.operatorToken && expression.operatorToken.kind === ts.SyntaxKind.EqualsToken) return false;
+      return true;
+    }
+    const effectDiagnostics = [];
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (!isFloatingExpression(node)) continue;
+      const type = typeChecker.getTypeAtLocation(node.expression);
+      const effect = yield* option(effectType(type, node.expression));
+      if (isSome2(effect)) {
+        const allowedFloatingEffects = yield* pipe(
+          fiberType(type, node.expression),
+          orElse(() => effectSubtype(type, node.expression)),
+          option
+        );
+        if (isNone2(allowedFloatingEffects)) {
+          effectDiagnostics.push({
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Effect must be yielded or assigned to a variable.`,
+            fixes: []
+          });
+        }
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/missingEffectContext.ts
+var missingEffectContext = createDiagnostic({
+  name: "effect/missingEffectContext",
+  code: 1,
+  apply: fn("missingEffectContext.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeOrder = yield* deterministicTypeOrder;
+    const checkForMissingContextTypes = fn(
+      "missingEffectContext.apply.checkForMissingContextTypes"
+    )(function* (node, expectedType, valueNode, realType) {
+      const expectedEffect = yield* effectType(
+        expectedType,
+        node
+      );
+      const realEffect = yield* effectType(
+        realType,
+        valueNode
+      );
+      return yield* getMissingTypeEntriesInTargetType(
+        realEffect.R,
+        expectedEffect.R
+      );
+    });
+    const effectDiagnostics = [];
+    const sortTypes = sort(typeOrder);
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      const missingContext = yield* pipe(
+        checkForMissingContextTypes(
+          node,
+          expectedType,
+          valueNode,
+          realType
+        ),
+        orElse(() => succeed([]))
+      );
+      if (missingContext.length > 0) {
+        effectDiagnostics.push(
+          {
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+            fixes: []
+          }
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/missingEffectError.ts
+var missingEffectError = createDiagnostic({
+  name: "effect/missingEffectError",
+  code: 1,
+  apply: fn("missingEffectError.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeOrder = yield* deterministicTypeOrder;
+    const checkForMissingErrorTypes = fn("missingEffectError.apply.checkForMissingErrorTypes")(
+      function* (node, expectedType, valueNode, realType) {
+        const expectedEffect = yield* effectType(
+          expectedType,
+          node
+        );
+        const realEffect = yield* effectType(
+          realType,
+          valueNode
+        );
+        return yield* getMissingTypeEntriesInTargetType(
+          realEffect.E,
+          expectedEffect.E
+        );
+      }
+    );
+    const effectDiagnostics = [];
+    const sortTypes = sort(typeOrder);
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      const missingContext = yield* pipe(
+        checkForMissingErrorTypes(
+          node,
+          expectedType,
+          valueNode,
+          realType
+        ),
+        orElse(() => succeed([]))
+      );
+      if (missingContext.length > 0) {
+        effectDiagnostics.push(
+          {
+            node,
+            category: ts.DiagnosticCategory.Error,
+            messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+            fixes: []
+          }
+        );
+      }
+    }
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/missingStarInYieldEffectGen.ts
+var missingStarInYieldEffectGen = createDiagnostic({
+  name: "effect/missingStarInYieldEffectGen",
+  code: 4,
+  apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const effectDiagnostics = [];
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const brokenYields = /* @__PURE__ */ new Set();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const functionStarNode = ts.findAncestor(
+          node,
+          (_) => (ts.isFunctionExpression(_) || ts.isMethodDeclaration(_)) && _.asteriskToken !== void 0
+        );
+        if (functionStarNode && functionStarNode.parent) {
+          const effectGenNode = functionStarNode.parent;
+          const effectGenLike = yield* pipe(
+            effectGen(effectGenNode),
+            orElse(() => effectFnUntracedGen(effectGenNode)),
+            orElse(() => effectFnGen(effectGenNode)),
+            option
+          );
+          if (isSome2(effectGenLike)) {
+            if (effectGenLike.value.functionStar) {
+              brokenGenerators.add(effectGenLike.value.functionStar);
+            }
+            brokenYields.add(node);
+          }
+        }
+      }
+    }
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
+        fixes: []
+      })
+    );
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? [{
+        fixName: "missingStarInYieldEffectGen_fix",
+        description: "Replace yield with yield*",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createYieldExpression(
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              node.expression
+            )
+          );
+        })
+      }] : [];
+      effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
+        fixes: fix
+      });
+    });
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/multipleEffectVersions.ts
+var effectVersionsCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
+var multipleEffectVersions = createDiagnostic({
+  name: "effect/multipleEffectVersions",
+  code: 6,
+  apply: fn("multipleEffectVersions.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(PluginOptions);
+    const effectDiagnostics = [];
+    if (!options.multipleEffectCheck) return [];
+    if (sourceFile.statements.length < 1) return [];
+    const effectVersions = effectVersionsCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = "resolvedModules" in program && typeof program.resolvedModules === "object" && "size" in program.resolvedModules ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || 0;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      if ("forEachResolvedModule" in program && typeof program.forEachResolvedModule === "function") {
+        program.forEachResolvedModule((_) => {
+          if (_ && _.resolvedModule && _.resolvedModule.packageId && _.resolvedModule.packageId.name === "effect" && !(_.resolvedModule.packageId.version in effectVersions)) {
+            effectVersions[_.resolvedModule.packageId.version] = {
+              resolvedFileName: _.resolvedModule.resolvedFileName
+            };
+          }
+        });
+      }
+      effectVersionsCache.set(sourceFile.fileName, effectVersions);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
+    }
+    if (Object.keys(effectVersions).length > 1) {
+      const versions = Object.keys(effectVersions).map((version) => `version ${version}`);
+      effectDiagnostics.push({
+        node: sourceFile.statements[0],
+        category: ts.DiagnosticCategory.Warning,
+        messageText: `Seems like in this project there are multiple effect versions loaded (${versions.join(", ")}). This may cause unexpected type errors and runtime behaviours. If you are ok with that, you can disable this warning by adding "multipleEffectCheck": false to the Effect LSP options inside your tsconfig.json`,
+        fixes: []
+      });
+    }
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics/unnecessaryEffectGen.ts
+var unnecessaryEffectGen = createDiagnostic({
+  name: "effect/unnecessaryEffectGen",
+  code: 5,
+  apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile) {
+    const ts = yield* service(TypeScriptApi);
+    const effectDiagnostics = [];
+    const unnecessaryGenerators = /* @__PURE__ */ new Map();
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const maybeNode = yield* pipe(
+        effectGen(node),
+        flatMap2(({ body }) => returnYieldEffectBlock(body)),
+        option
+      );
+      if (isSome2(maybeNode)) {
+        if (isSome2(maybeNode)) {
+          unnecessaryGenerators.set(node, maybeNode.value);
+        }
+      }
+    }
+    unnecessaryGenerators.forEach(
+      (yieldedResult, effectGenCall) => effectDiagnostics.push({
+        node: effectGenCall,
+        category: ts.DiagnosticCategory.Suggestion,
+        messageText: `This Effect.gen contains a single return statement.`,
+        fixes: [{
+          fixName: "unnecessaryEffectGen_fix",
+          description: "Remove the Effect.gen, and keep the body",
+          apply: gen(function* () {
+            const textChanges = yield* service(
+              ChangeTracker
+            );
+            textChanges.replaceNode(sourceFile, effectGenCall, yieldedResult);
+          })
+        }]
+      })
+    );
+    return effectDiagnostics;
+  })
+});
+
+// src/diagnostics.ts
+var diagnostics = [
+  multipleEffectVersions,
+  missingEffectContext,
+  missingEffectError,
+  floatingEffect,
+  missingStarInYieldEffectGen,
+  unnecessaryEffectGen
+];
+
+// src/transform.ts
+function transform_default(program, pluginConfig, { addDiagnostic, ts: tsInstance }) {
+  return (_) => {
+    return (sourceFile) => {
+      pipe(
+        getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
+        provideService(TypeScriptApi, tsInstance),
+        provideService(TypeScriptProgram, program),
+        provideService(TypeCheckerApi, program.getTypeChecker()),
+        provideService(
+          TypeCheckerApiCache,
+          makeTypeCheckerApiCache()
+        ),
+        provideService(PluginOptions, parsePluginOptions(pluginConfig)),
+        run,
+        map((_2) => _2.diagnostics),
+        getOrElse(() => [])
+      ).map(addDiagnostic);
+      return sourceFile;
+    };
+  };
+}
+//# sourceMappingURL=transform.js.map