@effect/language-service 0.0.20 → 0.1.0

package/index.cjs

@@ -0,0 +1,1457 @@
+"use strict";
+
+// node_modules/.pnpm/effect@2.0.0-next.59/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@2.0.0-next.59/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "2.0.0-next.59";
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${moduleVersion}`);
+if (!(globalStoreId in globalThis)) {
+  ;
+  globalThis[globalStoreId] = /* @__PURE__ */ new Map();
+}
+var globalStore = globalThis[globalStoreId];
+var globalValue = (id, compute) => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id);
+};
+
+// node_modules/.pnpm/effect@2.0.0-next.59/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);
+var isNullable = (input) => input === null || input === void 0;
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Utils.js
+var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
+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 defaultIncHi = 335903614;
+var defaultIncLo = 4150755663;
+var MUL_HI = 1481765933 >>> 0;
+var MUL_LO = 1284865837 >>> 0;
+var BIT_53 = 9007199254740992;
+var BIT_27 = 134217728;
+var PCGRandom = class {
+  _state;
+  constructor(seedHi, seedLo, incHi, incLo) {
+    if (isNullable(seedLo) && isNullable(seedHi)) {
+      seedLo = Math.random() * 4294967295 >>> 0;
+      seedHi = 0;
+    } else if (isNullable(seedLo)) {
+      seedLo = seedHi;
+      seedHi = 0;
+    }
+    if (isNullable(incLo) && isNullable(incHi)) {
+      incLo = this._state ? this._state[3] : defaultIncLo;
+      incHi = this._state ? this._state[2] : defaultIncHi;
+    } else if (isNullable(incLo)) {
+      incLo = incHi;
+      incHi = 0;
+    }
+    this._state = new Int32Array([0, 0, incHi >>> 0, ((incLo || 0) | 1) >>> 0]);
+    this._next();
+    add64(this._state, this._state[0], this._state[1], seedHi >>> 0, seedLo >>> 0);
+    this._next();
+    return this;
+  }
+  /**
+   * Returns a copy of the internal state of this random number generator as a
+   * JavaScript Array.
+   *
+   * @category getters
+   * @since 2.0.0
+   */
+  getState() {
+    return [this._state[0], this._state[1], this._state[2], this._state[3]];
+  }
+  /**
+   * Restore state previously retrieved using `getState()`.
+   *
+   * @since 2.0.0
+   */
+  setState(state) {
+    this._state[0] = state[0];
+    this._state[1] = state[1];
+    this._state[2] = state[2];
+    this._state[3] = state[3] | 1;
+  }
+  /**
+   * Get a uniformly distributed 32 bit integer between [0, max).
+   *
+   * @category getter
+   * @since 2.0.0
+   */
+  integer(max) {
+    if (!max) {
+      return this._next();
+    }
+    max = max >>> 0;
+    if ((max & max - 1) === 0) {
+      return this._next() & max - 1;
+    }
+    let num = 0;
+    const skew = (-max >>> 0) % max >>> 0;
+    for (num = this._next(); num < skew; num = this._next()) {
+    }
+    return num % max;
+  }
+  /**
+   * Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
+   * 53 bits of precision (every bit of the mantissa is randomized).
+   *
+   * @category getters
+   * @since 2.0.0
+   */
+  number() {
+    const hi = (this._next() & 67108863) * 1;
+    const lo = (this._next() & 134217727) * 1;
+    return (hi * BIT_27 + lo) / BIT_53;
+  }
+  /** @internal */
+  _next() {
+    const oldHi = this._state[0] >>> 0;
+    const oldLo = this._state[1] >>> 0;
+    mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
+    add64(this._state, this._state[0], this._state[1], this._state[2], this._state[3]);
+    let xsHi = oldHi >>> 18;
+    let xsLo = (oldLo >>> 18 | oldHi << 14) >>> 0;
+    xsHi = (xsHi ^ oldHi) >>> 0;
+    xsLo = (xsLo ^ oldLo) >>> 0;
+    const xorshifted = (xsLo >>> 27 | xsHi << 5) >>> 0;
+    const rot = oldHi >>> 27;
+    const rot2 = (-rot >>> 0 & 31) >>> 0;
+    return (xorshifted >>> rot | xorshifted << rot2) >>> 0;
+  }
+};
+function mul64(out, aHi, aLo, bHi, bLo) {
+  let c1 = (aLo >>> 16) * (bLo & 65535) >>> 0;
+  let c0 = (aLo & 65535) * (bLo >>> 16) >>> 0;
+  let lo = (aLo & 65535) * (bLo & 65535) >>> 0;
+  let hi = (aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;
+  c0 = c0 << 16 >>> 0;
+  lo = lo + c0 >>> 0;
+  if (lo >>> 0 < c0 >>> 0) {
+    hi = hi + 1 >>> 0;
+  }
+  c1 = c1 << 16 >>> 0;
+  lo = lo + c1 >>> 0;
+  if (lo >>> 0 < c1 >>> 0) {
+    hi = hi + 1 >>> 0;
+  }
+  hi = hi + Math.imul(aLo, bHi) >>> 0;
+  hi = hi + Math.imul(aHi, bLo) >>> 0;
+  out[0] = hi;
+  out[1] = lo;
+}
+function add64(out, aHi, aLo, bHi, bLo) {
+  let hi = aHi + bHi >>> 0;
+  const lo = aLo + bLo >>> 0;
+  if (lo >>> 0 < aLo >>> 0) {
+    hi = hi + 1 | 0;
+  }
+  out[0] = hi;
+  out[1] = lo;
+}
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Hash.js
+var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
+var pcgr = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/pcgr"), () => new PCGRandom());
+var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
+var hash = (self) => {
+  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");
+      }
+      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(pcgr.integer(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(n);
+};
+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));
+
+// node_modules/.pnpm/effect@2.0.0-next.59/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") && self !== null && that !== null) {
+    if (isEqual(self) && isEqual(that)) {
+      return hash(self) === hash(that) && self[symbol2](that);
+    }
+  }
+  return false;
+}
+var isEqual = (u) => hasProperty(u, symbol2);
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Inspectable.js
+var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var toJSON = (x) => {
+  if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
+    return x.toJSON();
+  } else if (Array.isArray(x)) {
+    return x.map(toJSON);
+  }
+  return x;
+};
+var format = (x) => JSON.stringify(x, null, 2);
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/Pipeable.js
+var pipeArguments = (self, args) => {
+  switch (args.length) {
+    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@2.0.0-next.59/node_modules/effect/dist/esm/internal/opCodes/effect.js
+var OP_COMMIT = "Commit";
+
+// node_modules/.pnpm/effect@2.0.0-next.59/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: moduleVersion
+};
+var sinkVariance = {
+  /* c8 ignore next */
+  _R: (_) => _,
+  /* c8 ignore next */
+  _E: (_) => _,
+  /* c8 ignore next */
+  _In: (_) => _,
+  /* c8 ignore next */
+  _L: (_) => _,
+  /* c8 ignore next */
+  _Z: (_) => _
+};
+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 random(this);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var StructuralPrototype = {
+  [symbol]() {
+    return 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@2.0.0-next.59/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(that.value, this.value);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.value));
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag,
+      value: toJSON(this.value)
+    };
+  }
+});
+var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
+  _tag: "None",
+  _op: "None",
+  [symbol2](that) {
+    return isOption(that) && isNone(that);
+  },
+  [symbol]() {
+    return combine(hash(this._tag));
+  },
+  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@2.0.0-next.59/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));
+
+// node_modules/.pnpm/effect@2.0.0-next.59/node_modules/effect/dist/esm/ReadonlyArray.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 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 head = /* @__PURE__ */ get(0);
+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;
+});
+
+// src/definition.ts
+function createRefactor(definition) {
+  return definition;
+}
+
+// src/utils/AST.ts
+var NoSuchSourceFile = class {
+  constructor(fileName) {
+    this.fileName = fileName;
+  }
+  _tag = "NoSuchSourceFile";
+};
+function getSourceFile(program) {
+  return (fileName) => {
+    const sourceFile = program.getSourceFile(fileName);
+    if (!sourceFile) {
+      throw new NoSuchSourceFile(fileName);
+    }
+    return sourceFile;
+  };
+}
+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) {
+      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?.escapedText === namedImport) {
+          return importSpecifier.name?.escapedText || importSpecifier.propertyName?.escapedText;
+        }
+      }
+    }),
+    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?.escapedText;
+        }
+      }
+    }));
+  };
+}
+function transformAsyncAwaitToEffectGen(ts, preferredEffectGenAdapterName) {
+  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),
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier(preferredEffectGenAdapterName),
+            void 0,
+            [
+              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,
+      [],
+      [ts.factory.createParameterDeclaration(void 0, void 0, preferredEffectGenAdapterName)],
+      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();
+  };
+}
+
+// src/refactors/asyncAwaitToGen.ts
+var asyncAwaitToGen = createRefactor({
+  name: "effect/asyncAwaitToGen",
+  description: "Convert to Effect.gen",
+  apply: (ts, program, options) => (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,
+          options.preferredEffectGenAdapterName
+        )(
+          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, options) => (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,
+          options.preferredEffectGenAdapterName
+        )(
+          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(ts.isVariableDeclaration),
+    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 = {
+      preferredEffectGenAdapterName: info.config.preferredEffectGenAdapterName ?? "_"
+    };
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(info.languageService)) {
+      proxy[k] = (...args) => languageService[k].apply(languageService, args);
+    }
+    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(
+          getSourceFile(program)(fileName),
+          (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] : []),
+              []
+            )
+          )
+        );
+        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 sourceFile = getSourceFile(program)(fileName);
+            const textRange = toTextRange(positionOrRange);
+            const possibleRefactor = 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
+      );
+    };
+    return proxy;
+  }
+  return { create };
+};
+module.exports = init;