@effect/language-service 0.3.2 → 0.5.0

package/index.js

@@ -0,0 +1,2102 @@
+"use strict";
+
+// 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 adapter = () => function() {
+  let x = arguments[0];
+  for (let i = 1; i < arguments.length; i++) {
+    x = arguments[i](x);
+  }
+  return new GenKindImpl(x);
+};
+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/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+var array = (item) => make((self, that) => {
+  if (self.length !== that.length) {
+    return false;
+  }
+  for (let i = 0; i < self.length; i++) {
+    const isEq = item(self[i], that[i]);
+    if (!isEq) {
+      return false;
+    }
+  }
+  return true;
+});
+
+// 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/Order.js
+var make2 = (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 getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
+var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
+var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var all = (input) => {
+  if (Symbol.iterator in input) {
+    const out2 = [];
+    for (const o of input) {
+      if (isNone2(o)) {
+        return none2();
+      }
+      out2.push(o.value);
+    }
+    return some2(out2);
+  }
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const o = input[key];
+    if (isNone2(o)) {
+      return none2();
+    }
+    out[key] = o.value;
+  }
+  return some2(out);
+};
+var adapter2 = /* @__PURE__ */ adapter();
+var gen = (...args) => {
+  let f;
+  if (args.length === 1) {
+    f = args[0];
+  } else {
+    f = args[1].bind(args[0]);
+  }
+  const iterator = f(adapter2);
+  let state = iterator.next();
+  if (state.done) {
+    return some2(state.value);
+  } else {
+    let current = state.value;
+    if (isGenKind(current)) {
+      current = current.value;
+    } else {
+      current = yieldWrapGet(current);
+    }
+    if (isNone2(current)) {
+      return current;
+    }
+    while (!state.done) {
+      state = iterator.next(current.value);
+      if (!state.done) {
+        current = state.value;
+        if (isGenKind(current)) {
+          current = current.value;
+        } else {
+          current = yieldWrapGet(current);
+        }
+        if (isNone2(current)) {
+          return current;
+        }
+      }
+    }
+    return some2(state.value);
+  }
+};
+
+// src/definition.ts
+function createRefactor(definition) {
+  return definition;
+}
+function createDiagnostic(definition) {
+  return definition;
+}
+
+// src/utils/TypeParser.ts
+var covariantTypeArgument = (type) => {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) return none2();
+  return some2(signatures[0].getReturnType());
+};
+function pipeableType(ts, typeChecker) {
+  return (type, atLocation) => {
+    const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
+    if (!pipeSymbol) return none2();
+    const pipeType = typeChecker.getTypeOfSymbolAtLocation(pipeSymbol, atLocation);
+    const signatures = pipeType.getCallSignatures();
+    if (signatures.length === 0) return none2();
+    return some2(type);
+  };
+}
+function varianceStructCovariantType(ts, typeChecker) {
+  return (type, atLocation, propertyName) => gen(function* (_) {
+    const propertySymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, propertyName)
+    );
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* covariantTypeArgument(propertyType);
+  });
+}
+function effectVarianceStruct(ts, typeChecker) {
+  return (type, atLocation) => all({
+    A: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_A"),
+    E: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_E"),
+    R: varianceStructCovariantType(ts, typeChecker)(type, atLocation, "_R")
+  });
+}
+function effectType(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    yield* pipeableType(ts, typeChecker)(type, atLocation);
+    for (const propertySymbol of typeChecker.getPropertiesOfType(type)) {
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+      const varianceArgs = effectVarianceStruct(ts, typeChecker)(
+        propertyType,
+        atLocation
+      );
+      if (isSome2(varianceArgs)) {
+        return yield* varianceArgs;
+      }
+    }
+    return yield* none2();
+  });
+}
+function fiberType(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    const awaitSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "await")
+    );
+    const pollSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "poll")
+    );
+    if (!awaitSymbol || !pollSymbol) return yield* none2();
+    return effectType(ts, typeChecker)(type, atLocation);
+  });
+}
+function effectSubtype(ts, typeChecker) {
+  return (type, atLocation) => gen(function* (_) {
+    const tagSymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "_tag")
+    );
+    if (!tagSymbol) return yield* none2();
+    return effectType(ts, typeChecker)(type, atLocation);
+  });
+}
+function importedEffectModule(ts, typeChecker) {
+  return (node) => gen(function* () {
+    const type = typeChecker.getTypeAtLocation(node);
+    const propertySymbol = yield* fromNullable(
+      typeChecker.getPropertyOfType(type, "never")
+    );
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
+    return yield* effectType(ts, typeChecker)(propertyType, node).pipe(
+      map(() => node)
+    );
+  });
+}
+function effectGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "gen") return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
+    );
+  });
+}
+function effectFnUntracedGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    if (!ts.isPropertyAccessExpression(node.expression)) return yield* none2();
+    const propertyAccess = node.expression;
+    if (propertyAccess.name.text !== "fnUntraced") return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
+    );
+  });
+}
+function effectFnGen(ts, typeChecker) {
+  return (node) => gen(function* () {
+    if (!ts.isCallExpression(node)) return yield* none2();
+    if (node.arguments.length === 0) return yield* none2();
+    const generatorFunction = node.arguments[0];
+    if (!ts.isFunctionExpression(generatorFunction)) return yield* none2();
+    if (generatorFunction.asteriskToken === void 0) return yield* none2();
+    const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+    if (!ts.isPropertyAccessExpression(expressionToTest)) return yield* none2();
+    const propertyAccess = expressionToTest;
+    if (propertyAccess.name.text !== "fn") return yield* none2();
+    return yield* importedEffectModule(ts, typeChecker)(propertyAccess.expression).pipe(
+      map(() => ({
+        body: generatorFunction.body,
+        functionStar: generatorFunction.getFirstToken()
+      }))
+    );
+  });
+}
+function expectedAndRealType(ts, typeChecker) {
+  return (node) => {
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      const expectedType = typeChecker.getTypeAtLocation(node.name);
+      const realType = typeChecker.getTypeAtLocation(node.initializer);
+      return [[node.name, expectedType, node.initializer, realType]];
+    }
+    if (ts.isCallExpression(node)) {
+      const resolvedSignature = typeChecker.getResolvedSignature(node);
+      if (resolvedSignature) {
+        return resolvedSignature.getParameters().map((parameter, index) => {
+          const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+          const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+          return [node.arguments[index], expectedType, node.arguments[index], realType];
+        });
+      }
+    }
+    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);
+              return [[node, expectedType, node, realType]];
+            }
+          }
+        }
+      }
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+      const expectedType = typeChecker.getTypeAtLocation(node.left);
+      const realType = typeChecker.getTypeAtLocation(node.right);
+      return [[node.left, expectedType, node.right, realType]];
+    }
+    if (ts.isReturnStatement(node) && node.expression) {
+      const expectedType = typeChecker.getContextualType(node.expression);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      if (expectedType) return [[node, expectedType, node, realType]];
+    }
+    if (ts.isArrowFunction(node) && ts.isExpression(node.body)) {
+      const body = node.body;
+      const expectedType = typeChecker.getContextualType(body);
+      const realType = typeChecker.getTypeAtLocation(body);
+      if (expectedType) return [[body, expectedType, body, realType]];
+    }
+    if (ts.isSatisfiesExpression(node)) {
+      const expectedType = typeChecker.getTypeAtLocation(node.type);
+      const realType = typeChecker.getTypeAtLocation(node.expression);
+      return [[node.expression, expectedType, node.expression, realType]];
+    }
+    return [];
+  };
+}
+
+// src/diagnostics/floatingEffect.ts
+var floatingEffect = createDiagnostic({
+  code: 3,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    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 visit = (node) => {
+      if (isFloatingExpression(node)) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const effect = effectType(ts, typeChecker)(type, node.expression);
+        if (isSome2(effect)) {
+          const allowedFloatingEffects = pipe(
+            fiberType(ts, typeChecker)(type, node.expression),
+            orElse(() => effectSubtype(ts, typeChecker)(type, node.expression))
+          );
+          if (isNone2(allowedFloatingEffects)) {
+            effectDiagnostics.push({
+              node,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Effect must be yielded or assigned to a variable.`
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/internal/array.js
+var isNonEmptyArray = (self) => self.length > 0;
+
+// node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Array.js
+var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
+var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
+var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
+var isArray = Array.isArray;
+var isNonEmptyReadonlyArray = isNonEmptyArray;
+var isOutOfBound = (i, as) => i < 0 || i >= as.length;
+var get = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  return isOutOfBound(i, self) ? none2() : some2(self[i]);
+});
+var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
+  const i = Math.floor(index);
+  if (isOutOfBound(i, self)) {
+    throw new Error(`Index ${i} out of bounds`);
+  }
+  return self[i];
+});
+var head = /* @__PURE__ */ get(0);
+var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
+var tailNonEmpty = (self) => self.slice(1);
+var sort = /* @__PURE__ */ dual(2, (self, O) => {
+  const out = Array.from(self);
+  out.sort(O);
+  return out;
+});
+var empty = () => [];
+var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
+    }
+  }
+  return out;
+});
+var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
+  const input = fromIterable(self);
+  if (isNonEmptyReadonlyArray(input)) {
+    const out = [headNonEmpty(input)];
+    const rest = tailNonEmpty(input);
+    for (const r of rest) {
+      if (out.every((a) => !isEquivalent(r, a))) {
+        out.push(r);
+      }
+    }
+    return out;
+  }
+  return [];
+});
+
+// src/utils/AST.ts
+function getNodesContainingRange(ts) {
+  return (sourceFile, textRange) => {
+    const precedingToken = ts.findPrecedingToken(textRange.pos, sourceFile);
+    if (!precedingToken) return empty();
+    let result = empty();
+    let parent = precedingToken;
+    while (parent) {
+      if (parent.end >= textRange.end) {
+        result = pipe(result, append(parent));
+      }
+      parent = parent.parent;
+    }
+    return result;
+  };
+}
+function toTextRange(positionOrRange) {
+  return typeof positionOrRange === "number" ? { end: positionOrRange, pos: positionOrRange } : positionOrRange;
+}
+function isNodeInRange(textRange) {
+  return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
+}
+function findModuleNamedBindings(ts) {
+  return (sourceFile, moduleName) => fromNullable(ts.forEachChild(sourceFile, (node) => {
+    if (!ts.isImportDeclaration(node)) return;
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier)) return;
+    if (moduleSpecifier.text !== moduleName) return;
+    const importClause = node.importClause;
+    if (!importClause) return;
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) return;
+    return namedBindings;
+  }));
+}
+function findModuleNamespaceImportIdentifierName(ts) {
+  return (sourceFile, moduleName) => pipe(
+    findModuleNamedBindings(ts)(sourceFile, moduleName),
+    map(
+      (namedBindings) => {
+        if (!ts.isNamespaceImport(namedBindings)) return;
+        return namedBindings.name.text;
+      }
+    ),
+    flatMap(fromNullable)
+  );
+}
+function findModuleNamedImportIdentifierName(ts) {
+  return (sourceFile, moduleName, namedImport) => pipe(
+    findModuleNamedBindings(ts)(sourceFile, moduleName),
+    map((namedBindings) => {
+      if (!ts.isNamedImports(namedBindings)) return;
+      for (const importSpecifier of namedBindings.elements) {
+        if (importSpecifier.propertyName?.getText() === namedImport) {
+          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
+        }
+      }
+    }),
+    flatMap(fromNullable)
+  );
+}
+function findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker) {
+  return (sourceFile, importName) => {
+    return fromNullable(ts.forEachChild(sourceFile, (node) => {
+      if (!ts.isImportDeclaration(node)) return;
+      if (!node.importClause) return;
+      const namedBindings = node.importClause.namedBindings;
+      if (!namedBindings) return;
+      if (ts.isNamespaceImport(namedBindings)) {
+        const symbol3 = typeChecker.getTypeAtLocation(namedBindings).getSymbol();
+        if (!symbol3 || !symbol3.exports) return;
+        if (!symbol3.exports.has(importName)) return;
+        return namedBindings.name.escapedText;
+      }
+      if (ts.isNamedImports(namedBindings)) {
+        for (const importSpecifier of namedBindings.elements) {
+          const symbol3 = typeChecker.getTypeAtLocation(importSpecifier).getSymbol();
+          if (!symbol3 || !symbol3.exports) return;
+          if (!symbol3.exports.has(importName)) return;
+          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.getText();
+        }
+      }
+    }));
+  };
+}
+function transformAsyncAwaitToEffectGen(ts) {
+  return (node, effectName, onAwait) => {
+    function visitor(_) {
+      if (ts.isAwaitExpression(_)) {
+        const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
+        return ts.factory.createYieldExpression(
+          ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+          onAwait(expression)
+        );
+      }
+      return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
+    }
+    const generatorBody = visitor(node.body);
+    const generator = ts.factory.createFunctionExpression(
+      void 0,
+      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+      void 0,
+      [],
+      [],
+      void 0,
+      generatorBody
+      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+    );
+    const effectGenCallExp = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectName),
+        "gen"
+      ),
+      void 0,
+      [generator]
+    );
+    let currentFlags = ts.getCombinedModifierFlags(node);
+    currentFlags &= ~ts.ModifierFlags.Async;
+    const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
+    if (ts.isArrowFunction(node)) {
+      return ts.factory.createArrowFunction(
+        newModifiers,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        node.equalsGreaterThanToken,
+        effectGenCallExp
+      );
+    }
+    const newBody = ts.factory.createBlock([
+      ts.factory.createReturnStatement(effectGenCallExp)
+    ]);
+    if (ts.isFunctionDeclaration(node)) {
+      return ts.factory.createFunctionDeclaration(
+        newModifiers,
+        node.asteriskToken,
+        node.name,
+        node.typeParameters,
+        node.parameters,
+        void 0,
+        newBody
+      );
+    }
+    return ts.factory.createFunctionExpression(
+      newModifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      void 0,
+      newBody
+    );
+  };
+}
+function addReturnTypeAnnotation(ts, changes) {
+  return (sourceFile, declaration, typeNode) => {
+    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+    const endNode = needParens ? declaration.parameters[0] : closeParen;
+    if (endNode) {
+      if (needParens) {
+        changes.insertNodeBefore(
+          sourceFile,
+          endNode,
+          ts.factory.createToken(ts.SyntaxKind.OpenParenToken)
+        );
+        changes.insertNodeAfter(
+          sourceFile,
+          endNode,
+          ts.factory.createToken(ts.SyntaxKind.CloseParenToken)
+        );
+      }
+      changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " });
+    }
+  };
+}
+function removeReturnTypeAnnotation(ts, changes) {
+  return (sourceFile, declaration) => {
+    const closeParen = ts.findChildOfKind(declaration, ts.SyntaxKind.CloseParenToken, sourceFile);
+    const needParens = ts.isArrowFunction(declaration) && closeParen === void 0;
+    const endNode = needParens ? declaration.parameters[0] : closeParen;
+    if (endNode && declaration.type) {
+      changes.deleteRange(sourceFile, { pos: endNode.end, end: declaration.type.end });
+    }
+  };
+}
+function getEffectModuleIdentifier(ts, typeChecker) {
+  return (sourceFile) => pipe(
+    findModuleNamespaceImportIdentifierName(ts)(sourceFile, "effect/Effect"),
+    orElse(() => findModuleNamedImportIdentifierName(ts)(sourceFile, "effect", "Effect")),
+    orElse(
+      () => findModuleImportIdentifierNameViaTypeChecker(ts, typeChecker)(sourceFile, "Effect")
+    ),
+    getOrElse(
+      () => "Effect"
+    )
+  );
+}
+function simplifyTypeNode(ts) {
+  function collectCallable(typeNode) {
+    if (ts.isParenthesizedTypeNode(typeNode)) return collectCallable(typeNode.type);
+    if (ts.isFunctionTypeNode(typeNode)) {
+      return some2([
+        ts.factory.createCallSignature(typeNode.typeParameters, typeNode.parameters, typeNode.type)
+      ]);
+    }
+    if (ts.isTypeLiteralNode(typeNode)) {
+      const allCallSignatures = typeNode.members.every(ts.isCallSignatureDeclaration);
+      if (allCallSignatures) {
+        return some2(typeNode.members);
+      }
+    }
+    if (ts.isIntersectionTypeNode(typeNode)) {
+      const members = typeNode.types.map(collectCallable);
+      if (members.every(isSome2)) {
+        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
+      }
+    }
+    return none2();
+  }
+  return (typeNode) => {
+    const callSignatures = collectCallable(typeNode);
+    if (isSome2(callSignatures) && callSignatures.value.length > 1) {
+      return ts.factory.createTypeLiteralNode(callSignatures.value);
+    }
+    return typeNode;
+  };
+}
+function isPipeCall(ts) {
+  return (node) => {
+    if (!ts.isCallExpression(node)) return false;
+    const expression = node.expression;
+    if (!ts.isIdentifier(expression)) return false;
+    if (expression.text !== "pipe") return false;
+    return true;
+  };
+}
+function asDataFirstExpression(ts, checker) {
+  return (node, self) => {
+    if (!ts.isCallExpression(node)) return none2();
+    const signature = checker.getResolvedSignature(node);
+    if (!signature) return none2();
+    const callSignatures = checker.getTypeAtLocation(node.expression).getCallSignatures();
+    for (let i = 0; i < callSignatures.length; i++) {
+      const callSignature = callSignatures[i];
+      if (callSignature.parameters.length === node.arguments.length + 1) {
+        return some2(
+          ts.factory.createCallExpression(
+            node.expression,
+            [],
+            [self].concat(node.arguments)
+          )
+        );
+      }
+    }
+    return none2();
+  };
+}
+function deterministicTypeOrder(ts, typeChecker) {
+  return make2((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+}
+
+// src/utils/TypeCheckerApi.ts
+function getMissingTypeEntriesInTargetType(ts, typeChecker) {
+  return (realType, expectedType) => {
+    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;
+  };
+}
+
+// src/diagnostics/missingEffectContext.ts
+var missingEffectContext = createDiagnostic({
+  code: 1,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
+    const visit = (node) => {
+      const entries = expectedAndRealType(ts, typeChecker)(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        const expectedEffect = effectType(ts, typeChecker)(
+          expectedType,
+          node2
+        );
+        if (isNone2(expectedEffect)) continue;
+        const realEffect = effectType(ts, typeChecker)(
+          realType,
+          valueNode
+        );
+        if (isNone2(realEffect)) continue;
+        const missingContext = getMissingTypeEntriesInTargetType(
+          ts,
+          typeChecker
+        )(
+          realEffect.value.R,
+          expectedEffect.value.R
+        );
+        if (missingContext.length > 0) {
+          effectDiagnostics.push(
+            {
+              node: node2,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
+            }
+          );
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics/missingEffectError.ts
+var missingEffectError = createDiagnostic({
+  code: 2,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const sortTypes = sort(deterministicTypeOrder(ts, typeChecker));
+    const visit = (node) => {
+      const entries = expectedAndRealType(ts, typeChecker)(node);
+      for (const [node2, expectedType, valueNode, realType] of entries) {
+        const expectedEffect = effectType(ts, typeChecker)(
+          expectedType,
+          node2
+        );
+        if (isNone2(expectedEffect)) continue;
+        const realEffect = effectType(ts, typeChecker)(
+          realType,
+          valueNode
+        );
+        if (isNone2(realEffect)) continue;
+        const missingErrorTypes = getMissingTypeEntriesInTargetType(
+          ts,
+          typeChecker
+        )(
+          realEffect.value.E,
+          expectedEffect.value.E
+        );
+        if (missingErrorTypes.length > 0) {
+          effectDiagnostics.push(
+            {
+              node: node2,
+              category: ts.DiagnosticCategory.Error,
+              messageText: `Missing '${sortTypes(missingErrorTypes).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
+            }
+          );
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics/missingStarInYieldEffectGen.ts
+var missingStarInYieldEffectGen = createDiagnostic({
+  code: 4,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const brokenYields = /* @__PURE__ */ new Set();
+    const visit = (functionStarNode) => (node) => {
+      if (functionStarNode && ts.isYieldExpression(node) && node.expression && node.asteriskToken === void 0) {
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const effect = effectType(ts, typeChecker)(type, node.expression);
+        if (isSome2(effect)) {
+          brokenGenerators.add(functionStarNode);
+          brokenYields.add(node);
+        }
+      }
+      const effectGenLike = pipe(
+        effectGen(ts, typeChecker)(node),
+        orElse(() => effectFnUntracedGen(ts, typeChecker)(node)),
+        orElse(() => effectFnGen(ts, typeChecker)(node))
+      );
+      if (isSome2(effectGenLike)) {
+        ts.forEachChild(effectGenLike.value.body, visit(effectGenLike.value.functionStar));
+      } else if ((ts.isFunctionExpression(node) || ts.isMethodDeclaration(node)) && node.asteriskToken !== void 0) {
+        ts.forEachChild(node, visit(void 0));
+      } else {
+        ts.forEachChild(node, visit(functionStarNode));
+      }
+    };
+    ts.forEachChild(sourceFile, visit(void 0));
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`
+      })
+    );
+    brokenYields.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Error,
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
+      })
+    );
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics/unnecessaryEffectGen.ts
+var unnecessaryEffectGen = createDiagnostic({
+  code: 5,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      const effectGenLike = effectGen(ts, typeChecker)(node);
+      if (isSome2(effectGenLike)) {
+        const body = effectGenLike.value.body;
+        if (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);
+          const maybeEffect = effectType(ts, typeChecker)(type, nodeToCheck);
+          if (isSome2(maybeEffect)) {
+            brokenGenerators.add(node);
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Warning,
+        messageText: `This Effect.gen is useless here because it only contains a single return statement.`
+      })
+    );
+    return effectDiagnostics;
+  }
+});
+
+// src/diagnostics.ts
+var diagnostics = {
+  missingEffectContext,
+  missingEffectError,
+  floatingEffect,
+  missingStarInYieldEffectGen,
+  unnecessaryEffectGen
+};
+
+// src/quickinfo.ts
+var SymbolDisplayPartEq = make(
+  (fa, fb) => fa.kind === fb.kind && fa.text === fb.text
+);
+var JSDocTagInfoEq = make(
+  (fa, fb) => fa.name === fb.name && typeof fa.text === typeof fb.text && (typeof fa.text !== "undefined" ? array(SymbolDisplayPartEq)(fa.text, fb.text) : true)
+);
+function dedupeJsDocTags(quickInfo) {
+  if (quickInfo.tags) {
+    return {
+      ...quickInfo,
+      tags: dedupeWith(quickInfo.tags, JSDocTagInfoEq)
+    };
+  }
+  return quickInfo;
+}
+function formatTypeForQuickInfo(ts, typeChecker) {
+  return (channelType, channelName) => {
+    const stringRepresentation = typeChecker.typeToString(
+      channelType,
+      void 0,
+      ts.TypeFormatFlags.NoTruncation
+    );
+    return `type ${channelName} = ${stringRepresentation}`;
+  };
+}
+function prependEffectTypeArguments(ts, program) {
+  return (sourceFileName, position, quickInfo) => {
+    const sourceFile = program.getSourceFile(sourceFileName);
+    if (!sourceFile) return quickInfo;
+    const hasTruncationHappened = ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
+    if (!hasTruncationHappened) return quickInfo;
+    const typeChecker = program.getTypeChecker();
+    const effectTypeArgsDocumentation = pipe(
+      getNodesContainingRange(ts)(sourceFile, toTextRange(position)),
+      head,
+      flatMap(
+        (_) => effectType(ts, typeChecker)(typeChecker.getTypeAtLocation(_), _)
+      ),
+      map((_) => [{
+        kind: "text",
+        text: "```ts\n/* Effect Type Parameters */\n" + formatTypeForQuickInfo(ts, typeChecker)(_.A, "Success") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.E, "Failure") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.R, "Requirements") + "\n```\n"
+      }]),
+      getOrElse(() => [])
+    );
+    if (quickInfo.documentation) {
+      return {
+        ...quickInfo,
+        documentation: effectTypeArgsDocumentation.concat(quickInfo.documentation)
+      };
+    }
+    return {
+      ...quickInfo,
+      documentation: effectTypeArgsDocumentation
+    };
+  };
+}
+
+// src/refactors/asyncAwaitToGen.ts
+var asyncAwaitToGen = createRefactor({
+  name: "effect/asyncAwaitToGen",
+  description: "Convert to Effect.gen",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    filter(ts.isFunctionDeclaration),
+    filter((node) => !!node.body),
+    filter(
+      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
+    ),
+    head,
+    map((node) => ({
+      kind: "refactor.rewrite.effect.asyncAwaitToGen",
+      description: "Rewrite to Effect.gen",
+      apply: (changeTracker) => {
+        const effectName = getEffectModuleIdentifier(ts, program.getTypeChecker())(sourceFile);
+        const newDeclaration = transformAsyncAwaitToEffectGen(
+          ts
+        )(
+          node,
+          effectName,
+          (expression) => ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(effectName),
+              "promise"
+            ),
+            void 0,
+            [
+              ts.factory.createArrowFunction(
+                void 0,
+                void 0,
+                [],
+                void 0,
+                void 0,
+                expression
+              )
+            ]
+          )
+        );
+        changeTracker.replaceNode(sourceFile, node, newDeclaration);
+      }
+    }))
+  )
+});
+
+// src/refactors/asyncAwaitToGenTryPromise.ts
+var asyncAwaitToGenTryPromise = createRefactor({
+  name: "effect/asyncAwaitToGenTryPromise",
+  description: "Convert to Effect.gen with failures",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    filter(ts.isFunctionDeclaration),
+    filter((node) => !!node.body),
+    filter(
+      (node) => !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async)
+    ),
+    head,
+    map((node) => ({
+      kind: "refactor.rewrite.effect.asyncAwaitToGenTryPromise",
+      description: "Rewrite to Effect.gen with failures",
+      apply: (changeTracker) => {
+        const effectName = getEffectModuleIdentifier(ts, program.getTypeChecker())(sourceFile);
+        let errorCount = 0;
+        function createErrorADT() {
+          errorCount++;
+          return ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment(
+              "_tag",
+              ts.factory.createAsExpression(
+                ts.factory.createStringLiteral("Error" + errorCount),
+                ts.factory.createTypeReferenceNode("const")
+              )
+            ),
+            ts.factory.createShorthandPropertyAssignment("error")
+          ]);
+        }
+        const newDeclaration = transformAsyncAwaitToEffectGen(
+          ts
+        )(
+          node,
+          effectName,
+          (expression) => ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier(effectName),
+              "tryPromise"
+            ),
+            void 0,
+            [
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(
+                  ts.factory.createIdentifier("try"),
+                  ts.factory.createArrowFunction(
+                    void 0,
+                    void 0,
+                    [],
+                    void 0,
+                    void 0,
+                    expression
+                  )
+                ),
+                ts.factory.createPropertyAssignment(
+                  ts.factory.createIdentifier("catch"),
+                  ts.factory.createArrowFunction(
+                    void 0,
+                    void 0,
+                    [ts.factory.createParameterDeclaration(void 0, void 0, "error")],
+                    void 0,
+                    void 0,
+                    createErrorADT()
+                  )
+                )
+              ])
+            ]
+          )
+        );
+        changeTracker.replaceNode(sourceFile, node, newDeclaration);
+      }
+    }))
+  )
+});
+
+// src/refactors/functionToArrow.ts
+var functionToArrow = createRefactor({
+  name: "effect/functionToArrow",
+  description: "Convert to arrow",
+  apply: (ts) => (sourceFile, textRange) => pipe(
+    pipe(
+      getNodesContainingRange(ts)(sourceFile, textRange),
+      filter(ts.isFunctionDeclaration)
+    ),
+    appendAll(
+      pipe(
+        getNodesContainingRange(ts)(sourceFile, textRange),
+        filter(ts.isMethodDeclaration)
+      )
+    ),
+    filter((node) => !!node.body),
+    filter((node) => !!node.name && isNodeInRange(textRange)(node.name)),
+    head,
+    map(
+      (node) => ({
+        kind: "refactor.rewrite.effect.functionToArrow",
+        description: "Convert to arrow",
+        apply: (changeTracker) => {
+          const body = node.body;
+          let newBody = ts.factory.createBlock(body.statements);
+          if (body.statements.length === 1) {
+            const statement = body.statements[0];
+            if (statement && ts.isReturnStatement(statement) && statement.expression) {
+              newBody = statement.expression;
+            }
+          }
+          let arrowFlags = ts.getCombinedModifierFlags(node);
+          arrowFlags &= ~ts.ModifierFlags.Export;
+          arrowFlags &= ~ts.ModifierFlags.Default;
+          const arrowModifiers = ts.factory.createModifiersFromModifierFlags(arrowFlags);
+          const arrowFunction = ts.factory.createArrowFunction(
+            arrowModifiers,
+            node.typeParameters,
+            node.parameters,
+            void 0,
+            ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+            newBody
+          );
+          let constFlags = ts.getCombinedModifierFlags(node);
+          constFlags &= ~arrowFlags;
+          const constModifiers = ts.factory.createModifiersFromModifierFlags(constFlags);
+          let newDeclaration = node;
+          if (ts.isMethodDeclaration(node)) {
+            newDeclaration = ts.factory.createPropertyDeclaration(
+              constModifiers,
+              node.name,
+              void 0,
+              void 0,
+              arrowFunction
+            );
+          } else if (ts.isFunctionDeclaration(node)) {
+            newDeclaration = ts.factory.createVariableStatement(
+              constModifiers,
+              ts.factory.createVariableDeclarationList(
+                [
+                  ts.factory.createVariableDeclaration(
+                    node.name,
+                    void 0,
+                    void 0,
+                    arrowFunction
+                  )
+                ],
+                ts.NodeFlags.Const
+              )
+            );
+          }
+          changeTracker.replaceNode(sourceFile, node, newDeclaration);
+        }
+      })
+    )
+  )
+});
+
+// src/refactors/pipeableToDatafirst.ts
+var pipeableToDatafirst = createRefactor({
+  name: "effect/pipeableToDatafirst",
+  description: "Rewrite to datafirst",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    filter(isPipeCall(ts)),
+    filter((node) => isNodeInRange(textRange)(node.expression)),
+    filter(
+      (node) => node.arguments.length > 0
+    ),
+    map2((node) => {
+      let newNode = node.arguments[0];
+      let didSomething = false;
+      for (let i = 1; i < node.arguments.length; i++) {
+        const arg = node.arguments[i];
+        const a = asDataFirstExpression(ts, program.getTypeChecker())(arg, newNode);
+        if (isSome2(a)) {
+          newNode = a.value;
+          didSomething = true;
+        } else {
+          if (isPipeCall(ts)(newNode)) {
+            newNode = ts.factory.createCallExpression(
+              ts.factory.createIdentifier("pipe"),
+              [],
+              newNode.arguments.concat([arg])
+            );
+          } else {
+            newNode = ts.factory.createCallExpression(ts.factory.createIdentifier("pipe"), [], [
+              newNode,
+              arg
+            ]);
+          }
+        }
+      }
+      return didSomething ? some2([node, newNode]) : none2();
+    }),
+    filter(isSome2),
+    map2((_) => _.value),
+    head,
+    map(([node, newNode]) => ({
+      kind: "refactor.rewrite.effect.pipeableToDatafirst",
+      description: "Rewrite to datafirst",
+      apply: (changeTracker) => {
+        changeTracker.replaceNode(sourceFile, node, newNode);
+      }
+    }))
+  )
+});
+
+// src/refactors/toggleLazyConst.ts
+var toggleLazyConst = createRefactor({
+  name: "effect/toggleLazyConst",
+  description: "Toggle type annotation",
+  apply: (ts) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    filter(ts.isVariableDeclaration),
+    filter((node) => isNodeInRange(textRange)(node.name)),
+    filter(
+      (node) => !!node.initializer && !(ts.isArrowFunction(node.initializer) && ts.isBlock(node.initializer.body))
+    ),
+    head,
+    map(
+      (node) => ({
+        kind: "refactor.rewrite.effect.toggleLazyConst",
+        description: "Toggle lazy const",
+        apply: (changeTracker) => {
+          const initializer = node.initializer;
+          if (ts.isArrowFunction(initializer) && initializer.parameters.length === 0) {
+            changeTracker.deleteRange(sourceFile, {
+              pos: initializer.body.end,
+              end: initializer.end
+            });
+            changeTracker.deleteRange(sourceFile, {
+              pos: initializer.pos,
+              end: initializer.body.pos
+            });
+            return;
+          }
+          changeTracker.insertText(sourceFile, initializer.pos, " () =>");
+        }
+      })
+    )
+  )
+});
+
+// src/refactors/toggleReturnTypeAnnotation.ts
+var toggleReturnTypeAnnotation = createRefactor({
+  name: "effect/toggleReturnTypeAnnotation",
+  description: "Toggle return type annotation",
+  apply: (ts, program) => (sourceFile, textRange) => {
+    function isConvertibleDeclaration(node) {
+      switch (node.kind) {
+        case ts.SyntaxKind.FunctionDeclaration:
+        case ts.SyntaxKind.FunctionExpression:
+        case ts.SyntaxKind.ArrowFunction:
+        case ts.SyntaxKind.MethodDeclaration:
+          return true;
+        default:
+          return false;
+      }
+    }
+    return pipe(
+      getNodesContainingRange(ts)(sourceFile, textRange),
+      filter(isConvertibleDeclaration),
+      head,
+      map(
+        (node) => ({
+          kind: "refactor.rewrite.effect.toggleReturnTypeAnnotation",
+          description: "Toggle return type annotation",
+          apply: (changeTracker) => {
+            const typeChecker = program.getTypeChecker();
+            if (node.type) {
+              removeReturnTypeAnnotation(ts, changeTracker)(sourceFile, node);
+              return;
+            }
+            const callableType = typeChecker.getTypeAtLocation(node);
+            const returnTypes = callableType.getCallSignatures().map((s) => s.getReturnType());
+            const returnTypeNodes = returnTypes.map(
+              (type) => typeChecker.typeToTypeNode(type, node, ts.NodeBuilderFlags.NoTruncation)
+            ).filter((node2) => !!node2);
+            if (returnTypeNodes.length === 0) return;
+            const returnTypeNode = returnTypeNodes.length === 1 ? returnTypeNodes[0] : ts.factory.createUnionTypeNode(returnTypeNodes);
+            addReturnTypeAnnotation(ts, changeTracker)(
+              sourceFile,
+              node,
+              simplifyTypeNode(ts)(returnTypeNode)
+            );
+          }
+        })
+      )
+    );
+  }
+});
+
+// src/refactors/toggleTypeAnnotation.ts
+var toggleTypeAnnotation = createRefactor({
+  name: "effect/toggleTypeAnnotation",
+  description: "Toggle type annotation",
+  apply: (ts, program) => (sourceFile, textRange) => pipe(
+    getNodesContainingRange(ts)(sourceFile, textRange),
+    filter(
+      (node) => ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)
+    ),
+    filter((node) => isNodeInRange(textRange)(node.name)),
+    filter((node) => !!node.initializer),
+    head,
+    map(
+      (node) => ({
+        kind: "refactor.rewrite.effect.toggleTypeAnnotation",
+        description: "Toggle type annotation",
+        apply: (changeTracker) => {
+          const typeChecker = program.getTypeChecker();
+          if (node.type) {
+            changeTracker.deleteRange(sourceFile, { pos: node.name.end, end: node.type.end });
+            return;
+          }
+          const initializer = node.initializer;
+          const initializerType = typeChecker.getTypeAtLocation(initializer);
+          const initializerTypeNode = typeChecker.typeToTypeNode(
+            initializerType,
+            node,
+            ts.NodeBuilderFlags.NoTruncation
+          );
+          if (initializerTypeNode) {
+            changeTracker.insertNodeAt(
+              sourceFile,
+              node.name.end,
+              simplifyTypeNode(ts)(initializerTypeNode),
+              {
+                prefix: ": "
+              }
+            );
+          }
+        }
+      })
+    )
+  )
+});
+
+// src/refactors/wrapWithPipe.ts
+var wrapWithPipe = createRefactor({
+  name: "effect/wrapWithPipe",
+  description: "Wrap with pipe",
+  apply: () => (sourceFile, textRange) => {
+    if (textRange.end - textRange.pos === 0) return none2();
+    return some2({
+      kind: "refactor.rewrite.effect.wrapWithPipe",
+      description: `Wrap with pipe(...)`,
+      apply: (changeTracker) => {
+        changeTracker.insertText(sourceFile, textRange.pos, "pipe(");
+        changeTracker.insertText(sourceFile, textRange.end, ")");
+      }
+    });
+  }
+});
+
+// src/refactors.ts
+var refactors = {
+  asyncAwaitToGen,
+  asyncAwaitToGenTryPromise,
+  functionToArrow,
+  pipeableToDatafirst,
+  toggleLazyConst,
+  toggleReturnTypeAnnotation,
+  toggleTypeAnnotation,
+  wrapWithPipe
+};
+
+// src/index.ts
+var init = (modules) => {
+  const ts = modules.typescript;
+  function create(info) {
+    const languageService = info.languageService;
+    const pluginOptions = {
+      diagnostics: info.config && "diagnostics" in info.config && typeof info.config.diagnostics === "boolean" ? info.config.diagnostics : true,
+      quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true
+    };
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(info.languageService)) {
+      proxy[k] = (...args) => languageService[k].apply(languageService, args);
+    }
+    proxy.getSemanticDiagnostics = (fileName, ...args) => {
+      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
+      const program = languageService.getProgram();
+      if (pluginOptions.diagnostics && program) {
+        const effectDiagnostics = pipe(
+          fromNullable(program.getSourceFile(fileName)),
+          map(
+            (sourceFile) => pipe(
+              Object.values(diagnostics).map(
+                (diagnostic) => pipe(
+                  diagnostic.apply(modules.typescript, program, pluginOptions)(
+                    sourceFile,
+                    applicableDiagnostics
+                  ).map((_) => ({
+                    file: sourceFile,
+                    start: _.node.getStart(sourceFile),
+                    length: _.node.getEnd() - _.node.getStart(sourceFile),
+                    messageText: _.messageText,
+                    category: _.category,
+                    code: diagnostic.code,
+                    source: "effect"
+                  }))
+                )
+              ),
+              (_) => _.reduce(
+                (arr, maybeRefactor) => arr.concat(maybeRefactor),
+                []
+              )
+            )
+          ),
+          getOrElse(() => [])
+        );
+        return effectDiagnostics.concat(applicableDiagnostics);
+      }
+      return applicableDiagnostics;
+    };
+    proxy.getApplicableRefactors = (...args) => {
+      const applicableRefactors = languageService.getApplicableRefactors(...args);
+      const [fileName, positionOrRange] = args;
+      const program = languageService.getProgram();
+      if (program) {
+        const textRange = toTextRange(positionOrRange);
+        const effectRefactors = pipe(
+          fromNullable(program.getSourceFile(fileName)),
+          map(
+            (sourceFile) => pipe(
+              Object.values(refactors).map(
+                (refactor) => pipe(
+                  refactor.apply(modules.typescript, program, pluginOptions)(
+                    sourceFile,
+                    textRange
+                  ),
+                  map((_) => ({
+                    name: refactor.name,
+                    description: refactor.description,
+                    actions: [{
+                      name: refactor.name,
+                      description: _.description,
+                      kind: _.kind
+                    }]
+                  }))
+                )
+              ),
+              (_) => _.reduce(
+                (arr, maybeRefactor) => arr.concat(isSome2(maybeRefactor) ? [maybeRefactor.value] : []),
+                []
+              )
+            )
+          ),
+          getOrElse(() => [])
+        );
+        info.project.projectService.logger.info(
+          "[@effect/language-service] possible refactors are " + JSON.stringify(effectRefactors)
+        );
+        return applicableRefactors.concat(effectRefactors);
+      }
+      return applicableRefactors;
+    };
+    proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, ...args) => {
+      const program = languageService.getProgram();
+      if (program) {
+        for (const refactor of Object.values(refactors)) {
+          if (refactor.name === refactorName) {
+            const textRange = toTextRange(positionOrRange);
+            const possibleRefactor = pipe(
+              fromNullable(program.getSourceFile(fileName)),
+              flatMap(
+                (sourceFile) => refactor.apply(modules.typescript, program, pluginOptions)(
+                  sourceFile,
+                  textRange
+                )
+              )
+            );
+            if (isNone2(possibleRefactor)) {
+              info.project.projectService.logger.info(
+                "[@effect/language-service] requested refactor " + refactorName + " is not applicable"
+              );
+              return { edits: [] };
+            }
+            const formatContext = ts.formatting.getFormatContext(
+              formatOptions,
+              info.languageServiceHost
+            );
+            const edits = ts.textChanges.ChangeTracker.with(
+              {
+                formatContext,
+                host: info.languageServiceHost,
+                preferences: preferences || {}
+              },
+              (changeTracker) => possibleRefactor.value.apply(changeTracker)
+            );
+            return { edits };
+          }
+        }
+      }
+      return languageService.getEditsForRefactor(
+        fileName,
+        formatOptions,
+        positionOrRange,
+        refactorName,
+        actionName,
+        preferences,
+        ...args
+      );
+    };
+    proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
+      const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
+      if (pluginOptions.quickinfo && quickInfo) {
+        const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
+        const program = languageService.getProgram();
+        if (program) {
+          return prependEffectTypeArguments(ts, program)(fileName, position, dedupedTagsQuickInfo);
+        }
+        return dedupedTagsQuickInfo;
+      }
+      return quickInfo;
+    };
+    return proxy;
+  }
+  return { create };
+};
+module.exports = init;
+//# sourceMappingURL=index.js.map